Software Architect

Design scalable software architectures with ADR-style decision documentation.

Updated Apr 16, 2026
One-click install
npx skills add https://github.com/jc180105/.opencode --skill software-architect-jc180105
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Software Architect
Source: https://github.com/jc180105/.opencode/tree/main/.opencode/skills/engineering-software-architect
Command: npx skills add https://github.com/jc180105/.opencode --skill software-architect-jc180105

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Software Architects solve the challenge of designing software systems that are scalable, maintainable, and aligned with evolving business domains. They balance bounded contexts, patterns, and trade-offs to ensure long-term viability and reduce architectural drift.

Core Features & Use Cases

  • Domain modeling and bounded context mapping to maintain alignment with business capabilities.
  • Architectural pattern guidance (modular monolith, microservices, event-driven) and trade-off analysis.
  • ADR-driven decision documentation to capture context, options, and rationale.

Quick Start

Provide a scalable, maintainable architecture for a new system and outline the first ADR with rationale.

Frequently Asked Questions about Software Architect

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

FAQPage Schema
How do I design scalable software architecture for a complex system?

Design scalable software architecture by framing explicit problem boundaries, analyzing trade-offs across patterns, and documenting rationale using ADRs. This process enforces clear bounded context mapping to ensure long-term maintainability and reduce architectural drift across evolving business domains.

What is the best way to document architectural decisions and trade-offs?

The best way to document architectural decisions is using ADR-driven documentation to capture context, options, and rationale. This method records explicit trade-off analyses, ensuring long-term viability and preventing architectural drift when business domains evolve or system requirements shift.

When do I need domain-driven design and bounded context mapping?

You need domain-driven design and bounded context mapping when aligning complex software systems with evolving business capabilities. This approach maintains structural clarity by defining explicit boundaries, reducing architectural drift, and ensuring the system architecture accurately reflects business domains.

How do I choose between a modular monolith and microservices architecture?

Choose between a modular monolith and microservices by conducting explicit trade-off analysis. Evaluate system complexity, scalability requirements, and domain boundaries to determine whether a monolithic or distributed event-driven pattern best supports your long-term evolution strategy.

Can I use this for evolving an existing architecture instead of starting new?

Yes, you can use this for evolving existing architectures. The process applies domain modeling, bounded context mapping, and ADR-driven documentation to manage evolution strategy, ensuring ongoing alignment with business capabilities while preventing architectural drift during system scaling.

Why does architectural drift occur in complex software systems?

Architectural drift occurs when software systems lack explicit trade-off analysis and ADR-driven decision documentation. Without clear problem framing, bounded contexts, and rationale tracking, system designs gradually lose alignment with evolving business domains, severely impacting long-term viability and maintainability.