Who Owns What
The division of labor: humans set goals and priorities, approve plans, review diffs, and design guardrails. Agents write the code, run and repair tests, and triage incidents. Judgment stays human; throughput goes agentic — and six years of measured evidence says the station goes unstaffed for reasons that never look like a wrong answer.
The question that decides whether an agentic lifecycle is an asset or an incident generator isn't "how good are the agents?" It's "who owns what?" — drawn as a hard line, not a vibe.
The human side: judgment
- Set goals and priorities — what to build, what matters, what to skip. Intent is the input to everything downstream, and it cannot be delegated: an agent optimizing the wrong goal is worse than no agent.
- Approve plans — before agents burn hours of compute executing, a human confirms the plan matches the intent. Cheap to check at plan time, expensive to discover at deploy time.
- Review diffs — the working checkpoint. Not every line, necessarily — but every change passes a human gate before it ships.
- Design guardrails — the security boundaries, permission models, and budgets the agents operate inside. Humans decide what agents may do; agents decide how to do it.
The agent side: throughput
- Write the code — implementation is now the cheap part
- Run and repair tests — not just execute the suite: fix the broken test, rerun, iterate until green
- Triage incidents — classify, correlate, roll back, open the ticket, page only when a human is genuinely needed
- Generate docs inline — the change and its documentation are the same unit of work
The division follows one rule: anything with consequences gets a human owner; anything with volume gets an agent. Judgment is scarce and doesn't scale; throughput is exactly what scales. Aim each at what it's for. The axis hiding inside that rule is not how often a thing is wrong but what a wrong answer costs before anyone notices — drawn out on verification and observability, which is the layer built along it.
You can read this table straight off real tooling. Claude Code's permission prompts and plan mode are "approve plans" in miniature. GitHub's required-review branch protection is "review diffs" enforced structurally. Agent budget caps and allowlisted tools are "design guardrails." None of these are new inventions — they're existing controls, repositioned as the human half of an agentic lifecycle.
The warning, measured
That callout is the least evidenced claim on this sheet. It names a failure mode and asks you to take it on faith. The measurement exists — it just comes from outside software.
Chris Piech teaches Stanford's flagship intro CS class and co-created Code in Place, a free version of it that runs about 17,000 students against more than 1,000 volunteer teachers: one teacher for every ten students, the class in the world with the most teachers. It has run six times over six years, which puts half its history before Cursor and Claude Code and half after. Throughout, it has doubled as an experiment platform — different cohorts get different doses of AI, and completion is measured rather than surveyed.
Four doses of assistance
Same course, same material — only what the learner was handed changed
04Ten minutes of a human⚑ Winner
A pop-up mid-exercise: there is a teacher online, they would like to spend ten minutes with you. The learner accepts or declines.
↑Best measured
Accepting raises the probability of completing the course by ten percentage points. One teacher per ten students makes the offer possible at all.
03A chatbot, handed over⚑ Goes backwards
Here is an assistant, use it to learn. Always available, no occasion attached, nobody expecting anything of the learner.
↓Worse than nothing
Dropout rises. Learners are demotivated — not by wrong answers, but by having the work taken off them at the wrong moment.
02AI placed deliberately
The same assistant, introduced at a chosen moment rather than left running. The source reports that such conditions were found and that they helped.
?Reported, unspecified
Helps people learn. The talk does not say which placements worked, so neither does this sheet — the rung is named because it exists, not because it is specified.
01The course alone
Videos, exercises, and a section leader. The arrangement that ran before Cursor and Claude Code existed.
—Baseline
The baseline every dose above has to clear. Rung 03 does not clear it.
Ruled outThe obvious reading — the humans said the right things and the machine said the wrong ones — was checked and does not hold. The conversations were read: for intro programming the AI was correct and was not hallucinating, and the humans were not always correct. The less accurate party produced the better outcome, so accuracy was never the variable under test.
Hand a learner a chatbot and tell them to learn with it, and they drop out more than if you had handed them nothing. Interrupt that same learner with an offer of ten minutes with a real teacher, and accepting it raises their probability of finishing the course by ten percentage points.
What makes it useful here is the explanation it rules out. Piech's team read both kinds of conversation. For intro programming the AI was correct and was not hallucinating; the human teachers were not always correct. The less accurate party produced the better outcome — so answer quality was never the variable, and no better model would have closed the gap, because the model was already right.
"If we give people AI and just like, here's a chatbot, use it to learn, predictably people will drop out. People get demotivated. It is demotivating to have AI thrown at you at the wrong moment of your learning."
"We've looked at these conversations, the AI was correct. It wasn't hallucinating, not for intro programming, and the humans weren't always correct."
Read as a harness result, that is this site's whole argument in someone else's domain. The layer that ran out of road was not the model — it was the one deciding when a human is in the loop. Delivery, not accuracy, the same distinction context delivery draws about tokens, applied to people.
Why it transfers, and where it stops
A learning experiment is not a code review, and the transfer has to be argued rather than assumed.
What carries is the structure: a competent assistant, continuously available, attached to no particular occasion, with nobody expecting anything of the person — and the person quietly stops doing the work, in a way that never surfaces as a wrong answer. That is the rubber-stamped plan and the skimmed diff, described from the other side.
What does not carry is the remedy, and the size of it. Piech's fix is motivational: a person who visibly cares whether you grow. A staffed review gate is not obviously the same mechanism, and ten percentage points is his number, on his cohort, for his course. Nothing here says it transfers to anything.
The valuable piece, and its five-week lag
Piech also puts the delegation question from inside his own practice, and this version carries a clock:
"I program with AI a lot, but I happen to know a lot about programming and architecture. And if I don't know a lot about programming and architecture, AI will start to make some poor decisions, which I might not experience the first time I make a prototype, but like five weeks down the line when students are actually using my thing, they might start to hit weird bugs. And if I don't understand the architecture, I can't help them."
"If you have AI write too much of your code, at what point can you no longer do that valuable piece of the architecture?"
That is hard on the table above, and worth stating bluntly: review the diff is not sufficient as a human station. Every diff in a series can be correct and the architecture still wrong. The failure does not present at the gate — it presents five weeks later, as bugs whose shape only makes sense to someone holding the whole design. Which, by construction, is the person who has been handing the design over.
So the stations that survive contact with this finding are the early ones. Set goals and approve plans are cheap to staff, and they are where architecture is still legible as a decision rather than distributed across a thousand correct lines. Review diffs is the station most likely to be rubber-stamped, and the least able to catch what rubber-stamping costs.
The rule stands — anything with consequences gets a human owner — with a timing clause attached: the owner has to meet the decision while it is still a decision.
What actually makes someone staff the station
Piech's finding says the station goes unstaffed. It does not say what would make anyone staff it. For that it is worth hearing from people arguing the opposite case — AWS's Anupam Mishra and Raja SP spent a year running lifecycle experiments specifically to get more work handed to agents, and arrived at a hard floor on how much.
Their standard is unfashionable and simple: an engineer working on an application "should start with a goal that I need to understand each and every line of code, I should be able to debug this code." The reason offered is not craftsmanship. It is that the version control system records a person, not a model — "somebody will say, this person did this check-in, you can't say AI did this check-in" — and that the same person is the one paged at 3 a.m. Ownership here is not a value. It is an already-existing fact about who is accountable, and the only question is whether the person holding it understands what they are holding.
Two consequences they draw from it are worth adding to the table above.
The right seniority model is an intern, not a colleague. A model states wrong things with the same confidence as right ones, and folds instantly when challenged — so the working relationship that gets good results is one where the human questions it by default, the way you would guide someone with a lot of ideas and no scars.
Participation is what produces the willingness to sign. Their observation from customer work is that teams who validate at every stage "have a better affinity to the final code that's coming up," and that this affinity — not the test suite — is the thing that lets the change go to production. Which is the same mechanism as Piech's, read from the other end: continuous involvement is not a tax on throughput, it is what makes the last gate more than a formality.
A table isn't a building
This settles responsibility — but responsibility isn't architecture. Where do the agents actually work? How does a plan physically become a diff, a diff become a deploy? And what makes the human gate a wall in the path rather than a suggestion? For that, you need to walk the floor.