/design — Development & Design
Receive functional requirements, automatically inventory available ECC resources (agents/skills/commands), build a complete implementation plan and output plan.md. It will not execute the implementation automatically, and must wait for user confirmation.
Step 1: Inventory ECC Resources
Scan all available ECC agents, skills and commands as references for subsequent planning.
Scanning method:
- List all available agent types (from the subagent_type list of the Agent tool), including the (harness configuration optimization) and (autonomous loop monitoring) added in v1.8
- List all available skills (from the skill list in system-reminder)
- List all available commands (from and plugin commands), including , , added in v1.8
- Filter out relevant resources according to the user's requirements ()
Output: A concise resource list, marking the relevance level (high/medium/low) of each resource to the current requirement.
Step 2: Complexity Assessment
Select the execution path according to the scale of the requirement:
| Complexity | Judgment Criteria | Execution Path |
|---|
| Low | Single file, no architecture changes involved (e.g. update README, add badge, modify configuration) | Skip Step 4 (architect), go directly from Step 3 → Step 5 |
| Medium and above | Cross-file or has architecture impact | Complete process Step 3 → Step 4 → Step 5 |
If the requirement is too vague to judge the complexity, use AskUserQuestion to ask the user to supplement specific information.
No matter which path is taken, plan.md will be output.
Step 3: planner — Build Implementation Plan
Use the planner agent to build a detailed implementation plan.
Agent(subagent_type="everything-claude-code:planner")
Input context:
- User's requirement description ( + conversation context)
- ECC resource list inventoried in Step 1
- Current project structure (understood through , , etc.)
The plan must include:
- Requirement decomposition — Decompose the requirement into executable subtasks
- Technical solution — Implementation method for each subtask
- Industry practice and standardization solution reference — Each technical solution must be attached with a basis
- Whether there are industry standards or conventions (RFC, W3C, OWASP, 12-Factor, etc.)
- Whether there is academic research support (papers, benchmarks)
- Whether there are mature standardized solutions (official SDK, canonical pattern of well-known libraries)
- If there is no direct standard, explain why the custom solution is adopted, and quote the closest reference
- ECC resource integration — Clearly indicate which agent/skill/command should be used in each step. ECC resource allocation must be confirmed through inventory — Do not assume resources are available, and must trace back to the inventory results of Step 1
- Example: "Step 3: Use tdd-guide agent to write tests"
- Example: "Step 5: Use /code-review for quality review"
- Dependency relationship — Which steps must be executed in sequence and which can be parallelized
- Risk assessment — Potential technical risks and countermeasures
- Acceptance criteria — What counts as completion
Step 4: architect — Architecture Design Review
Use the architect agent to review the plan from Step 3.
Agent(subagent_type="everything-claude-code:architect")
Review focus:
- Whether the architecture is reasonable and scalable
- Whether there is a simpler alternative
- Compatibility with existing code
- Performance and security considerations
- Reliability of industry/academic references — Whether the cited standards are applicable to the current scenario, whether they are the latest version, and whether there are better standardized solutions omitted
- Whether the selection of ECC resources is appropriate — Must compare with the inventory results of Step 1 to confirm that the selected agent/skill is available in the current session
- Document impact assessment: Which documents (README, API docs, CODEMAPS) need to be added or updated after implementation, and be included in the plan.md to-do list
If there are major architecture suggestions: Feed back to the planner to adjust the plan (up to 2 iterations).
Step 5: Output plan.md
Before writing the final plan to the file, first check the plan quality against the following checklist:
| Dimension | Passing Standard |
|---|
| Completeness | Each requirement has corresponding implementation steps |
| Executability | Each step has a clear file path and specific actions |
| Dependency correctness | Dependencies between steps have no loops and the order is reasonable |
| Appropriate granularity | Each step has 1-3 specific actions |
| Reasonable ECC resources | Each agent/skill is used within its designed purpose |
| Testable acceptance | Each acceptance criterion can be objectively verified |
| Industry/academic support | Each technical solution has clear industry standards, academic research or standardized solution references |
| Post-implementation tools | The steps of plan.md include post-implementation quality assurance (code-reviewer, /update, /verify, etc.) |
| Eval baseline | If behavioral changes are involved, the plan includes eval baseline establishment and regression verification steps (refer to ) |
If problems are found, directly modify the plan content.
Output path: in the project root directory (if it already exists, use AskUserQuestion to ask whether to overwrite)
plan.md format:
markdown
# Implementation Plan: [Function Name]
> Generated by /design on [Date]
> Status: PENDING APPROVAL
## Overview
<!-- 1-3 sentences describing the goal -->
## ECC Resources
<!-- agents/skills/commands used in this plan -->
|----------|------|-------|
| tdd-guide | agent | Step 3: Write tests |
| code-reviewer | agent | Step 5: Quality review |
| ... | ... | ... |
## Industry & Standards Reference
|----------|---------|------|------|
| ... | ... | Industry Standard/Academic Research/Standardized Solution/Best Practice | ... |
## Implementation Steps
### Phase 1: [Implementation Phase]
- [ ] Step 1: ...
- Agent: `planner`
- Input: ...
- Output: ...
### Phase 2: [Quality Assurance]
- [ ] Execute code-reviewer to review code quality
- [ ] Execute security-reviewer to check security
- [ ] Execute /verify for comprehensive verification
### Phase 3: [Document Synchronization]
- [ ] Execute /update to update the knowledge base (doc-updater + learn-eval)
- [ ] Or manually execute /update-docs + /update-codemaps
## Architecture Notes
<!-- architect's review results (including document impact assessment) -->
## Risks & Mitigations
<!-- Risk assessment -->
## Acceptance Criteria
- [ ] ...
- [ ] ...
## Review Notes
<!-- Results of plan quality self-review -->
Final prompt to user:
plan.md has been generated, please confirm the plan content. You can start implementation after confirmation.