codebase-design

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

1|Updated Oct 29, 2025
One-click install
npx skills add https://github.com/jwh3times/holland-vip --skill codebase-design-jwh3times
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: codebase-design
Source: https://github.com/jwh3times/holland-vip/tree/main/.agents/skills/codebase-design
Command: npx skills add https://github.com/jwh3times/holland-vip --skill codebase-design-jwh3times

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: Defines module, interface, seam, adapter, depth, leverage, and locality so teams and AI agents name design concepts consistently. - Dependency-aware deepening: Classifies dependencies as in-process, local-substitutable, remote-but-owned, or true external, and prescribes ports-and-adapters or mock strategies for each. - Design It Twice workflow: Spawns parallel sub-agents to produce radically different interface proposals, 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 belongs, define a port with production and in-memory test adapters, and rewrite tests against the new interface. ## Quick Start Ask the AI to review a module in your codebase and propose a deeper interface using the codebase-design vocabulary.

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 hides a large amount of behaviour behind a small interface. Reduce the number of methods, simplify parameters, and hide complexity inside the implementation so callers get more leverage 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 and where behaviour can be altered without editing in place. 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. A single-adapter seam is just indirection and should be avoided.

How do I test a deepened module?▼

Write tests at the deepened module's interface, treating the interface as the test surface. Delete old unit tests on the shallow modules, and assert on observable outcomes so tests survive internal refactors.

How do I handle third-party dependencies when deepening modules?▼

True external dependencies like Stripe or Twilio should be injected as ports, with tests providing mock adapters. Dependencies with local stand-ins, such as PGLite for Postgres, can be tested with the stand-in running in the suite.

What is the Design It Twice process?▼

Design It Twice spawns three or more parallel sub-agents, each producing a radically different interface under distinct constraints such as minimal surface or maximum flexibility. The designs are then compared on depth, locality, and seam placement before recommending one.