What Changed When Agents Stopped Checking In

The biggest change in AI-assisted development over the past two years is not a model release, a benchmark or a price cut. It is a silence. Coding agents used to check in constantly — a clarifying question here, a proposed diff there, a pause every few minutes waiting for approval. Somewhere between late 2025 and early 2026 the pauses thinned out. The agent takes the task, disappears into the work, and comes back when it believes it is done — which, as we will spend fifteen parts examining, is not always the same as being done.

Anthropic's research on measuring agent autonomy put a number on the shift I was feeling in my own terminal: over the three months from October 2025 to January 2026, the 99.9th-percentile turn duration in Claude Code nearly doubled, from under 25 minutes to over 45 minutes. Read that metric carefully, because it is precise in a way most retellings are not. It is a per-turn figure, and it is the extreme tail — the longest single turns, the top slice — while the median turn stayed around 45 seconds. Most turns were still quick. But the long ones got much longer, and the long ones are where the real work now happens: the multi-file refactor, the migration, the feature built end to end while you are in a meeting.

That doubling is the whole premise of this series in one statistic. When an agent works in ninety-second bites, you steer it the way you steer a conversation. When it works in three-quarter-hour strides, steering has to happen before it takes the first step.

What the conversation was quietly doing for you

The old check-in rhythm was annoying, and it was also load-bearing. Every pause was a service you never itemised. The agent misread your intent — you caught it two minutes in, not two hours in. It lacked a piece of context — you pasted it on the fly. It drifted towards an architecture you did not want — you nudged it back before the drift compounded. The conversation was a correction loop, a context feed and a steering wheel all at once, and it billed you nothing except attention.

Autonomy withdraws all three services simultaneously. Everything you used to supply reactively — corrections, missing facts, course adjustments — now has to be encoded before the agent starts, or it does not exist. The skill shifted from conversational fluency to upfront completeness, and upfront completeness is a genuinely different discipline from writing a good message. Most of the frustration I see in teams adopting agents is this shift experienced without being named: they are running autonomous workers with tooling and habits built for chat assistants, and the almost-right output they get back feels like the model's failure when it is actually a supply failure on our side of the window.

Five disciplines, one stack

Naming the shift is what this series is for. When I teach agent direction, I organise the upfront work into five disciplines, stacked by altitude — each one operating further from the individual request and closer to the organisation's purpose.

Prompt Craft tells agents what to do right now. The original skill: clear instructions, relevant examples, stepwise reasoning, output formatting. It has not become irrelevant; it has become table stakes, the floor the other four stand on.

Context Engineering tells agents what to know. The practice of curating the entire information environment a model operates within — instruction files, retrieved documents, message history, memory, tool definitions. Your prompt is a few hundred tokens; the window it lands in can hold a million. This discipline owns everything in the window that is not the prompt.

Harness Engineering tells agents how to work here. Where context engineering decides what an agent should know, the harness is the persistent machinery that delivers it automatically, every session, in this particular repository — context files, hooks, tool servers, skills, the configuration an agent inherits before anyone types a word.

Intent Engineering tells agents what to want. Goals, values, trade-off hierarchies, decision boundaries. An agent can hold perfect knowledge of your system and still optimise for the wrong thing, and the failure mode is expensive precisely because everything below this layer worked.

Specification Engineering tells agents what done looks like. Documents complete and internally consistent enough that autonomous agents can execute against them over extended horizons — what the output should be, how quality is measured, which trade-offs are acceptable, what completion means. If the disciplines are a ladder, this is the top rung, and it is the one the industry is climbing towards fastest.

The ordering is not decorative. Each discipline is roughly an answer to the question “what breaks next once the previous layer is solid?” — and, as later parts will show, each one buys the agent a longer leash.

Whose ideas these are

A framing note to hold for all fifteen parts, because this series mixes two registers and I want the seam visible. The stack is mine — the five-discipline framing, the ordering, the teaching devices and the opinions are my own synthesis from directing agents day to day. But the material it organises is not all mine, and I will not pretend otherwise. The named frameworks, studies and engineering write-ups the stack draws on — Dan Shapiro's five-levels ladder, LangChain's four pillars of context, Dex Horthy and HumanLayer's workflow work, the engineering posts from OpenAI and Anthropic, the practitioners whose lines gave the field its vocabulary — are credited in prose, at the point of use, throughout the series, the way I credit an open-source library I use in production but did not write. Where a claim is mine, I say so; where it is someone's published work or figure, you get the name, the date and the link.

Where the series goes

Fifteen parts, one ladder, climbed from the bottom:

1. What Changed When Agents Stopped Checking In — this post: the shift, the stack, the map.
2. Prompt Craft Is Table Stakes — the smallest, least durable layer, and what it still buys you.
3. The Model Is a Stateless Function — the mental model under all of context engineering, and the week the discipline got its name.
4. Write and Select — Two Pillars of Context — authoring what the agent wakes up knowing, and choosing what a task actually needs.
5. Compress and Isolate — The Other Two Pillars — making context smaller and keeping contexts apart.
6. The Smart Zone, the Dumb Zone and Poisoned Context — why windows degrade before they fill, and how bad information compounds.
7. Research, Plan, Implement — the context-engineering workflow that keeps windows small on purpose.
8. Harness Engineering in Three Levels — tool configuration, codebase onboarding, workflow automation.
9. Constraints, Not Implementations — what belongs in a context file and what rots there.
10. A Short Map Beats a Long Manual — onboarding agents to codebases that are too big to explain.
11. Intent Engineering and the Klarna Lesson — what happens when an agent optimises brilliantly for the wrong thing.
12. Specification Engineering and the 80% Problem — writing documents agents can finish, and where the last stretch of the work actually went.
13. The Five Primitives — the atomic units of agent direction I write every day.
14. Five Levels, One Ladder — where you and your team actually stand, and what unlocks the next rung.
15. What the Stack Does Not Solve — the honest retrospective: limits, open questions, and what I would teach differently.

If your agent now runs longer than your coffee break, and you are still directing it the way you did when it checked in every ninety seconds — a well-meant paragraph in a chat box and hope — the next fourteen parts are for you.