npx claudepluginhub robertphyatt/ironclaude --plugin ironclaudeThis skill uses the workspace's default tool permissions.
Create comprehensive implementation plans with bite-sized tasks (2-5 minutes each), exact file paths, complete code snippets, and expected output. Plans assume the implementer has zero context and needs mechanical instructions.
Generates detailed implementation plans from specs for multi-step tasks before coding, with bite-sized TDD steps, file structure maps, architecture overviews, tech stacks, and task dependencies.
Creates detailed implementation plans from specs for multi-step tasks before coding, with file structure mapping, bite-sized TDD steps, architecture overview, and tech stack.
Share bugs, ideas, or general feedback.
Create comprehensive implementation plans with bite-sized tasks (2-5 minutes each), exact file paths, complete code snippets, and expected output. Plans assume the implementer has zero context and needs mechanical instructions.
Required argument: Path to design doc (e.g., docs/plans/2026-01-29-feature-design.md)
| Rationalization | Why it's wrong |
|---|---|
| "I'll just implement this one thing while planning" | Implementation belongs in executing-plans. Stay in your lane. |
| "The plan is obvious, I don't need to write it down" | Plans catch missing steps. "Obvious" plans miss edge cases. |
| "Let me test if this approach works first" | That's prototyping, not planning. Design validates approach. |
| "This task is too small for a full plan" | Small tasks get the same plan structure. No exceptions. |
Announce professional mode status:
Using writing-plans skill. Professional mode is ACTIVE - architect mode enforced (no code changes).
Episodic memory search is REQUIRED before plan writing (see Step 0.5). Relevant when:
To search: dispatch the ironclaude:search-conversations agent with relevant query.
Step 0: Check for required design doc path argument
If no design doc path is provided, display:
BLOCKED: Design doc path required.
Usage: /writing-plans docs/plans/YYYY-MM-DD-feature-design.md
The design file must:
- Exist at the specified path
- End with -design.md
Then STOP. Do not proceed without a valid design doc path.
If design doc path is provided:
-design.mdBefore creating the implementation plan:
This is REQUIRED, not optional. Do not skip.
Step 1: Locate design document
Check docs/plans/ for the most recent design:
Use the Glob tool with pattern docs/plans/*-design.md to find design documents.
Read the design document completely to understand:
Step 2: Identify major components
List the major components that need to be built:
Step 3: Order tasks by dependencies
Arrange tasks so:
Step 4: Break each task into 2-5 minute steps
For each task, create steps that are ONE action each:
Example breakdown:
Task: Add user authentication
Step 1: Write test for authentication function (2 min)
Step 2: Run test to verify it fails (1 min)
Step 3: Implement minimal authentication function (3 min)
Step 4: Run test to verify it passes (1 min)
Step 5: Stage changes (1 min)
Each step must include:
TDD requirement: When a task involves creating or modifying executable code (not config files, documentation, or version bumps), the steps MUST follow this structure:
If a task genuinely does not need tests (pure config, documentation, version bump, hook script with no test framework), document why: "No tests required: [reason]" in the task description.
Step 5: Create plan document
Save to docs/plans/YYYY-MM-DD-<feature-name>.md:
# <Feature Name> Implementation Plan
> **For Claude:** REQUIRED SUB-SKILL: Use ironclaude:executing-plans to implement this plan task-by-task.
**Goal:** [One sentence describing what this builds]
**Architecture:** [2-3 sentences about approach from design]
**Tech Stack:** [Key technologies/libraries]
---
## Task 1: [Component Name]
**Files:** (MUST be explicit paths — never use glob patterns like `**/*.py`)
- Create: `exact/path/to/file.py`
- Modify: `exact/path/to/existing.py:123-145`
- Test: `tests/exact/path/to/test.py`
**Step 1: [Action]**
[If writing code, include complete snippet]
[If running command, include exact command and expected output]
Example:
```python
def authenticate(username, password):
# TODO: implement
pass
Run:
pytest tests/auth/test_authentication.py -v
Expected: FAIL with "function not defined"
Step 2: [Next action]
[Continue with exact steps...]
Step 5: Stage changes
Run:
git add src/auth/authentication.py tests/auth/test_authentication.py
Expected: Changes staged (professional mode blocks commit)
[Repeat structure...]
**Step 5.5: Create machine-readable plan JSON**
After creating the markdown plan, also create `docs/plans/YYYY-MM-DD-<feature-name>.plan.json`:
The JSON must follow this exact schema:
```json
{
"name": "Feature Name",
"goal": "One sentence describing what this builds",
"design_file": "docs/plans/YYYY-MM-DD-<feature-name>-design.md",
"tasks": [
{
"id": 1,
"name": "Task Name",
"description": "What this task does",
"allowed_files": ["exact/path/to/file.py", "exact/path/to/other.py"],
"depends_on": [],
"steps": [
{
"description": "Step description",
"command": "optional shell command",
"expected": "optional expected output"
}
]
}
]
}
Rules:
id must be positive integers, unique across all tasksdepends_on references other task IDs (must exist, no circular deps)allowed_files must be exact paths (no globs) — these are the only files the MCP will permit editing during that taskStage the JSON file alongside the markdown:
git add docs/plans/YYYY-MM-DD-<feature-name>.plan.json
Step 5.6: Signal plan files written
Call MCP mcp__plugin_ironclaude_state-manager__mark_plan_ready to transition the session to plan_ready. The statusline will show orange "plan_ready" until executing-plans is invoked.
If mcp__plugin_ironclaude_state-manager__mark_plan_ready returns an error (wrong stage), display the error to the user. Do NOT proceed to Phase 5 until it succeeds.
Note: Do NOT call mcp__plugin_ironclaude_state-manager__create_plan here. That is called by executing-plans.
Step 6: Stage plan document
Run:
git add docs/plans/YYYY-MM-DD-<feature-name>.md
Step 7: Present execution options with recommendation
Before presenting options, analyze the plan to determine the recommended execution strategy:
Recommend inline (option 3) when:
Recommend subagent-parallel (option 2) when:
Recommend subagent-sequential (option 1) when:
Display with recommendation:
Plan complete and saved to:
- docs/plans/YYYY-MM-DD-<feature-name>.md (human-readable)
- docs/plans/YYYY-MM-DD-<feature-name>.plan.json (machine-readable)
Professional mode is ACTIVE - plan staged for your review.
The MCP server releases tasks in dependency-computed waves:
- Wave 1: All tasks with no dependencies
- Wave 2: Tasks whose dependencies are all in Wave 1 (released after Wave 1 review passes)
- And so on until all tasks complete
Recommended: Option N ([mode name])
Rationale: [one sentence explaining why based on plan characteristics]
Three execution options:
1. Subagent tasks, sequential
- MCP releases one wave at a time
- Subagent per task, sequential within each wave
- Code review after each task
2. Subagent tasks, parallel
- MCP releases one wave at a time
- Independent tasks within a wave run in parallel
- Code review as each completes
3. No subagents, main session
- Execute all tasks in this session
- Maximum control, no subagent drift possible
Which approach? (1/2/3)
(Move the "(Recommended)" label to whichever option is recommended for this specific plan.)
Wait for user choice.
If option 1 chosen (subagent tasks, sequential):
Invoke executing-plans skill: [Use Skill tool: skill="ironclaude:executing-plans", args=" --mode=subagent-sequential"]
If option 2 chosen (subagent tasks, parallel):
Invoke executing-plans skill: [Use Skill tool: skill="ironclaude:executing-plans", args=" --mode=subagent-parallel"]
If option 3 chosen (no subagents, main session):
Invoke executing-plans skill: [Use Skill tool: skill="ironclaude:executing-plans", args=" --mode=inline"]
**/*.py, src/*). Every file must be listed by its full relative path.