plan

A planning command that turns an intent specification into a step-by-step implementation recipe called plan.aide. It can also create or update a related brief.aide file when planning establishes important commitments.

In plain words
What is it for?
Use it after preparing an intent specification, especially when the project needs a detailed build plan tied to existing architectural decisions.
Why use it?
It turns a high-level request into an agreed sequence of implementation work. It also keeps architectural decisions and unresolved questions visible while the plan is being made.

Command for Claude Code

Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

agentmods
npx agentmods add commands/aidemd-mcp/server/plan
Clone the repo
git clone --depth 1 https://github.com/aidemd-mcp/server

Made for: Claude Code.

Per session 0 Only the description is in the session, so the agent can decide to use it. The body loads when it is invoked.
When invoked 1,072 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. Scan, not verified.
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5 $0.00000 $0.01072
Opus 5 $0.00000 $0.00536
Sonnet 5 $0.00000 $0.00214
Haiku 4.5 $0.00000 $0.00107

Measured 2d ago against content hash cc930e728fbe, method: parsed. Prices are Anthropic first-party input rates as of 2026-08-30, from the pricing page.

Security

Grade A, and why

plan scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 2d ago.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

.claude/commands/aide/plan.md · 32 lines

How it starts

The opening of the file, as written. The whole thing — 32 lines — stays where its author put it; the contents beside it link to each section on GitHub.

/aide:plan — Plan Phase

Agent: This command is executed by the aide-architect agent.

Translate the intent spec into a step-by-step implementation plan. Output: plan.aide (the build recipe). The spec may be in one of two shapes: Shape A (synthesize ran — body sections filled, sibling brief.aide exists) or Shape B (synthesize skipped — frontmatter only, no brief.aide; the orchestrator's delegation prompt carries the user's implementation context as the architectural input). For Shape A, UPDATE brief.aide as planning surfaces new commitments. For Shape B, CREATE brief.aide only if planning surfaces commitments worth recording. See plan.aide spec and brief.aide spec.

Checklist

  • Read the intent spec (.aide or intent.aide) in the target module. Frontmatter is always required. Body sections are present only in Shape A.
  • Identify the shape: brief.aide exists → Shape A; brief.aide does not exist → Shape B. For Shape A, read the sibling brief.aide — its commitments are the current architectural state your plan must honor or deliberately retire; its open questions are decisions awaiting your settlement. For Shape B, the orchestrator's delegation prompt carries the user's implementation instructions verbatim — that's your architectural input.
  • Pull the coding playbook from the brain using the study-playbook skill — naming conventions, folder structure, patterns to follow and anti-patterns to avoid
  • Scan the target module and its neighbors to understand what already exists — existing helpers to reuse, existing patterns to match, folders already in place
  • Write plan.aide next to the .aide spec with:
    • Frontmatter: intent — one-line summary of what this plan delivers
    • ## Project Structure — the complete annotated folder tree of the module, rooted at the scope directory. This IS the recipe blueprint — every plan includes it unconditionally, whether greenfield or additive. The implementor must never figure out the module's structure; that is the architect's job. Every file that will exist after execution appears in the tree, annotated with what it does and its function signature (parameters and return type). For additive plans, mark which files are new vs. existing. .aide specs go next to orchestrators, not helpers.
    • ## Plan — checkboxed steps (the "cooking order" for the recipe above):
      • Each step references files from the Project Structure tree
      • Steps may reference brief.aide commitments by number ("honor commitment #11")
      • Which existing helpers to reuse instead of writing new ones
      • Sequencing — what must exist before the next step can start
      • Tests to write for each behavior the spec's outcomes.desired names
    • ## Decisions — architectural choices made: why X over Y, naming rationale, tradeoffs
  • Shape A (brief exists): Update brief.aide (do NOT overwrite — the strategist authored it). Shape B (no brief): create brief.aide only if planning surfaced commitments worth recording; if the plan + spec frontmatter fully describe the module, do not create an empty file. Sections (when the file exists):
    • ## Commitments — numbered commitments. Type shapes, function signatures, exact strings, schema cardinality, marker tokens, enumerations of accepted values. Numbers persist across edits — gaps stay when commitments are removed; new commitments append
    • ## Cross-module contracts — what this module exposes/consumes vs. neighbors
    • ## Open questions — design decisions deferred to build, cleared as they are answered downstream
  • No implementation code in any file — no function bodies, no algorithms as code. Architectural contracts (types, signatures, exact strings, schema details) belong in brief.aide when one exists, otherwise in the plan step bullets. If an implementor would have to invent it, name it explicitly. If the playbook covers it, put it in the plan step's Read list.
  • Every plan step must be traceable back to a line in the .aide spec, a brief.aide commitment, or a rule in the coding playbook. If a step has no source, cut it or find the rule that justifies it
  • If the spec is ambiguous, stop and escalate back to the spec writer (via the orchestrator) rather than inventing an answer
  • PAUSE for user approval. Present BOTH plan.aide and the updated brief.aide and do not proceed until the user approves them. Iterate if the user requests changes
  • Hand the approved plan + brief to the implementor via /aide:build

Read the full file on GitHub · 32 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. 2d ago First seen · 32 lines · 0 tokens per session scan A cc930e728fbe

Subscribe to this mod's changes

plan is a command published in the GitHub repository aidemd-mcp/server (3 stars, last pushed 3mo ago), licensed MIT. It costs nothing until one of its globs matches a file; then it loads 1,072 tokens. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-31.