arch-crew: a plugin for deciding (and auditing) architecture

There's a failure mode I keep hitting — in my own work and in other people's. You reach for an architecture, a pattern, or an agent framework because it's the thing you've heard of, not because the problem in front of you actually needs it. The result is a microservice that wanted to be a function, a FactoryProviderStrategy wrapping a one-line if, or a ReAct loop burning tokens on a task a single prompt would have nailed.

arch-crew is three Claude Code skills that push the other way: recommend the least architecture that meets the requirement, and name the cost of every step up.

What it is

Three skills. Each one first works out where you are — starting fresh (greenfield) or working in code that already exists (refactoring) — then either runs a short selection interview or reviews what you have against a catalog:

• decide-architecture — structure, topology, data, overlays. Compose a stack, or audit the one you've already got.
• design-patterns — GoF and Python-idiomatic patterns. Which one fits — and often, the answer is "a plain function."
• agentic-patterns — design or assess an LLM-agent system layer by layer, starting from the least autonomy that does the job.

The through-line in all three: do less, and know what each "more" costs you.

When you'd reach for it

A few situations it was built for:

• You're reaching for Clean Architecture on reflex. Onion, Hexagonal, Ports-and-Adapters are real tools — and a three-endpoint CRUD service pays their abstraction tax for nothing. The architecture wizard asks what actually drives change in your code before it names a topology, and it's just as happy to land you on a modular monolith with vertical slices as on anything fancier. The default isn't "the layered diagram everyone draws"; it's the least structure your change rate justifies.
• You've got spaghetti and have to fix it. Refactoring is where the pain is — and where the wrong move costs weeks. Point the refactoring mode at the mess: it reads the code, finds the seams, and hands you targeted moves — not a rewrite, not a lecture — telling you which boundary is worth the pain and which is just cargo-culting someone else's diagram.
• You're writing Python and not sure which pattern applies. Half the GoF catalog dissolves in a language with first-class functions, closures, and dataclasses. The design-patterns wizard walks you to the pattern that fits and its Pythonic form — including when the honest answer is "you don't need a pattern here."
• Not every agent needs to be ReAct. A single well-prompted call beats a workflow; a fixed pipeline beats a loop; a loop beats a swarm — right up until the task genuinely needs the rung above. The agentic wizard starts at the bottom of that ladder and only climbs when you make the case.

Where it came from

Before any of this was a plugin, it was three long HTML pages I'd built to think through these decisions for myself — clickable decision trees I kept open in a tab. The skills are those references distilled into a workflow. The wizards below are those pages, re-skinned to live here.

Two ways to use it

1. Click through a tree yourself. Open a wizard, answer the questions, and walk out the other side with a recommendation you can argue with. No install, nothing to set up.
2. Less sure? Let the skill interview you. Install the plugin in Claude Code and just describe your decision — the right skill triggers, asks what it needs, and composes an answer against your actual code.

/plugin marketplace add AdamKrysztopa/architectural-decisions
/plugin install arch-crew

Repo: github.com/AdamKrysztopa/architectural-decisions

The three wizards

• Software Architecture Patterns
• Agentic System Patterns
• Design Patterns (GoF / Pythonic)