agent-room-of-requirements

Use Strata, the Legacy Code Labs macOS visual-spec app, through its local Streamable HTTP MCP server. Trigger when Codex needs to create, read, validate, update, version, diff, or restore Strata diagrams; build visual specs from user flows, discovery trees, architecture sketches, or D2; diagnose Strata MCP setup; or verify a feature against a shared Strata canvas.

Use Clarity, the LegacyCodeHQ structural design CLI, for dependency impact graphs, architecture/refactoring verification, before-commit design checks, code review context, cycle/module/workspace exploration, AGENTS.md Clarity setup, or rebuilding/probing Clarity command availability. Use when Codex needs to run or interpret clarity show, watch, languages, extensions, modules, cycles, workspace, setup, or version-specific Clarity commands.

Plan, build, harden, and review Kotlin backend services with Spring Boot, Ktor, coroutines, typed configuration, persistence, migrations, testing, security, resilience, and operations. Use for Kotlin HTTP APIs, workers, service refactors, production-readiness reviews, or JVM backend architecture decisions.

Reliability-first Kotlin skill for implementing, refactoring, or reviewing Kotlin libraries, CLIs, JVM modules, shared domain code, coroutine code, and Java interop boundaries. Use when work needs null-safety discipline, value and sealed types, idiomatic scope-function use, typed errors, structured concurrency, testing, or JVM quality gates.

Reliability-first Python skill for implementing, refactoring, or reviewing Python packages, CLIs, services, scripts, async code, tests, and typed modules. Use when work needs type hints, dataclasses, boundary parsing, exception design, context managers, asyncio cancellation, packaging, pytest or unittest strategy, ruff, mypy, pyright, or runtime safety.

Analyze images using local Ollama vision model (qwen3.5:4b) with automatic pre-resizing and filename sanitization for reliable processing.

Save the most recent visible conversation text from the active Codex thread into a timestamped Markdown checkpoint file in the current repo root. Use when the user asks to back up the last few chat messages, dump recent thread context to disk, preserve a resume point before context loss, or create a lightweight conversation recovery file.

Unify executable specifications, Tauri-first reliability, and Rust/Tauri architecture for desktop apps with a Rust backend and web frontend. Use when Codex needs to convert Tauri requests into REQ-TAURI contracts, choose command/state/capability/lifecycle boundaries, apply typed error and async safety patterns, select verification strategy, scope permissions and sidecars safely, or produce implementation plans and quality gates for Tauri 2 applications.

Use when someone asks why a dedicated Rust web backend skill exists, how it differs from broader Rust planning or reliability skills, when to use rust-web-backend-delivery-01 versus other Rust skills, or wants a plain-English explanation of backend-specific delivery patterns such as handlers, persistence, tracing, auth, retries, migrations, and background work.

Plan, build, harden, and review Rust HTTP backends and APIs with executable requirements, integration-first testing, persistence and migration safety, config and secrets discipline, structured telemetry, auth and session handling, external API clients, deployment safety, idempotency, retries, and background processing. Use for Actix-, Axum-, or similar Rust web services, not generic Rust libraries, CLIs, parsers, or FFI code.

Use when someone asks to understand, explain, or document how a part of the codebase works and wants a visual or ELI5 output - generates an interactive scrollable HTML explainer with metaphors, diagrams, and progressive disclosure

Unify executable specifications, idiomatic Rust architecture, and reliability-first Rust delivery for libraries, CLIs, async services, app backends, and contained FFI wrappers. Use when Codex needs to decide how to approach Rust work, convert requests into REQ-RUST contracts, choose L1/L2/L3 boundaries, apply typed-error and async/concurrency safety patterns, select verification strategy, enforce four-word naming where feasible, or produce quality gates and implementation plans.

Create high-quality terminal-native ASCII explainer pages and diagrams for architecture, flows, sequences, trees, state transitions, comparisons, and codebase walkthroughs. Use when Codex needs to explain systems in plain text, .txt-style output, raw Markdown code blocks, commit messages, design notes, or terminals where the result must survive copy-paste without Unicode box-drawing, images, or Mermaid.

Conduct deep research and multi-perspective exploration for complex questions, decisions, and problem spaces. Use when the user asks for rigorous analysis, deeper context, strategic options, premise checking, thesis testing, creative but defensible alternatives, or a nuanced answer that goes beyond summary and must separate sourced facts from inference.

Explain AI-native engineering, four-word naming, TDD-first workflows, context engineering, and agent design in plain English. Use when Codex needs to turn dense notes, architecture writeups, or prompt-engineering guidance into an ELI5 markdown explainer with simple analogies, low-drama tone, and crisp takeaways.

Design and implement Rust features with executable specifications, TDD-first delivery, and idiomatic architecture. Use when Codex is asked to write or refactor Rust crates, services, CLIs, async workflows, or embedded components and must enforce requirement traceability, layered architecture across L1, L2, and L3 boundaries, four-word naming discipline for new symbols, and test-validated performance and concurrency claims.

Reliability-first MERN + TypeScript coding guide for Express, React, Mongoose, and MongoDB. Use when Codex needs to implement, refactor, review, or harden classic MERN applications with validated request boundaries, safe Mongoose query and write patterns, auth and security defaults, pagination or indexing decisions, and production-ready frontend or API reliability.

Create generative art and creative coding outputs through p5.js, canvas, particle systems, flow fields, cellular systems, or mathematically driven visual experiments. Use when the user wants code-based art, computational aesthetics, interactive sketches, or concept-driven visual work rather than product UI.

Use when implementation is complete and the user wants to commit, push, publish, preserve, or clean up the branch. Handles branch-finish decisions, explicit commit-and-push requests, and concise next-step handoff after the work has been saved.

Build, refactor, and review React plus TypeScript plus Three.js frontends, especially interactive 3D visualization UIs using react-force-graph, Zustand, TanStack Query, Vite, and performance-sensitive scene logic. Use when the task involves 3D canvases, graph exploration, camera controls, scene state, or realtime visual interaction in React.

Track resumable progress for TDD work by capturing red, green, and refactor state, exact test status, implementation progress, and next steps in a structured journal. Use when TDD spans interruptions, multiple files, multiple crates, or handoffs and Codex must preserve precise resume context.

Simulate multiple plausible futures for a decision, architecture choice, strategy question, or difficult conversation. Use when the user needs scenario planning, causal step-by-step timelines, risk comparison, regret analysis, or a clearer view of tradeoffs across possible paths before choosing.

Run evidence-based multi-agent technical debates using a shared markdown file that agents edit in place with strikethrough disagreements, dispute logs, and convergence rules. Use when the user asks to compare architecture options, challenge a refactor, stage adversarial code review, or resolve non-trivial implementation tradeoffs across agents such as Codex, Claude, or Gemini.

Build a rough codebase dependency map using CLI-only tooling and pointer-first spans. Use when Codex needs fast architecture orientation, lightweight import and include edges, and file:start:end context selection without running a persistent indexer or database.

Convert software requests into executable specifications with measurable WHEN...THEN...SHALL contracts, traceable requirement IDs, and TDD-first plans. Use when Codex needs to turn ambiguous feature ideas into testable acceptance criteria, generate unit/integration/performance test plans, enforce four-word naming conventions, or produce pre-commit quality gates for implementation work.

Design and implement Rust features with executable specifications, TDD-first delivery, and idiomatic architecture. Use when Codex is asked to write or refactor Rust crates, services, CLIs, async workflows, or embedded components and must enforce requirement traceability, layered architecture across L1, L2, and L3 boundaries, four-word naming discipline for new symbols, and test-validated performance and concurrency claims.

Retain and orchestrate context for long-running TDD work by tracking red, green, and refactor state, test status, implementation progress, and resumable next steps in a structured progress journal. Use when sessions span interruptions, multiple files or crates, or frequent context switches and Codex must produce reliable handoffs and resume points.

Capture GitHub repository evolution and conversation context with GHCLI, gh api, and GraphQL. Use when Codex needs to reconstruct how a repository changed, trace a commit to the pull request and comments around it, collect issue or PR discussion history, harvest GitHub Discussions, or produce a source-linked Markdown digest for onboarding, incident review, code archaeology, or design-history analysis.

Create polished, single-file technical explainer HTML pages in the elegant narrative style used for pages like .prd/ELI5/index.html. Use when Codex needs to turn source code, architecture notes, PRDs, connectors, workflows, or mixed technical artifacts into a scrollable ELI5 or executive explainer, especially for requests such as "how this actually works", "make an elegant HTML explainer", "build a visual journey", or "convert this understanding page into a reusable format".

Structure or rewrite memos, reports, PRDs, proposals, analytical writeups, explanations, and presentation content using Barbara Minto's pyramid principle. Use when Codex needs to turn loose notes or a flat draft into a top-down argument with a governing thought, Situation-Complication-Question-Answer introduction, Key Line, deductive or inductive support, point-driven headings, problem-definition framing, or storyboarded slides.

Install and run parseltongue 1.7.2 in an isolated user-space run folder, verify the actual bound server URL, and query a codebase through the HTTP API for orientation, entity lookup, forward and backward dependency tracing, blast radius, architecture scans, incremental reindexing, and higher-order graph workflows such as meet-in-the-middle debugging, safe refactoring, seam discovery, boundary audits, cycle breaking, migration choreography, and derived control-flow or data-flow investigations. Use when Codex must pin to version 1.7.2, needs graph-based code understanding, or must refresh an existing run folder without version drift.

Reliability-first Rust skill for libraries, CLIs, async services, app backends, and FFI wrappers. Use when Rust work needs strong boundary types, typed errors, async and cancellation safety, concurrency verification, compile-fail or property testing, unsafe containment, or operational release gates.

Reliability-first Tauri coding guide for desktop apps in Rust with a web frontend. Use when Codex needs to implement, refactor, review, or harden Tauri 2 applications involving commands, managed state, capabilities, windows, plugins, sidecars, filesystem access, updater or tray lifecycle, deep links, single-instance handling, or desktop security and operability.

Reliability-first backend TypeScript skill for APIs, workers, queues, CLIs, and long-running services. Use when writing Node, Bun, Deno, or worker code that needs request and env parsing, branded identifiers, explicit result errors, cancellation propagation, idempotent writes, persistence evolution, or contract and integration tests.

Reliability-first TypeScript skill for implementing, refactoring, or reviewing .ts code in shared libraries, services, browser code, and cross-layer contracts. Use when work needs strict tsconfig guardrails, schema-first parsing, unknown-at-boundary handling, discriminated unions, persistence/version safety, explicit async cancellation, or behavior-first testing.

Reliability-first React and TypeScript skill for .tsx apps, client and server boundaries, forms, query layers, optimistic UI, navigation recovery, and behavior-first frontend tests. Use when working on React components, hooks, App Router style boundaries, server-state flows, schema-driven forms, or resilient UI state machines.