Commands

These are the commands your AI coding agent uses to work with your specification tree, from a first idea all the way to working code. Each one is driven from your AI coding environment, and each does its heavier or more focused work through subagents — a subagent runs in its own separate context, so the main conversation you're having with your agent doesn't get filled up with intermediate work and stays free to keep going.

/mindmap-specification

Builds a brand-new specification by drawing it out of you across rounds of questions, rather than expecting you to write a finished spec up front.

1. Find where it belongs, and ground it in your codebase. Before asking you anything, this step searches your existing specification tree for the right place to put the new specification, and checks the idea against your actual codebase for feasibility. Both run as their own subagents in parallel, in their own context, so this grounding doesn't cost your main conversation any context budget.
2. Run iterative rounds of questions and answers. Each round asks you a handful of concrete questions about the current topic, saves your answers immediately, then proposes a few directions to explore next (or lets you finish). You steer which topic comes next; nothing is decided for you.
3. Synthesize the final specification, then choose what's next. Once you're done answering, everything from every round is turned into a single, well-organized specification. You then choose to apply it right away, decompose it into stages first, or stop there.

Flag	What it does
--continue <spec_id>	Resumes mind-mapping on an already-created specification instead of starting a new one.
--auto-apply	Skips the final choice and applies the finished specification immediately.
--auto-decompose	Skips the final choice and decomposes the finished specification into stages immediately.

/decompose-specification

Breaks an existing specification down into smaller, independently implementable child "stage" specifications.

1. Propose a breakdown into stage drafts. A subagent proposes how to split the parent specification into stages, based on its current content — this runs in its own context so the proposal doesn't have to be reasoned through inline.
2. Collect answers to clarifying questions, per stage. Each proposed stage gets its own round of clarifying questions before it's considered ready.
3. Finalize and approve each child stage. Once a stage's questions are answered, a subagent rewrites its content using those answers plus grounding from the codebase, then approves it — again handled in its own separate context, one stage at a time.

Flag	What it does
--auto-apply	Once a child stage is finalized and approved, applies it immediately instead of waiting.

/apply-specification

Implements a specification (or an entire subtree of them) — turning already-prepared specifications into working code.

Unlike /mindmap-specification and /decompose-specification, this command always runs unattended: it never stops to ask you anything. It uses its own best judgment on any ambiguity it can resolve safely, and only stops with a clear report if something genuinely can't be resolved without you.

1. Collect every prepared leaf specification in the subtree. Before doing any work, it walks the whole subtree under the specification you gave it and gathers every leaf that's ready to be implemented.
2. Plan, then implement, one leaf at a time. For each leaf, a subagent first verifies feasibility and records an implementation plan, then a separate subagent applies that plan and makes the actual code changes — each running in its own context, so working through a long list of leaves doesn't accumulate into one giant conversation.
3. Review the whole batch together, with a fix-and-re-review cycle. Once every leaf has been implemented, a subagent reviews all of them together — including how they relate to each other — and approves each one. If it finds a discrepancy, the relevant implementation is fixed and the whole batch is re-reviewed, up to a few times, before anything is left for manual follow-up.

How the automation flags chain together

The --auto-* flags let you drive the whole pipeline from a single starting command:

/mindmap-specification I want to build ... --auto-decompose --auto-apply

--auto-decompose on /mindmap-specification runs /decompose-specification on the finished specification automatically; passing --auto-apply alongside it chains that flag down too, so /decompose-specification in turn applies each of its finalized child stages by running /apply-specification on them automatically. One command, run once, can take an idea all the way to implemented code without you touching anything in between.

What's next

• Getting started — set up Athenode and run your first command
• Setting up your AI agent — more on agent setups and connecting additional AI coding environments