Architecture and codebase health
Shared language, deep modules, focused refactoring, and architecture improvements tied to real change costs.
Why this collection exists
Make fast-moving code cheaper to understand and change without launching a rewrite.
Prompts
Use these directly when the moment calls for a focused process.
Map an unfamiliar codebase
Build a useful model of modules, data flow, boundaries, and domain language before changing code.
Define the project’s domain vocabulary
Create a shared language that improves naming, documentation, and agent comprehension.
Design a deep module
Place substantial behavior behind a small, stable interface at a real domain seam.
Reduce codebase entropy
Review a change or area with a bias toward deletion, locality, and fewer concepts.
Plan a behavior-preserving refactor
Create a sequence of small structural changes with explicit regression protection.
Skills
Install these when the discipline should remain available across sessions.
Improve Codebase Architecture
Finds high-leverage opportunities to create deeper modules and reduce future change cost.
Domain Modeling
Builds shared vocabulary, challenges ambiguous concepts, and maintains domain context.
Codebase Design
Applies deep-module principles to place behavior behind small, truthful interfaces.
Reducing Entropy
Reviews designs and refactors with a bias toward deletion, locality, and fewer total concepts.
Workflows
Follow these when the work spans several distinct stages.
Understand an unfamiliar codebase
Move from repository noise to a working model of the domain, execution path, and modules relevant to your change.
Rescue a codebase becoming a ball of mud
Find the repeated change pain, create a deeper seam, and refactor without turning the effort into a rewrite.
Research and record an architecture choice
Move from an unfamiliar option space to a cited decision record grounded in the current repository.