Skip to content

Writing

Fan-Out: What the Literature Already Knew About the Third Schedule

Earlier today I published The Third Schedule — an argument, tested against my own commit history, that the quiet assumption under Paul Graham's Maker's Schedule, Manager's Schedule has broken: maker time is no longer singular. Multiple simultaneous threads of real builder-work can now run under one human's direction, and the scarce resource has moved from the maker's unbroken afternoon to the director's judgment bandwidth.

That post was deliberately inward-looking: one claim, one practice, one dataset. This one looks outward, because a claim like that deserves two external checks it hasn't had. First: has someone already written the maker's-schedule update for the agent era? (Spoiler: yes, at least four times — and it's worth reading them honestly rather than pretending the field is empty.) Second, and harder: there is a substantial, well-established research literature saying human multitasking carries real, measured costs. If that literature is right — and it mostly is — how can "builder time parallelizes" be true at all?

The answer to the second question turns out to have been sitting in a different literature for twenty years, complete with a formula. And once you have the formula, the broader 2025–2026 conversation about agent-era productivity — which swings between "AI collapsed time itself" and "AI makes developers 19% slower" — acquires something it badly needs: a limit. That's where the one hard dataset I have earns its place. Not as proof. As a boundary.

The Third Schedule: A Field Survey

Earlier today I published The Third Schedule — a deliberately tight essay arguing that the quiet assumption under Paul Graham's Maker's Schedule, Manager's Schedule has broken: maker time is no longer singular. The evidence was one practitioner's own git history — 9,806 commits across 183 repositories, January through late August 2026 — showing that half of all continuous work sessions (51.6%) put commits into two or more repositories, and one in eight (12.7%) into five or more. Those are the raw figures; a stricter re-scoring of the same dataset that counts only substantive commits — merges, scripted rollouts, doc-and-chore traffic, and sub-ten-line tweaks stripped out — puts them at 42.2% and 5.2%. This survey uses both and says which is which, because they measure different things: repositories touched versus threads genuinely judged.

That essay was built to stand on its own data and claim nothing beyond it. This piece is the companion it deserves: a genuine survey of what everyone else has published on this intersection as of August 2026 — prior reframings of Graham, practitioner accounts of parallel-agent work, the oversight-bandwidth research, the field-scale commit-mining studies, and the skeptics. The rule throughout is the same discipline the tight essay applied to my own informal "20x" gut number, which it declined to treat as data: every external claim gets checked against something actually measured before it's allowed to carry weight. Where the measured thing is my own dataset, I say so, and I say what a sample of one can and cannot calibrate.

The Robots Got There First

Earlier today I published The Third Schedule — an argument that the quiet assumption under Paul Graham's Maker's Schedule, Manager's Schedule has broken: maker time is no longer singular. That post argued from the inside out — one practitioner's commit record, 9,806 commits across 183 repositories, used to show that multiple simultaneous threads of real building under one human director is a thing that measurably exists.

A fair reader should have two objections ready. First: one practitioner's git log is not a literature. Second: hasn't a rather large body of cognitive science spent decades establishing that humans are bad at exactly this — that multitasking is mostly an illusion with a well-documented price tag? If the research says context switching is expensive and attention doesn't split, then "builder time has become parallelizable" needs to explain itself, not just point at a busy July.

This post is the opposite motion: out into the field. I went looking for three things — whether someone has already written the AI-age update to Graham's essay (spoiler: several people have, and they deserve engagement rather than silence); whether the cognitive science actually forbids the working pattern I described (it doesn't, but the reconciliation is narrower and more interesting than I expected); and what the measured 2025–2026 record says about how far any of this scales. The most useful thing I found was in none of the places I expected. It was in robotics — a twenty-year-old research literature on single operators supervising fleets of semi-autonomous vehicles, with a formula, failure modes, and a name for the exact quantity every agent-orchestration blog post is currently rediscovering. The robots got there first.

The Third Schedule

In July 2009, Paul Graham published Maker's Schedule, Manager's Schedule. If you build things for a living you probably didn't need it explained; you needed it named. His argument: there are two incompatible ways of structuring a working day. The manager's schedule is cut into one-hour intervals — meetings slot in cheaply, because changing what you're doing every hour is the default. The maker's schedule runs on units of half a day at least, because meaningful work — programming, writing — doesn't fit in an hour, and a single meeting "can blow a whole afternoon" by breaking it into two pieces too small for anything hard. Graham went further: the damage starts before the meeting does. Merely knowing your afternoon is broken dampens the morning, because ambitious work needs a horizon you no longer have.

Seventeen years later I think the essay is still correct about humans — and no longer a complete map of the organization. Because there is now a third kind of worker in the room, and it doesn't run on either schedule. Its arrival quietly breaks an assumption Graham's essay never had to state.

Who Is This Document For?

There is a mental model of AI-assisted correspondence that I held until quite recently, and I suspect most people still hold it. It goes like this: two humans exchange messages about shared work. Each of them might have an AI helping — polishing prose, summarizing a long thread, drafting a first version. But the correspondence itself is still human-to-human. The AI is a writing aid, the way a spell-checker is a writing aid. The loop is: I think, my assistant helps me say it, you read it, your assistant helps you answer.

That model quietly died on me over the last few weeks, and I want to describe what replaced it, because the replacement is different in kind, not degree.

The Cloud Was Covering for Us

We expected the usual trade when we pointed one of our agents at a local model instead of a cloud API: somewhat worse answers, in exchange for the documents never leaving the machine. What we got instead was a smaller, more literal model walking straight into real bugs in our own verification logic — bugs a large cloud model had been sailing past for months without ever tripping them. The local model didn't get dumber. It got honest, and honesty found the gaps.

The Agent Didn't Guess. It Checked.

Somewhere in the middle of a playbook run last night, on a live production deployment, a step returned this: 41 nodes and 96 edges downstream, including two production-planning flows.

No model wrote that sentence. Nobody had to decide whether to believe it. A deterministic simulator — a separately built model holding the real dependency graph of a real system — computed it, signed it, and handed it to the next step. The AI steps on either side of that moment then had to reason from the number instead of around it. That's the whole mechanic, it ran end to end for the first time last night, and I think it's the most important small thing we've shipped this year.