home / skills / madebyaris / spec-kit-command-cursor / sdd-planning

sdd-planning skill

safe

This skill transforms specifications into actionable technical plans, guiding architecture, components, and implementation steps to accelerate delivery.

npx playbooks add skill madebyaris/spec-kit-command-cursor --skill sdd-planning

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

2.9 KB

---
name: sdd-planning
description: Generate technical plans from specifications. Use when creating architecture documents, designing system components, or preparing for implementation.
---

# SDD Planning Skill

Transform specifications into actionable technical plans.

## When to Use

- Spec exists but plan doesn't
- Designing system architecture
- Breaking down features into components
- Preparing for implementation phase
- After research is complete

## Planning Protocol

### Step 1: Understand Requirements
1. Read `spec.md` thoroughly
2. Note functional requirements and acceptance criteria
3. Identify non-functional requirements (performance, security)
4. Review research findings if available

### Step 2: Design Architecture
1. Identify major components
2. Define component responsibilities
3. Design interfaces and contracts
4. Plan data flow

### Step 3: Select Technology
1. Evaluate options against requirements
2. Consider existing codebase stack
3. Document rationale for choices

### Step 4: Plan Implementation
1. Break into phases (Setup → Core → Integration → Polish)
2. Identify dependencies between components
3. Estimate effort for each phase

### Step 5: Assess Risks
1. Identify technical risks
2. Plan mitigations
3. Note assumptions

## Plan Output Format

```markdown
# Technical Plan: [Task ID]

## Overview
[2-3 sentence summary of approach]

## Architecture

### System Diagram
```mermaid
[architecture diagram]
```

### Components
| Component | Responsibility | Dependencies |
|-----------|---------------|--------------|
| [name] | [what it does] | [depends on] |

## Technology Stack
- **Frontend**: [choice] - [rationale]
- **Backend**: [choice] - [rationale]
- **Database**: [choice] - [rationale]
- **Infrastructure**: [choice] - [rationale]

## API Design
[Key endpoints and contracts]

## Data Models
[Entity definitions and relationships]

## Security Considerations
- [consideration]: [approach]

## Performance Targets
| Metric | Target | Approach |
|--------|--------|----------|
| [metric] | [value] | [how to achieve] |

## Implementation Phases

### Phase 1: Setup
- [task with estimate]

### Phase 2: Core
- [task with estimate]

### Phase 3: Integration
- [task with estimate]

### Phase 4: Polish
- [task with estimate]

## Risks
| Risk | Probability | Impact | Mitigation |
|------|-------------|--------|------------|
| [risk] | [H/M/L] | [H/M/L] | [approach] |

## Testing Strategy
- **Unit**: [approach]
- **Integration**: [approach]
- **E2E**: [approach]

## Open Questions
- [questions needing answers before implementation]
```

## Diagram Templates

See `assets/diagram-templates.md` for common architecture diagram patterns.

## Integration

- Input from: `sdd-research` skill, `sdd-explorer` subagent
- Output to: `/tasks` command, `sdd-implementer` subagent
- Works with: `sdd-planner` subagent for complex architectures
- Use the ask question tool for architectural decisions with significant tradeoffs

Overview

This skill transforms specifications into clear, actionable technical plans. It produces structured architecture, technology choices, implementation phases, risk assessments, and test strategies tailored to the spec and project constraints.

How this skill works

The skill reads the provided specification and research artifacts, extracts functional and non-functional requirements, then designs an architecture and component breakdown. It selects technology options with rationale, sequences implementation phases with estimates, and produces a markdown plan that can be exported as tasks for implementation.

When to use it

You have a spec but no implementation plan
Designing system architecture or component responsibilities
Breaking features into phased, implementable tasks
Preparing for development handoff or sprint planning
After research is complete and tradeoffs need to be recorded

Best practices

Start by confirming acceptance criteria and non-functional requirements from the spec
Prefer existing platform stack when it meets requirements to reduce risk
Break work into phases (Setup → Core → Integration → Polish) with clear dependencies
Document technology tradeoffs and assumptions explicitly
Include measurable performance and security targets to guide implementation

Example use cases

Convert a product spec into a technical plan with components, APIs, and data models
Design an architecture for a new microservice and estimate implementation effort
Create phased implementation and testing strategy for a feature rollout
Produce risk register and mitigation steps before development kickoff
Generate task-ready output to feed into a /tasks pipeline for execution

FAQ

What inputs does the skill need?

A spec file (spec.md), any research outputs, and context about the existing codebase or constraints.

How are technology choices justified?

Choices are evaluated against functional and non-functional requirements, existing stack compatibility, and tradeoffs are documented in the plan.