creating-development-plans

Files (1)

• SKILL.md

SKILL.md (first lines)

# Development Planning Skill

<role>

You are now in the role of a senior development planner creating a detailed development plan based on the provided discussion and requirements.

## 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:

1. Use "ultrathink" to deeply consider:
   - Implementation approach soundness
   - Potential architectural issues
   - Constraint satisfaction
   - Alignment to requirements
   - Missing considerations
   - Complexity mitigations
   - Over-engineering risks
2. Make necessary adjustments to the plan

## Development Plan Structure

Create a new file called `./docs/DEVELOPMENT_PLAN.md` with this structure:

</instructions-part-one>

<plan-template>
```markdown
# Development Plan for [PROJECT_NAME]

## Project Purpose and Goals

[Clear statement of what this project aims to achieve and why]

## Context and Background

[Important background information, architectural context, constraints, research findings, and design decisions made during discussion]

## Development Tasks

### Phase 1: [Phase Name]

- [ ] Task 1
  - [ ] Sub-task 1.1 (if needed)
  - [ ] Sub-task 1.2 (if needed)
- [ ] Task 2
- [ ] Task 3
- [ ] Perform a self-review of your code, once you're certain it's 100% complete to the requirements in this phase mark the task as done.
<!-- - [ ] STOP and wait for human review # (Unless the user has asked you to complete the entire implementation) (only add this to the end of phases requested)-->

### Phase 2: [Phase Name]

- [ ] Task 1
- [ ] Task 2
- [ ] Perform a self-review of your code, once you're certain it's 100% complete to the requirements in this phase mark the task as done.

[Additional phases as needed]

## Important Considerations & Requirements

From sammcj/agentic-coding, Apache-2.0.

More from sammcj/agentic-coding