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:

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)

❌ What to Avoid (Implementation Code)

Examples: High-Level vs Implementation

❌ BAD (Too Implementation-Specific)

**Rollback Steps**:

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)

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:

@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)

**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)

1. Security Considerations (MANDATORY for payments/auth/PII)
2. Testing Strategy
3. Monitoring & Observability