home / skills / secondsky / claude-skills / technical-specification

This skill generates comprehensive technical specifications for software projects, guiding architecture, API design, testing strategies, and documentation.

npx playbooks add skill secondsky/claude-skills --skill technical-specification

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

Files (2)
SKILL.md
2.9 KB
---
name: technical-specification
description: Creates detailed technical specifications for software projects covering requirements, architecture, APIs, and testing strategies. Use when planning features, documenting system design, or creating architecture decision records.
---

# Technical Specification

Create comprehensive technical specifications for software projects.

## Specification Template

```markdown
# Technical Specification: [Feature Name]

## Metadata
- **Status**: Draft | In Review | Approved
- **Author**: [Name]
- **Reviewers**: [Names]
- **Last Updated**: [Date]

## Executive Summary
[2-3 sentences: What problem does this solve? What's the proposed solution?]

## Background & Context
- Current pain points
- Why now?
- Related work

## Goals
### Primary Goals
1. [Measurable goal]

### Non-Goals
- [What this spec explicitly does NOT cover]

## Functional Requirements
| ID | Requirement | Priority |
|----|-------------|----------|
| FR-1 | [Description] | P0 |
| FR-2 | [Description] | P1 |

## Non-Functional Requirements
- **Performance**: Response time < 200ms
- **Scalability**: Support 10K concurrent users
- **Availability**: 99.9% uptime
- **Security**: [Requirements]

## Technical Design

### Architecture
[Diagram or description]

### API Design
```
POST /api/v1/resource
Request: { "field": "value" }
Response: { "id": "123", "field": "value" }
```

### Database Schema
```sql
CREATE TABLE resources (
  id UUID PRIMARY KEY,
  field VARCHAR(255)
);
```

## Implementation Plan
| Phase | Timeline | Deliverables |
|-------|----------|--------------|
| 1 | Week 1-2 | Core functionality |
| 2 | Week 3 | API endpoints |
| 3 | Week 4 | Testing & docs |

## Testing Strategy
- Unit tests: 80% coverage
- Integration tests: API endpoints
- E2E tests: Critical flows

## Risks & Mitigations
| Risk | Probability | Impact | Mitigation |
|------|-------------|--------|------------|
| [Risk] | Medium | High | [Plan] |

## Success Criteria
- [ ] All P0 requirements implemented
- [ ] Tests passing
- [ ] Performance targets met
- [ ] Documentation complete
```

## Full Template

See [references/template.md](references/template.md) for a comprehensive copy-paste template including:
- Complete metadata section
- Success metrics tables
- Architecture diagrams
- Detailed API design sections
- Security threat analysis
- Monitoring & observability
- Risk assessment matrix
- Rollout and rollback plans
- Dependencies tracking
- Open questions section

## Best Practices

**Do:**
- Include measurable acceptance criteria
- Add architecture diagrams
- Define explicit API contracts
- Quantify performance targets
- Document risks and mitigations
- Get stakeholder review before implementation
- Include security considerations
- Define rollback procedures

**Don't:**
- Use vague requirements ("fast", "scalable")
- Skip non-functional requirements
- Ignore security considerations
- Leave alternatives unexplored
- Omit testing strategy
- Forget dependencies and risks

Overview

This skill creates comprehensive technical specifications for software projects covering requirements, architecture, APIs, data models, testing, and rollout plans. It produces a reusable, measurable template you can apply to features, system designs, and architecture decision records. The output is structured to support stakeholder reviews and implementation planning.

How this skill works

The skill generates a full specification using a standardized template: metadata, executive summary, goals, functional and non-functional requirements, technical design, API examples, database schemas, implementation plan, testing strategy, risks, and success criteria. It fills in measurable acceptance criteria, performance targets, and rollout/rollback guidance based on provided project inputs. Diagrams, tables, and code snippets are included where applicable to make the design actionable.

When to use it

  • Planning a new feature or service before engineering work begins
  • Documenting system design for cross-team alignment or onboarding
  • Creating architecture decision records (ADRs) for major choices
  • Preparing implementation-ready API contracts and database schemas
  • Defining testing, monitoring, and rollback plans prior to release

Best practices

  • Include measurable acceptance criteria for every primary goal
  • Specify non-functional requirements explicitly (performance, scalability, security)
  • Provide API contracts and sample request/response payloads
  • Add architecture diagrams and a clear implementation timeline
  • Document risks, mitigations, and dependencies up front
  • Request stakeholder review and sign-off before coding begins

Example use cases

  • Drafting a spec for a new user-facing feature with API and DB changes
  • Designing a scalable microservice with performance and availability targets
  • Creating an ADR comparing authentication options and recommended approach
  • Preparing test plans and success criteria for a major release
  • Producing developer-facing docs that include schema and example API calls

FAQ

How do I use this for incremental changes?

Focus the spec on the delta: list current behavior, desired change, impacted components, and migration plan. Keep scope small and measurable.

Can it include diagrams and code snippets?

Yes. The spec supports architecture diagrams, SQL schemas, and API request/response examples to make implementation explicit.