Writing Plans

What Is This?

Overview

Writing Plans creates detailed implementation plans for software development tasks before any code is written. It breaks down feature specifications into granular steps assuming the developer has minimal codebase context, documenting exact file paths to create or modify, test-first development steps, verification procedures, and commit points.

The skill follows TDD (Test-Driven Development) methodology, structuring each task as: write failing test, run to verify failure, implement minimal code, run to verify pass, and commit. Plans are saved to timestamped markdown files in a dedicated worktree created by the brainstorming skill.

This ensures developers have complete roadmaps before implementation begins, reducing confusion, preventing scope creep, and maintaining code quality through systematic test-first development.

Who Should Use This

Software engineers starting new features or complex changes. Tech leads planning implementation approaches. Teams practicing TDD and wanting structured guidance. Developers unfamiliar with specific codebases needing detailed roadmaps. Anyone wanting to think through implementation before writing code.

Why Use It?

Problems It Solves

Starting complex features without plans leads to incomplete implementations, missed edge cases, and refactoring cycles. Developers unfamiliar with codebases waste time finding relevant files and understanding architecture. Plans specify exact file paths and provide necessary context, eliminating exploration time.

Test coverage suffers when tests are afterthoughts. TDD-structured plans ensure tests are written first for every feature component. Large features feel overwhelming without structure, and breaking work into 2-5 minute bite-sized steps makes progress manageable and momentum clear.

Core Highlights

Comprehensive implementation plans with zero-context documentation. TDD-structured tasks (failing test, verify fail, implement, verify pass, commit). Exact file paths for creates and modifications. Bite-sized granular steps (2-5 minutes each). Architecture and tech stack documentation. Testing and verification procedures. DRY and YAGNI principles enforced. Timestamped plan files for reference.

How to Use It?

Basic Usage

Provide feature specifications or requirements. The skill generates a complete implementation plan with granular steps.

Create plan for adding user authentication with JWT tokens

Generate implementation plan for CSV export feature

Plan database migration adding user roles and permissions

Specific Scenarios

For new features:

Plan implementation of real-time notifications using WebSockets

For refactoring:

Create plan for migrating REST API to GraphQL

For bug fixes requiring significant changes:

Plan fix for race condition in payment processing

Real-World Examples

A team needs to add payment processing to their application. They generate a plan breaking the feature into 15 tasks covering Stripe API integration, payment model creation, transaction handling, webhook processing, error handling, and reconciliation. Each task specifies exact files, includes test-first steps, and documents verification procedures. Implementation proceeds smoothly with full test coverage and no missed requirements.

A developer unfamiliar with a legacy codebase needs to add export functionality. The plan documents which existing services to use, where to add new code, how database queries should be structured, and what edge cases to handle. The developer follows the granular steps without extensive codebase exploration, completing the feature confidently.

An engineer tackles a complex refactoring moving business logic from controllers to a service layer. The plan breaks this into small increments, each tested independently. The TDD structure ensures no functionality breaks during refactoring, and frequent commits provide rollback points if issues arise.

Advanced Tips

Run this skill before touching any code to think through implementation. Use dedicated worktrees for plan-driven development to keep work isolated. Follow TDD structure strictly (test first, minimal implementation). Make commits after each completed task for granular history. Review generated plans with the team before implementation starts. Update plans if requirements change during development.

When to Use It?

Use Cases

Planning new feature implementations. Structuring complex refactoring work. Guiding developers unfamiliar with codebases. Ensuring TDD practices are followed. Breaking overwhelming tasks into manageable steps. Documenting implementation approaches for team review. Creating roadmaps for multi-day development work.

Related Topics

Test-Driven Development (TDD) methodology. Implementation planning and task breakdown. Code organization and file structure. Git workflow and commit granularity. Documentation practices for development plans.

Important Notes

Requirements

Clear feature specifications or requirements. Understanding of project architecture and tech stack. Access to codebase for verifying file paths. Commitment to following TDD practices. Dedicated worktree for plan execution.

Usage Recommendations

Generate plans before writing any code. Review plans with the team before implementation. Follow TDD structure strictly for quality. Make frequent small commits after each task. Update plans if requirements change. Save plans to a docs/plans directory with timestamps. Verify each step before proceeding to the next.

Limitations

Plans assume specifications are complete and accurate. Cannot account for unexpected technical challenges during implementation. Requires discipline to follow granular steps rather than jumping ahead. Plans need updates if requirements change significantly and cannot be generated for poorly defined requirements.