7 posts tagged with "agentic coding"

Previously: How to Trust X07 Code Written by Coding Agents

The previous posts explained why X07 exists and how its trust model works. This one is the walkthrough: scaffold a service, add domain logic, wire up tests and contracts, and produce a certificate bundle that lets a reviewer approve the change without reading the whole source tree.

A coding agent can run every step below in a single session. That is the part that matters.

Series navigation: Previous: How X07 Was Designed for 100% Agentic Coding · Post 3 of 3

Most code written by coding agents should not be trusted on sight.

That is not because agents are useless. It is because normal languages and normal toolchains were built for human review, not for machine-checkable trust. So the default reaction is still, "I need to read the code." X07 changes that by changing what counts as evidence.

Two ideas from other engineering fields make this possible. Formal verification means using mathematical proof to show that code does exactly what its specification says — not "we ran some tests and they passed," but "we can prove this function never returns a negative number under any input." Code certification takes that further: it bundles proofs, test results, architecture checks, and runtime evidence into a structured package — a certificate — that a reviewer can inspect and approve without reading every line of source. Think of a building inspection report: you do not need to watch every nail go in if you trust the inspection process, the inspector's credentials, and the evidence they collected. The principle is not new. Clover showed that verification can act as a strong filter in a closed loop, with up to 87% acceptance on correct CloverBench examples and no false positives on the adversarial incorrect ones in that evaluation. The lesson there is not "trust the model" — it is "make the checker honest, explicit, and useful." (arXiv)

A lot of AI-generated code fails the same way: it looks reasonable, maybe passes a few checks, and then falls apart the moment the real system touches it. The easy explanation is "the models aren't good enough yet." The more useful one is that most languages still assume a human is carrying the missing context in their head.

Hand an agent five equivalent patterns, prose-only errors, implicit side effects, and a flaky test surface, and it has to improvise at exactly the points where you need it to be mechanical.

That is why the recent argument for agent-first languages is worth taking seriously. Armin Ronacher's essay A Language For Agents made the thesis explicit; my own take is a bit more narrow. The reliability gap shows up wherever the language and toolchain leave too much ambiguity at the repair boundary.

I have spent a lot of time watching coding agents fail in quiet ways.

Not the obvious failures. Not the "I cannot do that" failures.

The quiet ones.

The function that looks clean but uses the wrong boundary encoding. The patch that compiles but drifts away from the repo's architecture. The generated test that passes because the fixture is too weak, not because the code is right.

Those failures changed how I think about programming languages.

X07 is a compiled systems language built around a simple constraint:

coding agents are much more reliable when the language and toolchain stop asking them to improvise at critical boundaries.

Most mainstream languages were optimized for humans carrying context in their heads. Agents work differently. They do better when the source form is canonical, the diagnostics are structured, the effect boundaries are explicit, and the repair loop is deterministic.

That is the design space X07 is exploring.

Series navigation: Previous: Programming With Coding Agents Is Not Human Programming With Better Autocomplete · Post 2 of 3 · Next: How to Trust X07 Code Written by Coding Agents

Most languages are trying to make humans flexible.

X07 is trying to make agents reliable.

That sounds like a small wording difference, but it changes almost everything: the source format, the diagnostics, the execution model, the testing story, the architecture tooling, and even the surrounding ecosystem.

The official X07 docs describe an agent-first systems language, and the current toolchain surface is built around deterministic worlds, record and replay, schema derivation, state machines, property-based testing, function contracts with bounded verification, and review or trust artifacts. That is not an AI plugin bolted onto a normal language. It is a language and toolchain shaped around machine-driven repair loops from the start.

Series navigation: Post 1 of 3 · Next: How X07 Was Designed for 100% Agentic Coding

For the last twenty years, most programming languages and most software practices were designed around a simple assumption: a human is the one holding the whole thing together.

A human reads code, remembers conventions, notices weirdness, and makes judgment calls when the codebase offers five equally valid ways to solve the same problem.

A coding agent works differently.

It is very good at wide edits. It is very good at following explicit contracts. It is very good at retry loops. But it is much worse than a strong engineer at carrying a large unstated architecture around in its head.

So working with an agent is not human programming sped up. It is a different optimization problem, and the things you should constrain are different too.