DEV Community: Mike Czerwinski

Anthropic measured the human side. Five operators are building the agent side.

Mike Czerwinski — Sun, 21 Jun 2026 20:45:56 +0000

I joined dev.to a few days ago because I'd run out of paths to argue this stuff against. Months of building a framework — operator discipline as an orthogonal axis to autonomy, locked decisions with status fields, drift detection, supersession trails — and the only thing I was sure of was that internal coherence isn't proof of anything. Frameworks survive by surviving other people, not by surviving the author.

So I started publishing. Today the framework finally hit something outside my own head.

What Anthropic measured

On June 16, Anthropic Economic Research published "Agentic coding and persistent returns to expertise." About 400,000 interactive Claude Code sessions. About 235,000 people. October 2025 to April 2026. Expertise patterns, delegation patterns, success patterns.

The central finding, in their own words:

"The greater domain expertise a person brings to a session, the more work Claude does per instruction."

"Success is determined by how well a person understands the problem they are trying to solve, not whether they're trained in coding."

Anthropic did not measure operator discipline directly. It measured the closest empirical neighbor: expertise as a multiplier on agentic work.

Expert-rated sessions show about 2.4× as many Claude actions per prompt as novice-rated sessions, and roughly 5× the text output. The signal is not simply "knows how to code." The signal is "understands the problem well enough to steer the agent." That overlaps with the same axis I'd been arguing as a frame in my first post on dev.to: vibe coding is not a level, it's an orthogonal axis to autonomy. My stronger claim was that L1 + High discipline outperforms L5 + Low discipline over time. Anthropic does not measure that claim directly, but it gives the human side of the axis something measurable.

What the report does not try to answer is the agent-side question: what kind of state, memory, governance, and transition rules have to exist so that the work compounds across sessions instead of being reconstructed every time. Its scope is interactive Claude Code usage — what work is done, who does it, whether the session succeeds — and it explicitly leaves out large parts of non-interactive/headless usage and does not measure downstream real-world outcomes.

That gap is what the practitioner cluster is circling from the other direction.

What the cluster is building

Five other operators on this platform have been pushing on the agent-side question from different starting points this week:

Rapls on status fields and append-only decision logs.
Scarab Systems on governed baselines and deterministic enforcement.
NOVAInetwork (@0xdevc) on quorum as a substitute for operator discipline at scale.
Raffaele Zarrelli (@sarracin0) on structural pressure when the loop is slow.
Brian Hall on the deterministic gate — and now with an open-source reference architecture (faramesh-core, MPL-2.0).

The short version of the cluster: five different starting points, one architectural conclusion — the LLM proposes, deterministic rules enforce, humans authorize transitions, and the rules live outside the agent's reasoning loop.

That's the agent-side scaffolding that sits outside the Anthropic report's scope.

Two halves of the same answer

Anthropic measured what happens when humans bring expertise into the loop. The cluster I spent today reading and writing with is building architecture for what happens when that expertise has to survive across sessions, tools, and agents. Same axis, two directions, a fuller picture.

Official research from Anthropic, independent practitioners on dev.to, both pointing at adjacent parts of the same problem. Not the same claim. Not the same layer. But the same direction.

That's not a viral take. That's an early convergence signal.

I came here to confront the framework against operators who actually ship with it. The framework didn't collapse on contact. It got sharper. The peers who pushed back named gaps I hadn't seen. And one of the biggest labs in the room published the human-side measurement while we were doing it.

Two independent signals converging from different directions, in the same week, on the same problem space. That's not the framework being right. It's the field starting to coalesce.

It's a good Sunday to close the loop.

Operator discipline is no longer just a personal workflow. It is starting to look like an axis, a measurement problem, and an architecture. Whatever comes next has to be built, measured, and governed.

https://www.anthropic.com/research/claude-code-expertise

Vibe coding is not a level. It's an axis.

Mike Czerwinski — Sun, 21 Jun 2026 09:48:45 +0000

Karpathy gave us vibe coding: "see stuff, say stuff, run stuff, copy and paste stuff, and it mostly works." Since then, the industry has kept trying to turn it into a tidy autonomy ladder — Level 0, Level 1, all the way up to fully autonomous development.

That ladder is useful. It is also incomplete.

It measures one thing: how much of the building you delegate to AI.

But two people can delegate the same amount and get radically different outcomes. One compounds. The other accumulates entropy. Same autonomy level. Different operating system.

That's the missing axis: operator discipline.

By operator discipline I mean one thing: how much of your work survives the session boundary as inspectable state.

What the vertical axis measures

The autonomy ladder — inspired by Karpathy, reinforced by recent writing on AI-assisted development, and repeated in a dozen industry variants — measures one vertical: how much of the work you direct the model to own, and how fluent you are at directing that delegation.

L0: no AI
L1: AI as autocomplete
L2: intent-driven (you specify the what, AI fills the how)
L3: collaborative pair-programming
L4: semi-autonomous (AI executes multi-step tasks, you review)
L5: fully autonomous (AI owns the loop)

Each step is a skill ladder inside one domain — building software. You climb by getting better at prompts, decomposition, code review-at-speed, and tolerance for non-determinism.

This is real and worth measuring. It's just not the only axis.

The horizontal axis most maps underweight

Here's the question the vertical can't answer:

Two developers are both at Level 4. One ships features that compound — the codebase gets cleaner, their operating context gets sharper, their next prompt does more with less. The other ships features that decay — the codebase grows entropy, their trust in the model degrades, every new prompt is a fresh negotiation.

Same vibe coding level. Different outcomes. What's the difference?

It's not skill at building. It's how the person relates to the tool over time.

Some maps name fragments of this — trust, verification, code review burden, the "perception–action gap" between knowing AI code can be wrong and being able to actually catch it. Those are real and worth reading. But they tend to live as caveats inside the autonomy story, not as a second axis with its own structure.

So let me try to draw the axis directly.

A small concrete example, since the abstraction needs one. For about three months I kept re-explaining the same architecture decision to the model every few sessions. Each time it would respectfully suggest the alternative I'd already rejected. Each time I'd argue it down again. The work felt fine in any single session. Over a month it was exhausting.

Then I started writing those decisions down in a separate store, with a status field. proposed → accepted → locked. Once a decision is locked, the model is told not to relitigate it without an explicit unlock.

The relitigation stopped. The work got calmer. The codebase started moving in one direction instead of wobbling.

Nothing about my vibe coding level changed. What changed was that a decision became a piece of state instead of a thing I had to defend live.

That's the axis. Not "are you good at prompting" — how much of your context is a state machine, vs. how much is reconstructed from scratch each session.

The 2×6 matrix

If autonomy is L0–L5 and operator discipline is Low/High, you get twelve cells. The diagonal that matters isn't "low everything → high everything." It's the cross-axis claim:

L1 + High operator discipline > L5 + Low operator discipline over any time horizon longer than a sprint.

Three sample cells:

L3 + Low: fast and brittle. Codebase entropy rising. Trust in the model is high in any given session and degrades across sessions because nothing about wrongness ever feeds back.
L3 + High: fast and stable. Trust calibrated by sampling. Wrongness feeds back into the persistent context as a constraint, so the next session is starting from a better prior.
L5 + Low: maximum velocity into maximum mess. This is the failure mode every honest writeup of autonomous agents eventually admits to — locally-sensible decisions that miss global constraints, with no substrate to catch the drift.

The claim is that the second axis dominates the first over time. I think it's right. It's testable. If you've watched two equally fluent AI users diverge over six months, you've already seen the pattern.

What operator discipline actually is

I'll describe what I personally run — not as the right answer, but so you have something concrete to disagree with.

A persona file the model loads each session: identity, communication preferences, hard rules, things that previously caused friction. Updated when a session reveals a new edge case.

Three append-only stores. Decisions have a lifecycle (proposed → accepted → locked). Threads are active workstreams, each with current step, blocker, and next action. Notes are atomic facts with source-anchoring — every fact carries provenance: which email, which call, which file, which line.

A capture habit. Decisions go into the store the same turn they happen, not as a post-session recap. Recaps drift. Live captures don't.

Locked decisions stop the death-by-second-guessing loop. Source-anchoring removes one easy path to hallucination — the model is less likely to confidently restate a "fact" when the workflow forces provenance into view.

None of this is novel architecture. The novelty is that it's written down and enforced, not implied. It's a state machine, not a prompt trick.

Whatever your autonomy level, you can be high or low on this. That's the axis.

What I'm not claiming

Discipline doesn't beat fluency. They multiply. An L1 user with high discipline still moves slower than an L4 user with high discipline.

The autonomy ladder isn't wrong. It's real and worth climbing.

What I am claiming: the map has two axes, and most of the public conversation has been about one of them. If "more AI" hasn't translated into "more leverage" for you, the answer might not be a smarter model. It might be the axis you weren't measuring.

What does your operator discipline look like? What's captured as state, what's reconstructed every session? Curious to hear concrete setups in the comments — especially ones that disagree with mine.

— Mike