claudecode-boilerplate/.claude/commands/add-feature.md

description
Implement a new feature following existing patterns, fully autonomously without stopping

Adding a New Feature (Fully Autonomous Execution Mode)

Important: This workflow is designed to run fully automatically from start to finish without user intervention. After completing each step, immediately move on to the next step. Do not ask the user for confirmation mid-thought or interrupt the work.

Argument: feature name (e.g. /add-feature User profile editing)

---

Step 1: Preparation and Context Setup

1. Establish the current task context:

• Feature name: [the feature name given as an argument]
• Date: [get the current date in YYYYMMDD format]
• Steering directory path: .steering/[date]-[feature name]/

2. Create the steering directory above.
3. Create the following three empty files:

• [steering directory path]/requirements.md
• [steering directory path]/design.md
• [steering directory path]/tasklist.md

Step 2: Understand the Project

1. Read CLAUDE.md to grasp the overall picture of the project.
2. Review the persistent documents in the docs/ directory to understand the relevant design philosophy and architecture.

Step 3: Investigate Existing Patterns

1. Use the Grep tool to search the source code (src/) for keywords related to the feature name.

Grep('[keyword related to the feature]', 'src/')

2. Analyze the search results to identify existing implementation patterns, naming conventions, and how components are used.

Step 4: Planning Phase (Automatic Generation of Steering Files)

1. Run Skill('steering') in planning mode to generate the contents of the three files created in Step 1 (requirements.md, design.md, tasklist.md).
2. Once this step completes successfully, never stop; immediately proceed to Step 5.

Step 5: Implementation Loop (Fully Working Through tasklist.md)

This step is a loop that repeats automatically until all tasks in tasklist.md are [x]. Once this step completes successfully, never stop; immediately proceed to Step 6.

Loop start:

1. Read the task list:

• Read the [steering directory path]/tasklist.md file.

2. Check progress:

• Check whether any incomplete tasks ([ ]) exist in the file.
• If no incomplete tasks exist: consider this implementation loop complete and immediately proceed to Step 6.
• If incomplete tasks exist: proceed to the next step (3. Execute the task).

3. Execute the task:

• Identify one incomplete task at the top of tasklist.md.
• Carry out the implementation work needed to complete that task.
• Use Skill('steering') in implementation mode.
• Always follow the coding standards in Skill('development-guidelines').

4. Update the task list:

• Once the executed task is complete, use the Edit tool to update tasklist.md, changing the task from [ ] to [x].

5. Continue the loop:

• Return to the top of Step 5 (1. Read the task list) and repeat the process.

---

* Exception-Handling Rules Within the Implementation Loop *

If any of the following situations occur while the implementation loop is running, handle them autonomously according to these rules and continue the loop.

• Rule A: When a task is too large

  • Handling: Break the current task into multiple smaller subtasks. Use the Edit tool to delete the original task and insert the new subtasks (with [ ]) in its place. Then continue the loop.

• Rule B: When a task becomes unnecessary for technical reasons

  • Condition: Apply only when there is a clear technical reason, such as a change in implementation approach, architecture, or dependencies.
  • Handling: Use the Edit tool to update the task in the format [x] ~~task name~~ (Reason: [briefly describe the specific technical reason]). Then continue the loop.

• ❌ Strictly Forbidden Actions:

  • Intentionally skipping an incomplete task for reasons such as "do it later" or "make it a separate task."
  • Leaving incomplete tasks unaddressed and ending the loop without reason.
  • Asking the user to make a decision.

---

Step 6: Implementation Validation (Launch a Subagent)

1. Do a final check that all tasks in tasklist.md are complete.
2. Use the Task tool to launch the implementation-validator subagent to validate quality.

• subagent_type: "implementation-validator"
• description: "Implementation quality validation"
• prompt: "Please validate the quality of all the changes related to the [feature name] implemented this time. The target files are [list of paths of the implemented files]. Focus on coding standards, error handling, testability, and consistency with existing patterns."

Once this step completes successfully, never stop; immediately proceed to Step 7.

Step 7: Run Automated Tests

1. Run the following commands in order and confirm that all tests pass.

Bash('npm test')
Bash('npm run lint')
Bash('npm run typecheck')

2. If any command produces an error, analyze the problem, generate and apply a fix, and then run this step again.

Once this step completes successfully, never stop; immediately proceed to Step 8.

Step 8: Retrospective and Document Updates

1. Run Skill('steering') in retrospective mode and record handover notes in tasklist.md.

• Implementation completion date
• Differences between plan and actual
• Lessons learned
• Improvement suggestions for next time

2. Determine whether this change affects the project's fundamental design or architecture.

3. If there is an impact, use the Edit tool to update the relevant persistent documents in docs/.

Completion Criteria

This workflow completes automatically once all of the following conditions are met.

• Step 5: All tasks in tasklist.md are complete ([x] or skipped for a valid reason).
• Step 6: The implementation-validator subagent's validation passes.
• Step 7: The test, lint, and typecheck commands all succeed without errors.
• Step 8: Handover notes are recorded in tasklist.md.

Until these completion criteria are met, continue to think autonomously, solve problems, and carry on the work.