---

description: Creates comprehensive Technical Design Documents (TDD) with mandatory and optional sections through interactive discovery. Use when user asks to "write a design doc", "create a TDD", "technical spec", "architecture document", "RFC", "design proposal", or needs to document a technical decision before implementation. Do NOT use for README files, API docs, or general documentation (use docs-writer instead). name: technical-design-doc-creator

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:

1. Header & Metadata
2. Context
3. Problem Statement & Motivation
4. Scope (In Scope / Out of Scope)
5. Technical Solution
6. Risks
7. 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)

8. Security Considerations (MANDATORY for payments/auth/PII)
9. Testing Strategy
10. Monitoring & Observability
11. Rollback Plan

Suggested Sections (Offer to User)

Ask user: "Would you like to add these sections now or later?"

12. Success Metrics
13. Glossary & Domain Terms
14. Alternatives Considered
15. Dependencies
16. Performance Requirements
17. Migration Plan (if applicable)
18. Open Questions
19. Roadmap / Timeline
20. 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": [] // Free text
    },
    {
      "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?",
      "options": [
        { "id": "yes", "label": "Yes, I can provide it now" },
        { "id": "partial", "label": "Partially, need help clarifying" },
        { "id": "no", "label": "No, need help defining it" }
      ]
    }
  ]
}

Step 2: Validate Mandatory Information

Based on answers, check if user can provide:

MANDATORY fields to ask if missing:

• Tech Lead / Owner
• Team members
• Problem description (what/why/impact)
• What is in scope
• What is out of scope
• High-level solution approach
• At least 3 risks
• Implementation tasks breakdown

Ask using AskQuestion or natural conversation IN THE USER'S LANGUAGE:

English Example:

I need the following information to create the TDD:

1. **Problem Statement**:
   - What problem are we solving?
   - Why is this important now?
   - What happens if we don't solve it?

2. **Scope**:
   - What WILL be delivered in this project?
   - What will NOT be included (out of scope)?

3. **Technical Approach**:
   - High-level description of the solution
   - Main components involved
   - Integration points

Can you provide this information?

Portuguese Example:

Preciso das seguintes informações para criar o TDD:

1. **Definição do Problema**:
   - Que problema estamos resolvendo?
   - Por que isso é importante agora?
   - O que acontece se não resolvermos?

2. **Escopo**:
   -