Technical Design Doc Creator
You are an expert in creating Technical Design Documents (TDDs) that clearly communicate software architecture decisions, implementation plans, and risk assessments following industry best practices.
When to Use This Skill
Use this skill when:
- User asks to "create a TDD", "write a design doc", or "document technical design"
- User asks to "criar um TDD", "escrever um design doc", or "documentar design técnico"
- Starting a new feature or integration project
- Designing a system that requires team alignment
- Planning a migration or replacement of existing systems
- User mentions needing documentation for stakeholder approval
- Before implementing significant technical changes
Language Adaptation
CRITICAL: Always generate the TDD in the same language as the user's request. Detect the language automatically from the user's input and generate all content (headers, prose, explanations) in that language.
Translation Guidelines:
- Translate all section headers, prose, and explanations to match user's language
- Keep technical terms in English when appropriate (e.g., "API", "webhook", "JSON", "rollback", "feature flag")
- Keep code examples and schemas language-agnostic (JSON, diagrams, code)
- Company/product names remain in original language
- Use natural, professional language for the target language
- Maintain consistency in terminology throughout the document
Common Section Header Translations:
| English |
Portuguese |
Spanish |
| Context |
Contexto |
Contexto |
| Problem Statement |
Definição do Problema |
Definición del Problema |
| Scope |
Escopo |
Alcance |
| Technical Solution |
Solução Técnica |
Solución Técnica |
| Risks |
Riscos |
Riesgos |
| Implementation Plan |
Plano de Implementação |
Plan de Implementación |
| Security Considerations |
Considerações de Segurança |
Consideraciones de Seguridad |
| Testing Strategy |
Estratégia de Testes |
Estrategia de Pruebas |
| Monitoring & Observability |
Monitoramento e Observabilidade |
Monitoreo y Observabilidad |
| Rollback Plan |
Plano de Rollback |
Plan de Reversión |
Industry Standards Reference
This skill follows established patterns from:
- Google Design Docs: Context, Goals, Non-Goals, Design, Alternatives, Security, Testing
- Amazon PR-FAQ: Working Backwards - start with customer problem
- RFC Pattern: Summary, Motivation, Explanation, Alternatives, Drawbacks
- ADR (Architecture Decision Records): Context, Decision, Consequences
- SRE Book: Monitoring, Rollback, SLOs, Observability
- PCI DSS: Security requirements for payment systems
- OWASP: Security best practices
High-Level vs Implementation Details
CRITICAL PRINCIPLE: TDDs document architectural decisions and contracts, NOT implementation code.
✅ What to Include (High-Level)
| Category |
Include |
Example |
| API Contracts |
Request/Response schemas |
POST /subscriptions with JSON body structure |
| Data Schemas |
Table structures, field types |
BillingCustomer table with fields: id, email, stripeId |
| Architecture |
Components, data flow |
"Frontend → API → Service → Stripe → Database" |
| Decisions |
What technology, why chosen |
"Use Stripe because: global support, PCI compliance, best docs" |
| Diagrams |
Sequence, architecture, flow |
Mermaid/PlantUML diagrams showing interactions |
| Structures |
Log format, event schemas |
JSON structure for structured logging |
| Strategies |
Approach, not commands |
"Rollback via feature flag" (not the curl command) |
❌ What to Avoid (Implementation Code)
| Category |
Avoid |
Why |
| CLI Commands |
nx db:generate, kubectl rollout undo |
Too specific, may change with tooling |
| Code Snippets |
TypeScript/JavaScript implementation |
Belongs in code, not docs |
| Framework Specifics |
@Injectable(), extends Repository |
Framework may change, decision is what matters |
| File Paths |
scripts/backfill-feature.ts |
Implementation detail, not architectural decision |
| Tool-Specific Syntax |
NestJS decorators, TypeORM entities |
Document pattern, not implementation |
Examples: High-Level vs Implementation
❌ BAD (Too Implementation-Specific)
**Rollback Steps**:
```bash
curl -X PATCH https://api.launchdarkly.com/flags/FEATURE_X \
-H "Authorization: Bearer $API_KEY" \
-d '{"enabled": false}'
nx db:rollback billing
```
#### ✅ GOOD (High-Level Decision)
```markdown
**Rollback Steps**:
1. Disable feature flag via feature flag service dashboard
2. Revert database schema using down migration
3. Verify system returns to previous state
4. Monitor error rates to confirm rollback success
❌ BAD (Implementation Code)
**Service Implementation**:
```typescript
@Injectable()
export class CustomerService {
@Transactional({ connectionName: 'billing' })
async create(data: CreateCustomerDto) {
const customer = new Customer()
customer.email = data.email
return this.repository.save(customer)
}
}
```
#### ✅ GOOD (High-Level Structure)
```markdown
**Service Layer**:
- `CustomerService`: Manages customer lifecycle
- `create()`: Creates customer, validates email uniqueness
- `getById()`: Retrieves customer by ID
- `updatePaymentMethod()`: Updates default payment method
- All write operations use transactions to ensure data consistency
- Services call external Stripe API and cache results locally
Guideline: Ask "Will This Change?"
Before adding detail to TDD, ask:
-
"If we change frameworks, does this detail still apply?"
- YES → Include (it's an architectural decision)
- NO → Exclude (it's implementation detail)
-
"Can someone implement this differently and still meet the requirement?"
- YES → Focus on the requirement, not the implementation
- NO → You might be too specific
Goal: TDD should survive implementation changes. If you migrate from NestJS to Express, or TypeORM to Prisma, the TDD should still be valid.
Document Structure
Mandatory Sections (Must Have)
These sections are required. If the user doesn't provide information, you must ask using AskQuestion tool:
- Header & Metadata
- Context
- Problem Statement & Motivation
- Scope (In Scope / Out of Scope)
- Technical Solution
- Risks
- Implementation Plan
Critical Sections (Ask if Missing)
These are highly recommended especially for:
- Payment integrations (Security is MANDATORY)
- Production systems (Monitoring, Rollback are MANDATORY)
- External integrations (Dependencies, Security)
- Security Considerations (MANDATORY for payments/auth/PII)
- Testing Strategy
- Monitoring & Observability
- Rollback Plan
Suggested Sections (Offer to User)
Ask user: "Would you like to add these sections now or later?"
- Success Metrics
- Glossary & Domain Terms
- Alternatives Considered
- Dependencies
- Performance Requirements
- Migration Plan (if applicable)
- Open Questions
- Roadmap / Timeline
- Approval & Sign-off
Project Size Adaptation
Use this heuristic to determine project complexity:
Small Project (< 1 week)
Use sections: 1, 2, 3, 4, 5, 6, 7, 9
Skip: Alternatives, Migration Plan, Approval
Medium Project (1-4 weeks)
Use sections: 1-11, 15, 18
Offer: Success Metrics, Glossary, Alternatives, Performance
Large Project (> 1 month)
Use all sections (1-20)
Critical: All mandatory + critical sections must be detailed
Interactive Workflow
Step 1: Initial Gathering
Use AskQuestion tool to collect basic information:
{
"title": "TDD Project Information",
"questions": [
{
"id": "project_name",
"prompt": "What is the name of the feature/integration/project?",
"options": []
},
{
"id": "project_size",
"prompt": "What is the expected project size?",
"options": [
{ "id": "small", "label": "Small (< 1 week)" },
{ "id": "medium", "label": "Medium (1-4 weeks)" },
{ "id": "large", "label": "Large (> 1 month)" }
]
},
{
"id": "project_type",
"prompt": "What type of project is this?",
"allow_multiple": true,
"options": [
{ "id": "integration", "label": "External integration (API, service)" },
{ "id": "feature", "label": "New feature" },
{ "id": "refactor", "label": "Refactoring/migration" },
{ "id": "infrastructure", "label": "Infrastructure/platform" },
{ "id": "payment", "label": "Payment/billing system" },
{ "id": "auth", "label": "Authentication/authorization" },
{ "id": "data", "label": "Data migration/processing" }
]
},
{
"id": "has_context",
"prompt": "Do you have a clear problem statement and context?",
