skills.rest
VKirill
VKirillCOMMUNITY
Explore all skills by this author →
GitHub

architecture-craft

Guide system architecture decisions using DDD bounded contexts and ADRs.

15|2|Updated May 23, 2026
Search Tags:#architecture#microservices#adr#distributed-systems#domain-driven-design#saga#bounded-context
One-click install
npx skills add https://github.com/VKirill/antigravity-for-claude-code --skill architecture-craft
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: architecture-craft
Source: https://github.com/VKirill/antigravity-for-claude-code/tree/main/skills/architecture-craft
Command: npx skills add https://github.com/VKirill/antigravity-for-claude-code --skill architecture-craft

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

architecture-craft helps teams avoid costly architectural thrash by turning system design into a repeatable decision discipline grounded in trusted models, clear trade-offs, and explicit constraints.

Core Features & Use Cases

  • Subdomain categorization (Core / Supporting / Generic) to allocate rigor and prevent reinventing solved problems.
  • Bounded contexts + ubiquitous language to define consistency boundaries and reduce term confusion across teams.
  • Architecture quantum + style selection to choose modular monolith vs distributed designs based on independent deployment, coupling, and data ownership.
  • ADR-driven trade-off documentation so “why” decisions are preserved and re-litigations are avoided.
  • Incremental decomposition (Strangler Fig + Sagas) to migrate safely without big-bang rewrites or incorrect distributed transactions.
  • Inter-service communication rules + evolution guardrails such as tolerant readers and additive compatibility.

Quick Start

Use architecture-craft when you are planning a major system design or decomposition and need a clear bounded-context and ADR-based decision plan for how services and data ownership should work.

Frequently Asked Questions about architecture-craft

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

FAQPage Schema
How do I decide between a modular monolith and distributed microservices for my system architecture?▼

System architecture decisions are guided by applying DDD bounded contexts, architecture quanta, and trade-off governance using ADRs. This ensures clear consistency boundaries and prevents architectural thrash in distributed style selection.

How do I decompose a monolith into microservices without a big-bang rewrite?▼

Decompose a monolith using the Strangler Fig pattern for incremental migration and Saga-first distributed workflows. This ensures safe decomposition without big-bang rewrites or incorrect distributed transactions across newly formed services.

When do I need bounded contexts and ubiquitous language in domain-driven design?▼

Bounded contexts and ubiquitous language are needed to define consistency boundaries and reduce term confusion across teams. They allocate rigor by categorizing subdomains into Core, Supporting, or Generic to prevent reinventing solved problems.

How do I manage distributed transactions across microservices without two-phase commit?▼

Manage distributed transactions by enforcing Saga-first distributed workflows. This approach coordinates data ownership across bounded contexts safely, avoiding the pitfalls of incorrect distributed transactions during inter-service communication.

What is the best way to document architecture decisions to prevent re-litigation?▼

Document significant architecture decisions as explicit Architecture Decision Records (ADRs). ADR-driven trade-off documentation preserves the reasoning behind choices, ensuring the decision context is understood and preventing future re-litigations.

How do I enforce data ownership and inter-service contracts in a distributed system?▼

Enforce per-context data ownership and apply inter-service communication rules like tolerant readers and additive compatibility. These evolution guardrails prevent contract violations and maintain service autonomy across bounded contexts.

Related Skills

Explore More Software Engineering Skills→
guilhermemarketingguilhermemarketing
59

domain-analysis

Identify subdomains and map bounded contexts across codebases.

Community
Advanced
crgarcia12crgarcia12

rewrite-planner

Plan incremental component rewrites using the strangler fig pattern.

Community
Advanced
p-o-ke-naep-o-ke-nae

microservices-patterns

Design resilient microservices architectures with service boundaries and communication patterns.

Community
Advanced
ano4lano4l

senior-architect

Document system architecture decisions with ADRs and diagrams in Mermaid, PlantUML, or ASCII.

Community
Advanced