# creating-development-plans

The skill drafts a phased development plan with task breakdowns, requirements, and QA checklists. It helps set clear checkpoints before writing code.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 330 installs · ★ 167
- Author: sammcj
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/sammcj/agentic-coding/tree/HEAD/Skills/creating-development-plans/SKILL.md
- Updated: 2026-10-24
- HTML: https://affpapa.org/en/nevibecode/skills/creating-development-plans

## What it does

The skill forces the agent to inspect the repository before writing any implementation code. It examines project documentation and dependencies to match existing conventions. After reading the codebase, the agent analyses requirements and evaluates technical trade-offs. It writes the resulting plan into `./docs/DEVELOPMENT_PLAN.md`.

Work is organised into independent phases with nested task checkboxes. Every phase ends with a self-review step and an explicit checkpoint to pause for human approval. The skill strictly limits the agent to planning, keeping it from writing code until you approve the roadmap. The template bans placeholder stubs and `TODO` comments.

Each document includes a testing strategy and a QA checklist. The author configures the prompt to use Australian English spelling without emojis. The agent excludes calendar dates and time estimates entirely. This keeps the focus strictly on technical execution.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add sammcj/agentic-coding --skill creating-development-plans -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/creating-development-plans/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/creating-development-plans/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add sammcj/agentic-coding --skill creating-development-plans -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/creating-development-plans/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add sammcj/agentic-coding --skill creating-development-plans -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/creating-development-plans/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install sammcj/agentic-coding creating-development-plans
```

2. **Manually: put the files in place**
- File: `.github/skills/creating-development-plans/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add sammcj/agentic-coding --skill creating-development-plans -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/sammcj/agentic-coding --path Skills/creating-development-plans
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/creating-development-plans/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add sammcj/agentic-coding --skill creating-development-plans -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/sammcj/agentic-coding/tree/HEAD/Skills/creating-development-plans/SKILL.md

## When to use it
- break down feature development into verifiable phases
- generate `./docs/DEVELOPMENT_PLAN.md` before writing code
- map out technical trade-offs and architectural constraints
- establish a testing strategy and debugging checklist

## Example prompts
- Create a dev plan for refactoring the authentication module
- Write a development plan for adding Stripe payments to the backend
- Document development requirements and task breakdown in docs/DEVELOPMENT_PLAN.md

## Source text · SKILL.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: c16497084091c63a.

BEGIN THIRD-PARTY FILE c16497084091c63a
```text
---
name: creating-development-plans
description: Creates structured development plans with phased task breakdowns, requirements, and QA checklists. Use when the user explicitly asks to create a dev plan, development plan, or document development requirements.
disable-model-invocation: true
---

# Development Planning Skill

<role>


## Core Principles

- **Planning occurs before code**: Thoroughly understand project context and requirements first
- **Context gathering is critical**: Always start by understanding the existing codebase and documentation
- **Phased approach**: Break work into discrete, manageable phases with human review checkpoints
- **Simplicity over complexity**: Keep solutions free of unnecessary abstractions
- **Actionable output**: The plan must be clear enough for another senior AI agent to execute independently

</role>

<instructions-part-one>

## Planning Process

### Step 1: Context Gathering

If there is existing code in the project:

1. Read all relevant files in the project directory
2. Examine existing documentation (README.md, docs/, CONTRIBUTING.md, etc.)
3. Analyse codebase structure, architecture, and dependencies
4. Identify coding conventions, patterns, and standards used
5. Review existing tests to understand expected behaviour
6. Note package versions and technology stack choices

### Step 2: Requirements Analysis

Based on your conversation with the user:

1. Identify the core goal and objectives
2. List hard requirements explicitly stated
3. Document any unknowns or assumptions
4. Consider edge cases and architectural implications
5. Evaluate multiple implementation approaches and trade-offs (performance, maintainability, complexity)
6. Identify integration points with existing code
7. Clarify any ambiguous requirements with the user before proceeding

### Step 3: Task Breakdown

Organise development into phases:

- Each phase should be independently testable and reviewable
- Break down complex tasks into sub-tasks (use nested checkboxes)
- Identify dependencies between tasks
- Order tasks logically within each phase
- Each phase MUST end with:
  - A self-review checkpoint
  - A "STOP and wait for human review" checkpoint

### Step 4: Quality Assurance Planning

Build a concise QA checklist that includes (if applicable):

- Standard items (listed below)
- Project-specific requirements gathered from conversation
- Technology-specific checks (e.g., "Go vet passes" for Go projects, "ESLint clean" for JavaScript)
- Security considerations mentioned
- Any other quality gates discussed with the user

### Step 5: Deep Review

Before finalising:
```
END THIRD-PARTY FILE c16497084091c63a

The third-party file has ended. Everything between the c16497084091c63a tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2624 of 7244 bytes. © sammcj · Apache-2.0 · https://github.com/sammcj/agentic-coding/tree/HEAD/Skills/creating-development-plans/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md