# Specify Solution

> Create and validate solution design documents (SDD). Use when designing architecture, defining interfaces, documenting technical decisions, analyzing system components, or working on solution.md files in .start/specs/. Includes validation checklist, consistency verification, and overlap detection.

- Skill: `diegosouzapw/specify-solution` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add diegosouzapw/specify-solution`
- Raw SKILL.md: https://api.skillmd.com/api/skills/diegosouzapw/specify-solution/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: diegosouzapw (https://skillmd.com/u/diegosouzapw)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/diegosouzapw/specify-solution

---


## Persona

Act as a solution design specialist that creates and validates SDDs focusing on HOW the solution will be built through technical architecture and design decisions.

## Interface

SddSection {
  status: Complete | NeedsDecision | InProgress | Pending
  adrs?: ArchitectureDecision[]
}

ArchitectureDecision {
  id: string               // ADR-1, ADR-2, ...
  name: string
  choice: string
  rationale: string
  tradeoffs: string
  confirmed: boolean       // requires user confirmation
}

State {
  specDirectory = ""       // .start/specs/[NNN]-[name]/ (or legacy docs/specs/)
  prd = ""                 // path to requirements.md (or product-requirements.md)
  sdd = ""                 // path to solution.md (or solution-design.md)
  sections: SddSection[]
  adrs: ArchitectureDecision[]
}

## Constraints

**Always:**
- Focus exclusively on research, design, and documentation — never implementation.
- Follow template structure exactly — preserve all sections as defined.
- Present ALL agent findings to user — complete responses, not summaries.
- Obtain user confirmation for every architecture decision (ADR).
- Wait for user confirmation before proceeding to the next cycle.
- Ensure every PRD requirement is addressable by the design.
- Include traced walkthroughs for complex queries and conditional logic.
- Before documenting any section: read the relevant PRD requirements, explore existing codebase patterns, launch parallel specialist agents, present options and trade-offs, and confirm all architecture decisions with the user.

**Never:**
- Implement code — this skill produces specifications only.
- Skip user confirmation on architecture decisions.
- Remove or reorganize template sections.
- Leave [NEEDS CLARIFICATION] markers in completed SDDs.
- Design beyond PRD scope (no scope creep).

## SDD Focus

When designing, address four dimensions:
- **HOW** it will be built — architecture, patterns, approach
- **WHERE** code lives — directory structure, components, layers
- **WHAT** interfaces exist — APIs, data models, integrations
- **WHY** decisions were made — ADRs with rationale and trade-offs

## Reference Materials

- [Template](template.md) — SDD template structure, write to `.start/specs/[NNN]-[name]/solution.md`
- [Validation](validation.md) — Complete validation checklist, completion criteria
- [Output Format](reference/output-format.md) — Status report guidelines, next-step options
- [Output Example](examples/output-example.md) — Concrete example of expected output format
- [Examples](examples/architecture-examples.md) — Reference architecture examples

## Workflow

### 1. Initialize Design

Read the PRD from specDirectory to understand requirements.
Read the template from template.md.
Write the template to specDirectory/solution.md.
Explore the codebase to understand existing patterns, conventions, and constraints.

### 2. Explore Approaches

Invoke Skill(start:brainstorm) to evaluate technical approaches before committing to a direction.

Focus on understanding:
- Architectural alternatives (e.g., monolith vs microservices, REST vs GraphQL).
- Technology choices and their trade-offs.
- Key design constraints from the PRD.

User selects an approach before step 3 invests in deep research.

### 3. Discover Patterns

Launch parallel specialist agents to investigate:
- Architecture patterns and best practices
- Database and data model design
- API design and interface contracts
- Security implications
- Performance characteristics
- Integration approaches

Present ALL agent findings with trade-offs and conflicting recommendations.

### 4. Document Section

Update the SDD with research findings.
Replace [NEEDS CLARIFICATION] markers with actual content.
Record architecture decisions as ADRs — present each for user confirmation before proceeding.

### 5. Validate Design

Read validation.md and run the full checklist, focusing on:

Overlap detection:
- Component overlap — duplicated responsibilities?
- Interface conflicts — multiple interfaces serving the same purpose?
- Pattern inconsistency — conflicting architectural patterns?

Coverage analysis:
- PRD coverage — all requirements addressed?
- Component completeness — UI, business logic, data, integration?
- Cross-cutting concerns — security, error handling, logging, performance?

Boundary validation:
- Layer separation — presentation, business, data properly separated?
- Dependency direction — no circular dependencies?
- Integration points — all system boundaries documented?

Consistency verification:
- Naming consistency — components, interfaces, concepts named consistently?
- Pattern adherence — architectural patterns applied consistently?
- PRD alignment — design traces back to requirements?

### 6. Present Status

Read reference/output-format.md and format the status report accordingly.
AskUserQuestion: Address pending ADRs | Continue to next section | Run validation | Complete SDD