design-code-architecture

Guide software architecture design through domain modeling and system sizing phases.

Updated Jul 31, 2026
One-click install
npx skills add https://github.com/fsolla/teqo --skill design-code-architecture
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: design-code-architecture
Source: https://github.com/fsolla/teqo/tree/main/.agents/skills/design-code-architecture
Command: npx skills add https://github.com/fsolla/teqo --skill design-code-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill solves the problem of architectural drift and over-engineering by guiding users through a structured, resumable journey that prioritizes expensive-to-reverse decisions while keeping the rest of the system simple.

Core Features & Use Cases

  • Guided Architectural Journey: Orchestrates eight distinct phases covering boundaries, domain modeling, system sizing, data persistence, and resilience.
  • Decision Documentation: Automatically records key architectural choices and rationale in project documentation to ensure consistency across sessions.
  • Use Case: Use this when starting a new application to define bounded contexts and clean boundaries, or when refactoring a prototype to ensure it can scale and remain maintainable as the team grows.

Quick Start

Invoke the design-code-architecture skill to begin the architectural planning process for your new application.

Frequently Asked Questions about design-code-architecture

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

FAQPage Schema
How do I define bounded contexts and clean architecture boundaries for a new application?

To define bounded contexts and clean architecture boundaries, you need a structured domain modeling process that isolates business capabilities. This skill guides you through modular monolith design and bounded context definition to ensure long-term maintainability.

What is the best way to prevent architectural drift when refactoring a prototype?

Preventing architectural drift requires documenting key architectural choices and rationale in decision logs. By prioritizing expensive-to-reverse decisions and keeping the rest simple, you can refactor prototypes to scale and remain maintainable as your team grows.

Can I use this architectural design process for both new projects and system refactoring?

Yes, this architectural design process applies to both new project initialization and architectural refactoring scenarios. It orchestrates a multi-phase journey covering domain modeling, system sizing, and data strategy to ensure reversibility and maintainability.

How does domain-driven design help with integration-point hardening and system resilience?

Domain-driven design helps with integration-point hardening by establishing clear bounded contexts that isolate failures. This structured approach covers system sizing and data persistence strategies, directly improving overall system resilience and long-term maintainability.

Do I need to document architectural decisions to maintain consistency across sessions?

Yes, documenting architectural decisions is required to maintain consistency across sessions. The process automatically records key architectural choices and rationale in project documentation, preventing architectural drift and over-engineering.

What's the difference between modular monolith design and over-engineering a system?

Modular monolith design differs from over-engineering by deliberately prioritizing expensive-to-reverse decisions while keeping the rest of the system simple. It focuses on clean boundaries and bounded contexts rather than adding unnecessary complexity.