Your Language Has Two Users Now
Part 1 of Code in the AI-Primary Era — a series on what agentic coding actually is: how models behave on code, what that does to the people responsible for it, and what it demands from a language platform.
For half a century, every layer of the programming stack has been built on one assumption: a human is at the keyboard. Error messages are prose, because humans read prose. Logs are colored, because human eyes scan color. Language features are rationed by committees asking whether an average engineer will misuse them. “Developer experience” means the experience of a person — their fingers, their working memory, their patience. The assumption was so universal that nobody thought of it as a design decision.
It has quietly stopped being true. Commit volumes are growing in ways that headcount does not explain; a rising share of shipped code was never typed by the person who owns it; whole categories of work — scaffolding, migrations, test suites, first drafts of subsystems — now default to generation. The exact percentage is debatable and changes monthly. The direction does not.
Once the primary author of code is a model, a long list of sensible-sounding defaults become miscalibrated. They optimize the comfort of the agent who is no longer doing most of the typing — while the agent who is gets feedback formatted as prose, features rationed like sharp knives, and a toolchain that reports its state through a terminal scrollback.
Logos is a systems language built from the opposite starting point, and this series is the reasoning behind it. “AI-first” has become a sticker that means anything from “we have a copilot plugin” to nothing at all. The honest version requires answering a prior question: what do models actually need? Not folklore about prompts — the structural facts: what models can and cannot do, which of their failure modes are permanent architecture and which are this year’s weather. That is what this series tries to lay out.
Two users, asymmetric strengths #
The lazy reading of “AI writes the code now” is that the human exits. The accurate reading is that a language now has two primary users, and they are strong in opposite places.
The model is the author. Its strength is generation over everything it has densely seen: idiomatic code, translation between representations, elaboration of patterns, API plumbing, the entire texture of ordinary programming. Its structural weakness — we will spend part 2 on why it is structural — is executing deterministic procedures. A model does not compute; it approximates the output of computation. So the language should hand its model-author two things: maximal expressivity, and rich targets to offload deterministic work onto, so that work moves out of the weights and into a substrate that executes exactly.
This is why Logos is, paradigmatically, a C++-level language: arbitrary structured const-generic values, first-class type packs, type-level computation written as ordinary metafunctions, registry-driven dispatch. The classic argument against such features — junior engineers find them confusing — evaporates when the author is a model. Filing expressive power behind years of committee process to protect a user who is no longer the author has a name in the Logos design notes: premature passivisation. It taxes the model for the benefit of no one.
The human is the owner. What humans supply is the part with no training-data leverage: judgment about which invariants matter, what failure means in the world, whether shipping is right given context the repository does not contain — plus the accountability that makes any of it matter. To exercise that ownership over model-scale output, humans need operational closeness to the code: the ability to read it, review it, intervene anywhere, at a glance.
This is why Logos wears a Rust-like skin: let mut, &mut self, match, traits, ownership, no exceptions. Familiar, low-entropy, modern-systems-flavoured — a surface the supervising human parses at speed, and, not incidentally, the surface today’s models generate more reliably than most alternatives.
Strip either half and the design fails. Remove the C++-level depth and the model hits a metaprogramming ceiling on every database-class problem it is asked to solve. Remove the Rust-class legibility and humans cannot oversee the output volume that models produce. Both layers exist because both users exist. The language composes their asymmetric strengths instead of flattening them onto one notional “developer”.
Owning code you never typed #
“The human is the owner” settles who answers for the result. It does not settle how involved the owner is — that is a dial, and its two ends look nothing alike.
At one end, the model is autonomous from task statement to delivery, and ownership is pure trust: accept what arrives, sign it, move on. At the other, the human re-verifies everything the model produces and stays close enough to the work that if the model vanished mid-project, they could continue — slower, with more defects, but genuinely continue.
Even that strict end is a large speedup over working alone, for a reason crisp enough that complexity theory built a class around it: checking a solution is fundamentally cheaper than finding one. NP is exactly this asymmetry — verification stays polynomial even where search, as far as anyone can prove, costs exponential time — and everyday engineering has the same shape. Confirming that a patch is right costs a fraction of what producing it did. A human who verifies everything still moves far faster than a human who must also invent everything.
In practice, though, the strict end is reserved for mission-critical work — and not only because it is slow. The reviewer has an error rate too, and whether the average human patch beats the average model patch is by now a live empirical question, not a rhetorical one. Full manual verification buys assurance from an inspector who is themselves fallible; for most code, the price stops being worth it.
So most real ownership sits between the ends, and it is mediated: the human owns the code through the model. The mediator exposes handles — explain this module, walk me through this failure, restructure this boundary, justify this dependency — and through them the owner pulls information out of the codebase and pushes quality and structure back into it, at whatever depth the task deserves. Every handle gripped costs speed, on average, because it routes the loop through its slowest component — the human. Where to set the dial is a per-task judgment — one of the judgments that is the human’s contribution — and One System, One Dynamics prices the settings honestly.
One configuration is excluded outright: responsibility that exceeds control. A human held accountable for output they had no practical means to inspect, question, or steer is not an owner — they are a scapegoat. Whatever else “AI-first” turns out to mean, a platform that asks humans to own model-scale output must keep the price of reaching for more control — at any moment, on any line — low.
More capable models mean more classical code #
Here is the claim in this framing that most people get backwards:
As models improve, the volume of conventional, deterministic, type-disciplined code in the world grows — it does not shrink.
Two reasons, developed properly later in the series. First, models cannot reliably execute deterministic procedures at any scale, so every system that must be correct keeps its correctness in symbolic components — type checkers, tests, solvers, schema validators — and the more work models do, the more such components are needed to check it. Second, long agentic trajectories drift, and the practical remedy is a lattice of deterministic checkpoints the trajectory must pass. When orchestration code from frontier labs has leaked, the striking thing was how unexotic it is: predominantly if/then — gates, dispatch, format checks, retries. Scaffolding.
Models are not replacing that scaffolding. Models are generating it — in whatever language makes it cheapest to produce, audit, and compose.
A model that proposes, deterministic machinery that adjudicates, a human who owns the outcome: that triangle, not the model alone, is the thing that produces working software. Its joint behavior — how fast it converges, where it gets stuck, what each corner needs from the other two — is the real subject of “AI-first” design.
What’s ahead #
The series builds the argument in order, each part standing on the previous one:
- A Model Is Not a Calculator — the boundary between what models generalize over and what they merely approximate, and the two offload rules that follow.
- Attraction Basins — agentic loops as fixed-point iteration: why agents cycle, why confidence means so little, and what “steering” actually does.
- The Model Cannot List What It Knows — model memory as a forward-only compressed program, and the enumeration gap that no scale closes.
- The Failure Mode Humans Don’t Have — what those facts do to large AI-built artifacts, and the external-corpus methodology they force.
- One System, One Dynamics — the human’s actual role: responsibility, the ownership spectrum, and the two goals an AI-first platform must serve.
- Attention Is the Budget — a note for engineering leadership on what all this does to team throughput.
Two more parts close the series later: the concrete platform requirements that fall out of the argument, and an audit of how Logos’s architecture measures against them.
Next: A Model Is Not a Calculator — why “just wait for the next release” is the wrong reading of a model failing at arithmetic.