← Back to skills

Development Process

Writing Plans

Write comprehensive implementation plans with bite-sized tasks, exact file paths, complete code, and runnable commands.

Last reviewed Mar 2, 2026

Install

Create this file in your project:

.claude/skills/writing-plans/SKILL.md
--- name: writing-plans description: Use this skill when asked to write an implementation plan, project plan, or detailed task breakdown for a feature or change. --- # Writing Plans ## When to Use - Creating an implementation plan for a new feature - Breaking down a large task into executable steps - Writing plans that another developer or AI agent will follow ## Process 1. **Understand scope** -- Read the requirements thoroughly. Identify what exists already in the codebase and what needs to be created. 2. **Identify tasks** -- Break the work into sequential, atomic tasks. Each task should be one action that takes 2-5 minutes. 3. **Write each task** with: - A clear description of what to do - Exact file paths to create or modify - Complete code snippets (not pseudocode) - Exact terminal commands to run - Expected output or verification step 4. **Order tasks** so each builds on the previous. Group related tasks into phases. 5. **Add checkpoints** -- After every 3-5 tasks, add a verification step (run tests, check types, test manually). ## Rules - Each task must be one atomic action. If it has "and" in the description, split it. - Include complete code, not fragments. The executor should not need to guess anything. - Include exact file paths relative to project root. - Include exact commands to run, not "run the appropriate test." - Assume the plan executor has zero context about the codebase. - Apply DRY, YAGNI, and TDD principles in the planned code. - Plan frequent commits -- at least one per phase. - Always start with a task to verify the current state (tests pass, app builds).

What this skill does

Writing Plans produces detailed, step-by-step implementation plans that can be executed by another developer or AI agent without needing to understand the broader codebase. Each step is atomic, containing the exact file to edit, the complete code to write, and the command to verify the change works.

The key insight is that plan quality is measured by executability. A good plan can be followed mechanically -- the executor doesn't need to make design decisions or fill in gaps. This makes plans ideal for delegation, whether to a junior developer, an AI agent, or your future self.

The 2-5 minute task size is intentional. Tasks smaller than 2 minutes create overhead from context switching. Tasks larger than 5 minutes usually hide multiple decisions and should be split. This sweet spot keeps momentum while maintaining clarity.

Example workflow

You ask the agent to write a plan for adding a search feature to a blog. The output might look like:

Phase 1: Search API

  • Task 1: Verify current state -- run npm test and npm run build, confirm both pass.
  • Task 2: Create /lib/search.ts with the searchPosts function (full code provided).
  • Task 3: Create /app/api/search/route.ts with GET handler (full code provided).
  • Task 4: Write test for the search API endpoint (full test code provided). Run npm test -- search.

Phase 2: Search UI

  • Task 5: Create SearchInput component (full code, exact file path).
  • ... and so on, each task self-contained.

Tips

  • Plans should start with a verification task to confirm the starting state is clean
  • When plans will be executed by an AI agent, include even more detail than you think is necessary
  • Group tasks into phases with checkpoint verifications between them
  • Good plans are also excellent documentation of what was done and why

Best with tools

    Related MCP servers

    • No linked MCP servers yet.

    Related skills

    Brainstorming

    Collaborative idea-to-design exploration that asks clarifying questions, proposes approaches with tradeoffs, and iterates toward a design.

    Executing Plans

    Execute implementation plans task-by-task with verification checkpoints, sequential ordering, and frequent commits.

    Systematic Debugging

    Enforces a structured debugging workflow: reproduce, hypothesize, verify, fix root cause, and audit similar code paths.