agency-software-architect

Design software architectures with bounded contexts and Architecture Decision Records.

Updated Feb 11, 2026
One-click install
npx skills add https://github.com/augustoheiss/LogicDefense --skill agency-software-architect-augustoheiss
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: agency-software-architect
Source: https://github.com/augustoheiss/LogicDefense/tree/main/.gemini/skills/agency-software-architect
Command: npx skills add https://github.com/augustoheiss/LogicDefense --skill agency-software-architect-augustoheiss

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Designs clear, pragmatic software architectures that balance business needs, technical constraints, and team capabilities to avoid overengineering, costly rewrites, and unclear ownership of system responsibilities.

Core Features & Use Cases

  • Domain modeling & bounded contexts: Identify aggregates, domain events, and context maps to reduce coupling and clarify responsibilities.
  • Architecture selection & patterns: Recommend modular monoliths, microservices, event-driven systems, CQRS, or hybrid approaches with trade-offs tailored to team size and operational needs.
  • Trade-off analysis & ADRs: Produce Architecture Decision Records that document options, rationale, consequences, and reversibility for future maintainers.
  • Use Case: When migrating a monolith, use this Skill to map bounded contexts, evaluate service split points, compare consistency vs availability implications, and produce a staged migration plan.

Quick Start

Draft an ADR that evaluates splitting the payments module into a microservice versus keeping it in a modular monolith, listing options, trade-offs, recommended approach, and a migration rollout plan.

Frequently Asked Questions about agency-software-architect

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

FAQPage Schema
How do I identify bounded contexts when migrating a monolith to microservices?

To identify bounded contexts, map domain events, aggregates, and context maps to reduce coupling and clarify system responsibilities. This domain-driven design process defines clear service boundaries for maintainable microservices.

What is the best way to document software architecture trade-offs for future maintainers?

Document software architecture trade-offs by creating Architecture Decision Records that outline options, rationale, consequences, and reversibility. ADRs provide clear context for future maintainers evaluating system design choices.

When should I choose a modular monolith over microservices for my distributed system?

Choose a modular monolith over microservices when balancing team size and operational needs against consistency and availability implications. Architecture selection depends on evaluating specific trade-offs to avoid overengineering and costly rewrites.

How do I create a staged migration plan for splitting a module into a microservice?

Create a staged migration plan by evaluating service split points, comparing consistency versus availability implications, and mapping bounded contexts. This staged approach emphasizes reversibility, observability, and maintainability throughout the rollout.

Does event-driven architecture or CQRS work better for scalable web services?

Event-driven architecture and CQRS suitability depends on your specific team capabilities, technical constraints, and operational needs. Architecture selection requires analyzing trade-offs between these patterns to ensure scalable and maintainable web services.