Design or improve module interfaces using deep-module heuristics.
SkillScore100Maintained
Automatic
◆Coding pack
Last verified 9/24/2026
What it changes
Passed 23 of 23 test cases with the skill, and 20 of 23 without it.
Without skill87%
With skill100%
Checks it passed that the model alone missed
Evaluates the proposed interface using module depth.
Compares at least two distinct candidate interface designs before selecting a target.
Recommends mapping representative callers and contracts as the initial workflow step.
and 2 more in the full report
3 fixed20 passed either way0 still failing0 broke
Pass-rate lift
+13 pp
Tokens
+10%
Agent turns
0%
Response time
-7%
Model gemini-3.6-flashMeasured 9/24/2026v123 of 23 cases passed with skill
Tokens, turns and time describe resource use, not a dollar price.
See it in action
One of 3 test cases the skill fixed. Same model, same prompt, with and without the skill.
1 of 3
Prompt
We are tasked with refactoring a legacy 2,000-line `UserAccount` module in C++. What should be the very first step in our design workflow before writing any new code?
What was checked, without and with the skill
Checked
Without skill
With skill
Recommends mapping representative callers and contracts as the initial workflow step.
Missed
Passed
case-17 · gemini-3.6-flash · 9/24/2026 · answers are capped and redacted
What's inside
The instructions your model reads when the skill loads.
SKILL.md49 linessingle file
Codebase Design
Seek deep modules: substantial useful behavior behind a small, stable
interface. Use the concepts below as design lenses, while matching the
repository's established domain language.
Working vocabulary
Module: a coherent unit with an interface and implementation, at any scale.
Interface: everything callers must know, including invariants and failure
modes—not just a type signature.
Seam: a location where behavior can vary without editing its callers.
Adapter: an implementation that connects at a seam.
Depth: useful capability relative to interface complexity.
Leverage: capability gained by callers; locality: change and knowledge
concentrated for maintainers.
Translate these terms to the project's vocabulary when that makes the design
clearer. Consistency with the codebase is more valuable than enforcing a private
lexicon.
Design workflow
Map representative callers, responsibilities, dependencies, and existing
contracts.
Look for coordination or policy that can move behind a smaller interface.
Place seams where variation, ownership, or test isolation justifies them.
Compare alternatives when the choice is consequential.
Validate the candidate with representative caller code and tests.
Heuristics, not laws
Reduce methods, parameters, ordering constraints, and configuration callers
must understand.
Use the deletion test: if removing a module merely spreads its complexity
across callers, it was likely earning its keep.
Treat pass-through layers skeptically, but keep them when they provide a real
compatibility, ownership, policy, or navigation boundary.
Introduce dependency seams when actual variation or test isolation repays the
indirection; avoid interfaces justified only by hypothetical futures.