Anthropic Engineer: Prompting Is Basically Over. Next Up: Graphs
An Anthropic engineer says 95% of her colleagues are already running self-improving loops, prompting is basically over, and the next step is graphs. She built a complete Claude Code setup from an empty terminal in 10 minutes. Hanako's long post breaks down loops and graphs: a loop makes a single unit correct, while a graph determines which units exist. Stop watching every step; design the graph.
An Anthropic engineer said one sentence in a video:
“Prompting is basically over. 95% of our engineers already run self-improving loops. The next move is graphs.”
She then spent 10 minutes building a complete Claude Code environment starting from an empty terminal. The process was recorded: Empty Terminal → Agents → Loops → Graphs → Self-Improving System.
Claude Code is Anthropic's terminal coding assistant. Agents can call tools, read and write files, and run commands on their own. In the past you directed it by writing prompts; in this workflow, the prompt is just the entry point—structure is the point.
A year ago this sentence would have sounded like an exaggeration. Now it just moves the center of gravity from writing prompts to designing systems. Prompting hasn't disappeared, but it is no longer central.
The video comes from @res1dualedge. The post links to a long article by Hanako. She breaks this down in detail: a Loop makes one unit of work correct without anyone watching; a Graph decides which units exist, along with their order and dependencies. Here are the core parts.
Loop: a check that can fail
Stripped to its skeleton, a Loop is four steps: produce, check, correct, repeat until green.
Check is the key to the whole Loop. Without a check that can fail, a Loop degenerates into a scheduled task.
Most people write the work first and attach review at the end. That review is just another model looking over the output. Two optimists confirming each other.
The check has to be written so a program can evaluate it:
- GREEN: test suite exits 0
- GREEN: every claim carries a source line
- GREEN: diff touches only files listed in the plan
What doesn't count as a check:
- NOT A CHECK: output looks good
- NOT A CHECK: model says it is confident
- NOT A CHECK: no errors were raised
“No errors raised” does not mean correct. Build a Loop on that, and the system will confidently repeat the same mistake until the budget runs out, with clean logs the whole way.
The ceiling of a Loop
A Loop can only make one unit of work better. It can't decide which units should exist, can't decide order, and won't notice that two of five steps don't actually need to wait for each other.
So you get a very good agent running three wrong steps in the wrong order. Every step is correct, and the result is still slow and still wrong. Tuning the Loop won't fix it; the problem isn't inside any unit.
Graph: the shape of the work
A Graph is two things: nodes and edges.
A node is a bounded unit of work, one input, one output. An edge is a dependency: this node's output feeds that node's input.
The most common mistake is treating “then” as an edge. There is no edge between “summarize the file, then check the weather”—the weather doesn't consume the summary. They are two independent nodes that a linear script happened to string together in typing order.
Check every arrow: does the next step actually read the previous step's output? If you can't name the variable that crosses over, there is no edge, and the wait is pure waste. Most chains have two or three arrows like this. Removing them is usually the biggest speedup.
Four kinds of nodes, one of which isn't a model
Splitter, worker, code node, gate—that's about it.
A splitter cuts work into units and sits at the front. Cut it wrong and everything downstream is wasted. Split the repo by folder and four workers audit the same set of files. Split by blast radius and each worker sees things the others don't.
Workers process one unit from a single perspective. Don't give them a shared window. Four auditors sharing a window will converge: the first one writes up a finding, the others all read it, and four reports orbit the same point. You pay four times the price and buy one opinion plus three echoes.
The code node is the one people forget. Merging, ranking, deduplicating, comparing two versions of an export. These aren't reasoning; each has exactly one correct answer and a few lines of code can solve it. Running them through a model only adds cost, latency, and variance. When describing a transformation, if you don't need words like “judge, decide, evaluate, summarize,” it's code.
How Loops and Graphs relate
Loops live inside nodes. Graphs live between nodes.
Inside a unit: produce, check, correct, repeat. Between units: split, fan out, merge, gate, send back.
The two don't conflict. A Graph without internal Loops will produce unverified work in parallel, which is worse than serial because the volume is larger. A Loop without an external Graph is a carefully designed step inserted into a queue nobody designed.
Two return paths
A Graph with no return path is a pipeline. It produces results and then forgets. Next week it starts from the same place with the same blind spots.
A Graph has two return paths, and they do different things.
Correction edge, the short one. A gate sends a unit back to the node that produced it, fixing the current run.
Learning edge, the long one. Accepted results go back to the splitter as constraints, fixing every future run.
Almost everyone builds only the first and skips the second. That's how you get a system that is fast but never gets smarter. The learning edge doesn't pass along the output itself; it passes along constraints derived from the output:
- ACCEPTED: utils slice ported, green on first pass
- DERIVED: adapters preserve keyword args exactly
- LANDS IN: splitter's brief for every later slice
Notice where it lands. It lands in the brief the splitter uses to divide tasks, not in the worker's instructions. A confirmed cause becomes a rule, and the next split starts from where this one ended.
Send back units, not batches
Four slices were ported; one test failed. Send the whole batch back and three correct slices get rewritten. The next version is different but not better, because there was nothing wrong with them.
Now all four have to be re-verified, and any one of them could fail for an unrelated reason. One failure becomes four uncertainties. Let this happen twice in one run and it will never converge. From the outside it looks like the model keeps failing. In reality the return path is destroying correct work.
A single send-back carries five things:
- UNIT: handlers slice
- VERDICT: red
- REASON: test_auth_redirect failed
- EVIDENCE: expected 302, got 200, handlers/auth.py:88
- SCOPE: fix this file only, do not touch other slices
Scope matters more than it looks. Without it, the returned unit puts on weight: the agent opens the file, spots two adjacent issues, and fixes them while it's there. A single-file fix turns into a four-file diff nobody reviewed.
Cap retries at three. Fail three fixes in a row and the problem is in the plan that produced it—the Loop can't see the plan.
Gates look at blast radius, not confidence
Most articles build a confidence score, set a threshold, and let anything above it through. That's the wrong variable.
Confidence is the weakest input because it's the only one the model can influence.
The strong variable is: if this is changed incorrectly, how expensive is it to undo?
- Reversible and isolated: copy changes, tests, isolated functions with coverage. A bad merge is worth one revert, and these can be opened up first.
- Reversible but broad: shared utilities, schema additions that a dozen callers touch. Gate them with deterministic checks plus a clean trace.
- Hard to reverse: migrations, deletions, writing production data, anything that touches money. This lane stays closed, no matter how high the score.
The third line is a closed lane. Unlike raising a threshold, thresholds get adjusted; a closed lane does not.
In open lanes, the gate reads evidence in order: deterministic results, the trace of this run, this node's historical rollback rate, and only last the model's own evaluation.
Where to start
Take something you do repeatedly. Draw the splitter, lanes, merge, gate, and one back-edge.
Build the gate first. Once something can fail loudly, everything gets easier. A Graph without a gate just produces unverified output faster.
Then build the lanes. Build the learning edge last. You need something accepting results before you can derive constraints from them.
Put a human at one step: the one with the highest consequence and the lowest reversibility. Approve merges, decide which fixes ship. Don't review intermediate artifacts, don't confirm every step. The moment a human becomes an intermediate node in the Graph, the Graph moves only as fast as a human reading.
Hanako sums up this discipline in three lines:
Measure the path, not only the answer it landed on.
A verdict that does not change what runs next is a report.
Any failure you do not turn into a permanent constraint, you will meet again.
Most people will keep tuning a Loop and calling it a system. People who draw the Graph will run a fleet—and never quite understand why everyone else has so much trouble catching up.
One commenter says: agent loops are one of the biggest productivity killers. Another says: graphs make agent autonomy more practical. Put the two together and you have roughly the current state of agent engineering.
The full article is in Hanako's X post. The course and templates are at agent-layers.vercel.app. The video is from @res1dualedge.
发布时间: 2026-11-21 15:24