mcpField
M
macro-architecture

macro-architecture

github.com/robsonrungDevelopment244 installsUpdated 2d ago
Repository

About macro-architecture

A skill for selecting system-level architecture styles and evaluating service decomposition trade-offs using requirements, code, and runtime evidence.

Key features

  1. 01Architecture style selection
  2. 02Service decomposition analysis
  3. 03Trade-offs grounded in runtime evidence
  4. 04Focused architecture references

Use cases

  1. 01Choosing an architecture for a new system
  2. 02Assessing whether to split or merge services

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/robsonrung/rar-skills --skill macro-architecture

After installing, type/macro-architecturein Claude Code to confirm it loaded.

Bundled files

References and scripts installed along with SKILL.md.

references/
adrtemplate.md
catalog.md
decomposition.md
event-driven.md
layered.md
microkernel.md
microservices.md
other-styles.md
space-based.md
style-selection.md
traps.md
scripts/
newadr.py

Details

From the project README

Macro Architecture

Two complementary system-level tools that work at the same altitude — what shape should this system take?

  • Style selection — given a system/service/feature and its driving requirements, which macro architecture style (or hybrid) fits, and what does the book warn about if you pick it? (from Software Architecture Patterns, 2nd ed., Mark Richards.)
  • Hard-parts decomposition — once you're decomposing, merging, or re-shaping a system, which way do the trade-offs actually push, anchored in the current code and runtime? (from Software Architecture: The Hard Parts, Ford & Richards.)

Use Style selection when choosing an overall shape for something new (or sanity-checking an existing one). Use Hard-parts decomposition when the decision is whether to pull a system apart or put it back together. They compose: pick a style, then stress-test the decomposition.

Distinct from architecture-lens (code-level trade-offs/connascence and layer placement/cohesion in the code under your hands), domain-driven-design (bounded-context boundaries, ubiquitous language, cross-context integration patterns), and design-patterns (GoF code patterns). This skill picks the MACRO shape; those review the code and contexts within it.

Select the decision

NeedRead
Choose or assess an overall architecture stylereferences/style-selection.md
Split, merge, or reshape services and data ownershipreferences/decomposition.md
BothSelect the style, then assess only its unresolved decomposition tradeoffs

Use current code, runtime evidence, and the user's constraints. The smallest coherent shape is the one that meets the actual requirements. Name the benefit, cost, and next concrete move. Do not turn a routine code change into a system redesign.

Authority and output

A decision or review request returns the selected method's recommendation. Implement only when the user's request authorizes implementation. Under design-gate, stay read-only and use the caller's canonical gate result.

Use all three or no ADR: hard to reverse, surprising without context, and a real tradeoff. Record on settle using the existing ADR convention when all three apply. The decomposition method contains the fallback path and helper command.

In an interview, contribute the decision, rationale, constraints, and source references to the existing decision record. Standalone report and implementation mechanics do not apply at that stage.

Focused knowledge

Load only the material the selected method needs:

Comments

Markdown supported