The Real Problem With AI Coding Isn't Capability. It's Alignment.
An honest assessment of how AI feels at this moment.
Everyone is pushing toward autonomy.
Longer context windows. More agents. Better harnesses. More tools. Less human in the loop.
For a lot of work, that makes sense.
For deep work, I think it’s the wrong frontier.
When you’re building a real system, the problem usually isn’t that the model can’t do enough. The problem is that every session starts half-amnesiac. You re-explain the same conventions. Re-litigate the same architectural choices. Reassert the same taste. Re-teach the same intent.
Then the session ends, and you do it again tomorrow.
That’s the tax. Not token cost. Not latency. The re-alignment tax.
And it’s more expensive than most people realize, because it compounds over the life of a project. Especially on serious codebases, the work is not just “solve this task.” The work is “solve this task in a way that fits everything we already decided.”
That is where current AI systems still break.
The only lever people have is corpus
There are three layers to AI-assisted work.
The model — the weights, the capability, the raw intelligence. Outside your control.
The harness — Claude Code, Cursor, Windsurf, the tooling that wields the model. Partly configurable, but largely outside your control.
The corpus — your system prompts, your docs, your skills, your conventions, your linter rules, your CI checks, your CLAUDE.md. This is the only layer you actually have leverage over. It spans from advisory (here’s how we do things) to mechanically enforced (CI will reject it if you don’t). So naturally, that’s where people focus.
Docs and skills aren’t wrong — they’re the right instinct. The problem is that corpus, without infrastructure, makes things worse. Stale rules don’t fail loudly. They quietly degrade everything around them. Add an overly broad instruction and the agent integrates it in ways you didn’t anticipate, silently breaking behavior in areas it never touched.
Without measurement, you can’t tell if your corpus is helping or hurting. Most people can’t. And most people’s isn’t.
The answer isn’t just “write better docs.” The answer is infrastructure for treating corpus the way you’d treat any system you care about: with capture, classification, versioning, testing, and measurement.
Agents optimize for what they can see
One way to say this is: agents optimize for completion.
Not correctness in the long run. Not maintainability. Not taste. Not coherence with the spirit of the codebase six weeks from now.
Completion.
That’s not because the models are stupid. It’s because they operate inside a bounded perceptual field. They optimize for the signals available in their light cone. Completion is visible. A green checkmark is visible. A diff is visible. “Task done” is visible.
But the things we actually care about in deep work are often weak, delayed, or implicit signals:
- Was this the right abstraction?
- Will this still make sense after three more features land?
- Does this match how we want the system to feel?
- Did it preserve intent, or just satisfy the letter of the request?
Those are long-horizon signals. They arrive later, weaker, and with more ambiguity.
If you want the deeper systems frame, I wrote more about it in section 3.1 of the whitepaper. The short version: systems optimize inside the field of signals they can perceive. If the signal architecture is bad, local optimization becomes rational and globally destructive.
That is exactly what happens with coding agents.
More autonomy can make this worse
This is why I’m skeptical of autonomy as the main story.
A highly capable but misaligned agent is not a better collaborator. It is a faster divergence engine.
If the agent is optimizing the wrong proxy, giving it more time, more tools, and more independence doesn’t solve the problem. It just lets it get further from your intent before you notice.
This is also why so many autonomous AI systems feel mediocre — even with skills, coordinators, and memory. If the model thinks it can solve the task without reading the docs, absorbing the guidelines, or reconstructing your intent, it usually will. From the model’s perspective, that’s efficient. From the project’s perspective, that’s where drift begins.
What we need first is faster and deeper alignment. Not “how do we let the agent run longer?” — but “how do we make the next session start closer to what I actually mean?”
The real missing infrastructure is signal infrastructure
That is the core idea behind Foundry.
Foundry is not fundamentally a prompt optimizer. It’s not mainly a fixture runner. It’s not just a better CLAUDE.md.
It is infrastructure for capturing the signals that arise when a human works with AI and turning those signals into durable alignment.
Because the raw material is already there.
Every correction is a signal.
Every “not like that” is a signal.
Every repeated explanation is a signal.
Every reversion, refinement, review comment, abandoned diff, and architectural argument is a signal.
Right now, most of that gets thrown away. Maybe a little of it gets manually promoted into docs. Maybe a rule gets added. Mostly it disappears.
So the system never actually learns the thing that mattered.
That’s where the leverage comes from. A correction made once can improve every future session, every agent touching the codebase, and eventually every similar task across the team. But that only matters if you can verify that the corpus change actually improved behavior rather than silently breaking something else.
The core primitive: low-friction ingest and classification
The heart of the system is not generation. It’s ingestion.
You need a low-friction way to ingest user interactions and classify them. Not just “save chat history.” Not just “embed everything.”
Classify it.
- What kind of signal is this?
- Is it a local preference or a team convention?
- Is it a one-off correction or a recurring failure mode?
- Is it a taste signal, a correctness signal, a security signal, a maintainability signal?
- Does it belong in memory, documentation, fixtures, evaluation, guardrails, or something else entirely?
That classification layer is the real primitive. I’ve been calling it the Librarian.
The Librarian doesn’t do the task. It figures out what kind of knowledge was produced by the interaction, where it should live, and what it should become.
Because the same correction can surface into different forms:
- memory, when it’s still local and provisional
- docs, when it becomes a pattern
- fixtures, when it becomes something you want to regression-test
- guardian checks, when it becomes a recurring failure mode worth watching for
- ADRs, when it reflects an actual decision
- trust gradients, when it tells you where the agent is reliable and where it isn’t
- linter or CI rules, when the correction is about structure and should be enforced mechanically, not just remembered
One interaction, many possible downstream artifacts.
Corpus is not “more context”
This changes what a corpus is.
A corpus is not “everything we’ve ever written shoved into the prompt.” That just creates context bloat and makes the agent worse.
A useful corpus is not preloaded for every agent. It is structured, categorized, and classified so the right bundle can be compiled and routed to the right task at hand.
The point is not to make every agent read all 18,000 lines of docs. The point is to let the right agent receive the minimum viable context for the task at hand — and to know whether that context is actually working.
The experience we’re building
Foundry is not a new agent you talk to. It’s not a workflow you adopt. It’s not a platform you migrate to.
It bolts onto what you already have.
Your agents — Claude Code, Cursor, whatever you use — keep working the way they work. Your codebase stays your codebase. Your infrastructure stays your infrastructure. Foundry adds a layer that watches what happens during real work and makes sure the signals don’t disappear.
The experience is closer to auditing than to tooling. You work. When something matters — a correction, a redirect, a decision, a “not like this” — Foundry classifies it and asks: where should this live?
You approve or you don’t. That’s the whole interaction.
Foundry is about both capture and verification. It captures the signal, routes it into the right durable form, and then tests whether that change reduced re-alignment cost without introducing regressions elsewhere. Otherwise you’re just accumulating rules and hoping.
Over time, your agents start each session closer to aligned. Not because the model changed. Because the signals stopped evaporating.
On setup: low-friction from day one, bring-your-own-infrastructure throughout. Foundry defines the interfaces — how signals get captured, classified, and routed. What sits underneath is yours: your memory store, your docs, your eval layer, your git history. The recursion pattern works regardless of which models you use or where your work lives.
The long-run vision extends beyond code. The same primitive — ingest, classify, route into durable forms, measure — applies anywhere a human is working alongside AI and generating signal: research, support, content. The substrate changes. The pattern doesn’t.
But we’re starting with software, because that’s where the signal is richest, the failure modes are clearest, and the re-alignment tax is most measurable.
This is not about making the model smarter
Everyone is trying to make the model smarter, or the harness better, or the agents more autonomous.
Those things matter. But they are not the deepest bottleneck for serious human-AI collaboration.
The deeper bottleneck is that the system keeps forgetting what matters to you. Your taste. Your intent. Your standards. Your decisions. Your reasons. Your “we already learned this” moments.
Foundry is an attempt to make those signals durable. Not so the AI can fully replace the human. So the human stops paying the same re-alignment tax every session.
Alignment work looks optional to the agent. Foundry makes it load-bearing, compounding, and verifiable.
Not autonomy. Horizon alignment.
Not “how do we remove the human?” — but “how do we make the system see far enough to work with the human well?”
If we get that right, a lot of the autonomy story becomes downstream of it.
If you’re building on this problem — or just tired of paying the re-alignment tax — I’d like to hear from you.