codebase-design

Designs deep modules with small interfaces, clean seams, and testable adapters.

Updated Jun 26, 2026
One-click install
npx skills add https://github.com/dulltackle/kangkang-skills --skill codebase-design-dulltackle
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: codebase-design
Source: https://github.com/dulltackle/kangkang-skills/tree/main/codebase-design
Command: npx skills add https://github.com/dulltackle/kangkang-skills --skill codebase-design-dulltackle

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Codebases accumulate shallow modules whose interfaces are nearly as complex as their implementations, making code hard to test, navigate, and change. This Skill provides a shared vocabulary and decision framework for designing deep modules so interfaces stay small while behaviour concentrates behind clean seams. ## Core Features & Use Cases - Deep-module vocabulary: Precise definitions of module, interface, implementation, depth, seam, adapter, leverage, and locality, with rejected framings explicitly called out so teams use consistent language. - Dependency-aware deepening: Classifies dependencies as in-process, local-substitutable, remote-but-owned, or true external, and prescribes ports-and-adapters or mocking strategies for each category. - Design It Twice workflow: Spawns parallel sub-agents that each produce a radically different interface for a candidate module, then compares them on depth, locality, and seam placement. - Use Case: When refactoring a cluster of shallow service classes, use this Skill to decide where the seam goes, define a port with production and in-memory test adapters, and rewrite tests against the new deep interface. ## Quick Start Ask the assistant to review a module in your codebase and propose a deeper interface using the deep-module vocabulary and seam discipline.

Frequently Asked Questions about codebase-design

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I design a deep module interface?

A deep module puts a large amount of behaviour behind a small interface. Reduce the number of methods, simplify parameters, and hide complexity inside the implementation. Measure depth as leverage: how much behaviour callers get per unit of interface they must learn.

What is the difference between a seam and an interface?

A seam is the location where a module's interface lives, a place where behaviour can be altered without editing that code. The interface is everything a caller must know to use the module, including invariants, ordering, and error modes.

When should I introduce a port and adapter?

Introduce a port only when at least two adapters are justified, typically a production adapter and an in-memory test adapter. One adapter means a hypothetical seam, which is just indirection without payoff.

How do I test a deepened module with external dependencies?

Classify the dependency first. In-process and local-substitutable dependencies need no port. Remote owned services get a port with an in-memory test adapter, and true third-party services get a mock adapter injected through the interface.

Should I keep old unit tests after deepening modules?

No. Replace, don't layer: delete old unit tests on shallow modules and write new tests at the deepened module's interface. Tests should assert observable outcomes through the interface so they survive internal refactors.