Improve Architecture

Good architecture is mostly one thing repeated: deep modules — a simple interface hiding a substantial implementation, so a caller gets a lot of behaviour for a little knowledge. The opposite, a shallow module whose interface is nearly as complex as what's behind it, earns nothing for the cost of existing; it just moves complexity around and makes you bounce between files to understand one idea. This skill finds the shallow spots and proposes deepening them.

Vocabulary (use it consistently)

• Module — anything with an interface and an implementation: a function, class, file, service.
• Depth — how much behaviour the interface buys you. High = deep (good); low = shallow (a thin wrapper, a pass-through).
• Seam — where an interface lives; a place you can change behaviour without editing in place. Seams are where tests attach and where features extend.
• Locality — how concentrated a change is. Deep modules give locality: a change lands in one place, and the knowledge to make it lives there too.
• Deletion test — the diagnostic. If you deleted this module, would the complexity it holds concentrate somewhere sensible (it was earning its keep — keep it, maybe deepen it) or merely redistribute across its callers (it was shallow — the boundary is in the wrong place)?

Phase 1 — Explore for friction

Walk the code (the project glossary and any ADRs first, so you use the real names and don't re-litigate settled calls). You're not auditing line-by-line — you're feeling for friction: