codebase-design

Design deep modular software components with minimal interfaces and ports.

9|Updated Dec 1, 2025
One-click install
npx skills add https://github.com/JohannesKonings/tanstack-aws --skill codebase-design-johanneskonings
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: codebase-design
Source: https://github.com/JohannesKonings/tanstack-aws/tree/main/.agents/skills/codebase-design
Command: npx skills add https://github.com/JohannesKonings/tanstack-aws --skill codebase-design-johanneskonings

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill addresses the common issue of shallow, tightly coupled codebases that are difficult to test, maintain, and navigate. It provides a shared architectural vocabulary to help you build deep modules that offer high leverage for callers and clear locality for maintainers.

Core Features & Use Cases

  • Deepening Modules: Provides a structured approach to identifying and deepening shallow modules by defining clear interfaces and seams.
  • Design It Twice: A parallel sub-agent pattern to explore multiple, radically different interface designs before committing to one.
  • Testability Guidance: Offers principles for designing interfaces that make testing natural, such as dependency injection and avoiding side effects.

Quick Start

Use the codebase-design skill to analyze my current module structure and suggest how to deepen it by identifying potential seams and interface improvements.

Frequently Asked Questions about codebase-design

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

FAQPage Schema
How do I design deep, testable, and maintainable modules?

You design deep modules by establishing minimal interfaces that encapsulate high internal complexity, applying ports and adapters to identify seams, and ensuring testability through dependency injection and side-effect avoidance.

What is the best way to evaluate alternative interface designs before committing?

Evaluating alternative interface designs involves exploring multiple radically different architectural approaches in parallel. This design exploration ensures you select the most robust interface before committing to a final codebase structure.

How do I refactor a tightly coupled codebase to improve modularity?

Refactoring tightly coupled codebases requires identifying structural seams and applying a standardized architectural framework. This process deepens shallow modules by defining clear interfaces and establishing strict design discipline across the codebase.

When do I need to apply architectural seams and ports and adapters?

You apply architectural seams and ports and adapters when your codebase becomes tightly coupled and difficult to test. This approach isolates dependencies, establishes clear locality for maintainers, and provides high leverage for callers.

How does this approach handle testability guidance for new features?

Testability guidance for new features is handled by offering principles that make testing natural, such as implementing dependency injection and avoiding side effects. This ensures consistent design discipline during development.