Planning

Break features into bite-sized implementation plans with clear tasks, file paths, and TDD steps. A good plan is the foundation for efficient, reviewable implementation.

When to Use This

• You have a spec or design document and need to break it into implementable steps.
• A feature touches multiple files and you want a clear order of operations.
• You want to ensure each step is small enough for meaningful code review.
• You need to communicate the implementation approach to your team.

What You'll Use

Walkthrough

Scenario: Plan the implementation of a new REST API endpoint for user preferences.

Step 1: Write the Plan

Run /write-plan and provide the context:

"Implement a REST API endpoint for user preferences. Users should be able to GET and PUT their notification preferences. The spec says we need: a preferences table, a repository, a service layer, API routes, validation, and tests."

Step 2: Claude Produces the Plan

The writing-plans skill structures the plan into bite-sized tasks:

Task 1: Database migration

• Create migration for user_preferences table
• Fields: user_id, notification_email, notification_push, notification_in_app, updated_at
• Test: migration runs up and down cleanly

Task 2: Repository layer

• Create UserPreferencesRepository with findByUserId and upsert methods
• File: src/repositories/user-preferences.ts
• Test: repository CRUD operations against test database

Task 3: Service layer

• Create UserPreferencesService with get and update methods
• Validation: ensure user exists, validate preference values
• File: src/services/user-preferences.ts
• Test: service logic with mocked repository

Task 4: API routes

• GET /api/users/:id/preferences — returns current preferences
• PUT /api/users/:id/preferences — updates preferences
• File: src/routes/user-preferences.ts
• Test: HTTP integration tests

Task 5: Commit and PR

• Conventional commit for each task
• PR with description referencing the spec

Step 3: Review and Adjust

Review the plan. You can ask Claude to:

• Reorder tasks if dependencies are different
• Add or remove tasks
• Adjust the scope of individual tasks
• Change the testing strategy

Step 4: Execute

Once satisfied, proceed to implementing using /execute-plan.

Quick Reference

Tips

• The best plans have 3-7 tasks. If there are more, consider breaking the feature into multiple plans.
• Each task should be independently testable and committable. This makes code review easier.
• /write-plan output is designed to be consumed by /execute-plan. Keep them together.
• For spec-driven workflows, you can also use spec-kit's /speckit-plan and /speckit-tasks to generate plans from specifications.

See Also

• superpowers plugin — Full plugin documentation
• Specification workflow — Previous step: define the spec
• Implementing workflow — Next step: execute the plan