technical-design-patterns

Create technical design documents for ABP Framework features.

24|5|Updated Nov 28, 2025
One-click install
npx skills add https://github.com/thapaliyabikendra/ai-artifacts --skill technical-design-patterns
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: technical-design-patterns
Source: https://github.com/thapaliyabikendra/ai-artifacts/tree/main/.claude/skills/technical-design-patterns
Command: npx skills add https://github.com/thapaliyabikendra/ai-artifacts --skill technical-design-patterns

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides structured patterns for creating comprehensive technical design documents, solving the challenge of inconsistent or incomplete design specifications. It ensures that complex features are well-thought-out, documented, and aligned with architectural principles before implementation begins.

Core Features & Use Cases

  • Standardized Templates: Offers templates for various sections of a technical design document, including problem statement, architecture, data model, API design, and testing strategy.
  • Decision Logging: Guides on documenting key technical decisions, alternatives considered, and trade-offs, providing context for future development.
  • Diagram Integration: Encourages the use of diagrams (e.g., Mermaid ERD, sequence diagrams) to visually represent system components and interactions.
  • Use Case: A backend architect is designing a new user authentication module. Using this skill, they create a detailed technical design document outlining the chosen authentication flow, database schema changes, API endpoints, and security considerations.

Quick Start

Outline the key sections for a technical design document for a new 'User Profile Management' feature, including problem statement, data model, and API design.

Frequently Asked Questions about technical-design-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I create a technical design document for a new feature?

Technical design documents outline the problem statement, architecture, data model, API design, and testing strategy before implementation. Structure your design with sections covering the feature's goals, chosen approach with trade-offs documented, database schema changes, API contracts, permissions, validation rules, caching strategy, and DTO definitions to align the team and catch issues early.

What should I include in an API contract and database schema design?

API contracts specify endpoints, request/response formats, authentication requirements, and error handling. Database schema design documents table structures, relationships, indexes, and constraints. Both should include validation rules, permission boundaries, caching considerations, and rationale for key decisions to guide implementation and code review.

When do I need architecture decision records for technical specifications?

Architecture decision records (ADRs) document significant technical choices—alternatives evaluated, trade-offs accepted, and rationale—when designing features with multiple valid approaches. Use ADRs for REST API design, authentication flows, caching strategies, or schema decisions to provide context for future maintainers and justify architectural constraints.

Can I use technical design patterns with ABP Framework features?

Yes. This approach applies directly to ABP Framework feature design, covering REST API contracts, database schemas, permissions models, validation rules, caching strategies, and DTO definitions specific to ABP implementation patterns to standardize and document complex feature rollout.

How do I document design trade-offs and alternative approaches?

Document each key decision with the alternatives you considered, why you rejected them, and which trade-offs you accepted in the chosen approach. Include rationale tied to technical constraints, performance requirements, or architectural principles so future developers understand the reasoning and can revisit decisions if context changes.

What diagrams should I include in technical design documentation?

Use visual representations like Mermaid ERD for database schemas, sequence diagrams for API interaction flows, and system architecture diagrams to show component relationships. Diagrams clarify complex interactions and serve as quick references during implementation and code review.