Improve Codebase Architecture

<!-- source https://www.youtube.com/watch?v=EJyuu6zlQCg -->

Improve Codebase Architecture

Explore a codebase like an AI would, surface architectural friction, discover opportunities for improving testability, and propose module-deepening refactors as GitHub issue RFCs.

A deep module (John Ousterhout, "A Philosophy of Software Design") has a small interface hiding a large implementation. Deep modules are more testable, more AI-navigable, and let you test at the boundary instead of inside.

Process

1. Explore the codebase

Use the Agent tool with subagent_type=Explore to navigate the codebase naturally. Do NOT follow rigid heuristics — explore organically and note where you experience friction:

• Where does understanding one concept require bouncing between many small files?
• Where are modules so shallow that the interface is nearly as complex as the implementation?
• Where have pure functions been extracted just for testability, but the real bugs hide in how they're called?
• Where do tightly-coupled modules create integration risk in the seams between them?
• Which parts of the codebase are untested, or hard to test?

The friction you encounter IS the signal.

2. Present candidates

Present a numbered list of deepening opportunities. For each candidate, show:

• Clusters: Which modules/concepts are involved
• Why they're coupled: Shared types, call patterns, co-ownership of a concept
• Dependency category: See REFERENCE.md for the four categories
• Test impact: What existing tests would be replaced by boundary tests

Do NOT propose interfaces yet. Ask the user: "Which of these would you like to explore?"

3. User picks a candidate

4. Frame the problem space

Before spawning sub-agents, write a user-facing explanation of the problem space for the chosen candidate:

• The constraints any new interface would need to satisfy
• The dependencies it would need to rely on
• A rough illustrative code sketch to make the constraints concrete — this is not a proposal, just a way to ground the constraints

Show this to the user, then immediately proceed to Step 5. The user reads and thinks about the problem while the sub-agents work in parallel.

5. Design multiple interfaces

Spawn 3+ sub-agents in parallel using the Agent tool. Each must produce a radically different interface for the deepened module.

Prompt each sub-agent with a separate technical brief (file paths, coupling details, dependency category, what's being hidden). This brief is independent of the user-facing explanation in Step 4. Give each agent a different design constraint:

• Agent 1: "Minimize the interface — aim for 1-3 entry points max"
• Agent 2: "Maximize flexibility — support many use cases and extension"
• Agent 3: "Optimize for the most common caller — make the default case trivial"
• Agent 4 (if applicable): "Design around the ports & adapters pattern for cross-boundary dependencies"

Each sub-agent outputs:

1. Interface signature (types, methods, params) 2. Usage example showing how callers use it 3. What complexity it hides internally 4. Dependency strategy (how deps are handled — see REFERENCE.md) 5. Trade-offs

Present designs sequentially, then compare them in prose.

After comparing, give your own recommendation: which design you think is strongest and why. If elements from different designs would combine well, propose a hybrid. Be opinionated — the user wants a strong read, not just a menu.

6. User picks an interface (or accepts recommendation)

7. Create GitHub issue

Create a refactor RFC as a GitHub issue using gh issue create. Use the template in REFERENCE.md. Do NOT ask the user to review before creating — just create it and share the URL.

Reference: Deep Module Architecture

Dependency Categories

When analyzing module coupling, classify each dependency into one of four categories:

1. Same-process, same-team

Dependencies between modules owned by the same team, running in the same process. These are the easiest to consolidate — merge freely.

Example: A UserValidator and UserService in the same package.

2. Same-process, different-team

Dependencies crossing team boundaries but still in-process. Consolidation requires coordination but is technically straightforward.

Example: Your service calling a shared auth library maintained by the platform team.

3. Cross-process, same-team

Network boundaries you control. The interface is already forced to be explicit (HTTP/gRPC), but you can reshape both sides.

Example: Your API gateway calling your own microservice.

4. Cross-process, different-team

Network boundaries you don't fully control. You can only design your side of the interface. Use ports & adapters.

Example: Calling a third-party payment API.

How Category Affects Design

GitHub Issue RFC Template

Use this template when creating refactor RFC issues in Step 7:

## Summary

[1-2 sentence description of what's being consolidated and why]

## Current State

### Modules involved
- `path/to/module-a` — [what it does]
- `path/to/module-b` — [what it does]
- ...

### Coupling evidence
- [Shared types, call patterns, co-change frequency]

### Dependency category
[One of the four categories above]

## Proposed Interface

[The chosen interface design from Step 6]

### What it hides
- [Implementation details now behind the interface]

### Dependency strategy
- [How external deps are handled — injected, adapted, etc.]

## Test Impact

### Tests replaced by boundary tests
- [List existing tests that become redundant]

### New boundary tests needed
- [List tests against the new interface]

## Migration Plan

1. [ ] Create new module with chosen interface
2. [ ] Implement behind interface, delegating to existing code
3. [ ] Migrate callers one at a time
4. [ ] Remove old modules once all callers migrated
5. [ ] Replace internal tests with boundary tests

## Trade-offs

- [Pros of chosen design]
- [Cons / what we're giving up]
- [Why this trade-off is acceptable]