senior-architect

name: senior-architectdescription: >  System architecture design and review. Use when designing architecture, evaluating  microservices vs monolith, writing ADRs, choosing a database, planning for scalability,  reviewing system design, or generating architecture diagrams.license: MIT + Commons Clausemetadata:   version: 1.1.0  author: borghei  category: engineering  domain: system-design  updated: 2026-06-17  tags: [system-design, distributed-systems, architecture, adr, scalability]

Senior Architect

Architecture design and analysis tools for making informed technical decisions: visualize system structure, analyze dependencies and coupling, detect architectural patterns, and run decision workflows for databases, patterns, and monolith-vs-microservices trade-offs.

Core Capabilities

• Diagram generation — produce component, layer, and deployment diagrams in Mermaid, PlantUML, or ASCII from a project directory.
• Dependency analysis — map the dependency tree, score coupling (0-100), and detect circular dependencies across npm, pip, Poetry, Go modules, and Cargo.
• Pattern detection — assess an existing codebase for layered/MVC/hexagonal/clean/microservices patterns, layer violations, god classes, and mixed concerns.
• Database selection — match data characteristics, scale, and consistency needs to SQL/NoSQL options with an ADR template.
• Pattern & topology selection — choose an architecture pattern by team size, deployment, and data-boundary requirements.
• Monolith vs microservices — apply decision checklists and a modular-monolith-first hybrid strategy.

When to Use

• Designing a new system or refactoring existing architecture.
• Evaluating microservices vs monolith, or choosing a database.
• Writing an ADR, planning for scalability, or reviewing a system design.
• Generating architecture diagrams for documentation or team review.

Clarify First

Before generating diagrams or an assessment, settle the inputs below. When one is missing or vague and would change the result, ask about it; when it wouldn't, use a sensible default and say which one you used.

• Project root: the codebase directory to analyze (drives pattern detection, dependency scoring, and diagram contents).
• Diagram type & format: component / layer / deployment in Mermaid / PlantUML / ASCII (sets what the generator emits).
• Architecture decision in question: e.g. database choice or monolith vs microservices (selects the decision workflow and ADR).

Ask about the two or three inputs that matter most for this request, not the whole list. If the user wants a result straight away, produce it and state your assumptions at the top.

Tools

Run any script with --help for full flags.

References

Load the reference that matches the task — keep this file lean and pull detail on demand:

• references/architecture_patterns.md — 9 architecture patterns (monolith, modular monolith, microservices, event-driven, CQRS, event sourcing, hexagonal, clean, API gateway) with trade-offs and code examples. Read when asked "which pattern?", "microservices vs monolith", "event-driven", or "CQRS".
• references/system_design_workflows.md — 6 step-by-step workflows: design interview, capacity planning, API design, database schema design, scalability assessment, migration planning. Read when asked "how to design?", "capacity planning", "API design", or "migration".
• references/tech_decision_guide.md — decision frameworks and comparison matrices for database, caching, message queue, auth, frontend framework, cloud provider, and API style. Read when asked "which database/framework/cloud/cache?".
• references/decision_workflows.md — the database-selection, architecture-pattern-selection, and monolith-vs-microservices decision workflows with matrices, checklists, and the ADR template. Read when making a documented architecture decision.
• references/tools-and-usage.md — detailed per-tool usage, example outputs, full flag tables, common-command catalog, tech-stack coverage, troubleshooting table, and success criteria. Read when running the scripts or interpreting their output.

Scope & Limitations

Covers: system-level architecture analysis (pattern detection, layer validation, component diagramming) for existing codebases; technology-agnostic dependency analysis across npm, pip, Poetry, Go modules, and Cargo; architecture decision workflows (database, pattern, monolith-vs-microservices); diagram generation in Mermaid, PlantUML, and ASCII.

Does NOT cover:

• Runtime performance profiling or load testing — use senior-devops (capacity planning) and senior-qa (performance test harnesses).
• Security vulnerability scanning of dependencies — use senior-security or senior-secops for CVE/SAST/DAST.
• Frontend component architecture and design-system auditing — use senior-frontend and design-auditor.
• CI/CD pipeline design and deployment orchestration — use senior-devops and release-orchestrator.

Integration Points