The Codebase Is the Biggest Prompt: Deep Modules for the AI Era — Interfaces Belong to Humans, Implementations to AI
*Editor's note: This is a structured English rendering of a Chinese-language forum essay that fact-checks and analyzes Matt Pocock's article 'How To Make Codebases AI Agents Love' (aihero.dev).*
Key points
- The essay traces a viral Chinese video claiming that "what influences AI output most is not your prompt, but your codebase," back to its source: Matt Pocock (Total TypeScript / AI Hero) and his article on aihero.dev.
- A line-by-line verification of the video summary against the original finds unusually high fidelity: the quote "Your codebase, way more than your prompt or your AGENTS.md file, is the biggest influence on AI's output" is accurate, as are the three costs (poor feedback loops, hard to navigate, cognitive burnout), the *Memento* metaphor, and the attribution of deep modules to Ousterhout's *A Philosophy of Software Design* (2018).
- Pocock's prescription — "You own the interface. AI owns the implementation. Tests keep it honest." — is confirmed verbatim; the video omitted the third clause about tests acting as a notary.
- One disclosure: Pocock is a heavy promoter of Effect, so that section of his article is flagged as self-interested advocacy, not a unique solution.
- Slow feedback = a latency tax on verification bandwidth (AI keeps stacking changes on unverified code).
- Hard navigation = an interface tax on the context window (how many tokens describe structure vs. noise).
- Cognitive burnout = human verification bandwidth consumed by filling in the AI's missing context.
- 20 years ago: complex implementation was *hidden* behind the interface so users didn't care.
- Now: complex implementation is *fenced off* by the interface — AI writes it, you don't care.
- For humans, deep modules work because of cognitive bottlenecks (working memory fits only seven or eight chunks).
- For AI, they work because of context economics: a typed function signature packs a module's full callable semantics into a few tokens, with implementation retrieved on demand.
- Original article: aihero.dev/how-to-make-codebases-ai-agents-love
- Ousterhout's deep-module definition cross-checked across softengbook, dev.to, sandordargo
- Parallel commentary: jamescroft.co.uk (2026-04), moderndescartes.com (2025-10)
- Reddit r/vibecoding discussion of Pocock's workflow (GitHub Issues as kanban, narrow vertical slices)
Why the codebase beats the prompt
The essay's framing: a prompt is a one-off parameter; a codebase is a persistent interface. Each spawned agent gets its task from the prompt, but the codebase determines what it can see, how fast it can move, and how long until errors surface. The three costs translate into taxes:
Deep modules, second spring: from 'hiding' to 'delegation'
Ousterhout's deep module (2018) means lots of implementation hidden behind a simple interface. Pocock performs a semantic reversal in the agent era:
The reversal depends on tests: interfaces lock behavior, tests lock interfaces. The result is a three-way property split — interface as human property (boundary design is where taste lives), implementation as AI property (tokens are commodities), tests as notary. Taste is not outsourced; it moves to the boundary. The codebase becomes curated external shared memory for session-amnesiac LLMs.
Where the analogy breaks: same conclusion, different mechanism
The essay pushes back on Pocock's line "What works for humans is also great for AI":
The migration condition is that interfaces must carry structure (types, signatures, module boundaries). In untyped languages the dividend vanishes — agents must read implementations to guess semantics, spiking the interface tax. This also explains why static files like AGENTS.md lose to the codebase: they are natural-language paraphrases of structure, while module boundaries are structure itself.
Editor's observations and a testable prediction
The essay's real contribution is framing the human/AI division of labor as a property question, making it a clean engineering sample of verification-bandwidth economics. It also notes a counter-trend: if models keep improving, long contexts might flatten the need for deep interfaces entirely. Testable prediction: within 12 months, mainstream agent tools will ship first-class 'module maps' — agents auto-maintaining structured codebase maps (Pocock's /improve-codebase-architecture skill is the prototype) — automating half of the manual discipline described in the article.