corpocode

CorpoCode

A firm of cheap-model caretakers for your expensive coding agent. The main model inside a coding agent (Claude Code first) is a brilliant, costly developer who should be doing exactly one thing: writing code. Deciding what to write, working out how to approach it, and cleaning up afterward should not burn its time. CorpoCode hires a set of three (extensible) caretakers — teams of small, cheap-model agents — to do all of that surrounding work, so the expensive model stays on the keyboard.

All logic lives in TypeScript behind corpocode hook <name>; installed hooks are thin shims that pipe stdin → corpocode hook → stdout. The main model never calls CorpoCode — it simply finds better context, a cleaner repo, and fewer mistakes already in front of it. Everything CorpoCode produces reaches the model through one channel: a hook's additionalContext.

The governing idea is not a prompt router but a prompt engine. On each hook, a caretaker categorizes the moment it was invoked in, instantiates a team of independent, single-purpose cheap-model agents to address whatever the main model might need, and aggregates their findings into one tight injection before the expensive model ever sees it. Extensive low-scope parallel passes, merged — never one monolithic prompt. CorpoCode is fail-open throughout: any error, hang, or missing dependency degrades to doing nothing — an empty response and a clean exit — never to disrupting the host's turn. And it proposes, the user disposes: durable changes (git promotions, config diffs, skill candidates, telemetry) stay under human control.

The three caretakers

Middle-Management — guides the developer

Opens every turn. It reads the transcript to understand intent, classifies the moment, and dispatches a team of cheap agents to handle everything except the coding:

• Review the current task and decide each branch independently — what relevant skills to load, when to delegate work to a subagent, when a moment is a design breakpoint, exactly what to inject into context, and (designed) when to call an MCP on the side and sideload its output.
• Find the relevant code, files, and docs the prompt never named — scoring the codebase by structure, recalling prior decisions from memory, retrieving precise reference material — and inject them. It intercepts file reads to add focus and surface this file's past mistakes before the model touches it.
• At a design breakpoint, instantiate MOLAR-EDIT (the design philosophy) by spawning one low-cost reviewer per tenet — the set is configurable — and aggregate only the concerns.
• Dynamic model and effort selection — classify the difficulty of the task at hand and switch the model and effort to match, so an easy turn stays cheap and a hard one gets headroom.

The expensive model arrives already oriented.

Housekeeping — cleans up after the developer

Runs during and after the work, in parallel, so cleanup never costs the main model a token:

• Real-time documentation straight from the real call graph — what each unit touches, its impacts, risks, and future considerations, and its input → transformation → output (structure, mutability, purpose). Documentation should be obvious, so Housekeeping makes it so.
• Full git management — atomic per-write commits to a bisectable trace branch, plus a curated, readable clean branch — taking version control off the valuable model's hands entirely.
• Independent verification of functionality — it periodically reviews functions and files against the MOLAR-EDIT tenets (In-flight, Logging, and Observability foremost) and can halt a violating edit.
• Mining problems into memory and skills — the mistakes the model hit become file-anchored warnings for next time, and recurring solutions become reusable skill candidates.

Upper-Management — designs the whole application (designed; no code yet)

The executive tier: expensive models commanding a peon army of cheap ones to design entire applications. It interrogates the user for complete technical, API, and architectural specs — expansion of current capabilities, future features, task parallelization, service compartmentalization, the path to scaling in production, and reusable systems built once — and records major architectural flaws to memory. Fully specified; scheduled after the agent substrate proves out.

The caretaker set is itself extensible — labels over a fan-out engine, not hardwired processes — so a fourth caretaker is an additive seam, not a rewrite.

Install

corpocode is a single npm package that is both a global CLI and a Claude Code plugin. Pick one channel — using both on the same platform fires every hook twice (corpocode doctor warns if it detects both).

Plugin channel (recommended for Claude Code)