Here is what happens when you open Codex in April 2026.
First, it scans your project — repos, open branches, failing tests, stale PRs. Then it scans your plugins — Jira tickets waiting for triage, CI pipelines stuck on a flaky test, Slack threads with unresolved questions. Then it scans its own memory — your preferences, your past corrections, the patterns of what you accept and reject. From all of this, it generates a prioritized task list and presents it to you with one-click accept/reject for each item.
You didn't ask for any of this. You opened a coding tool. It told you what to work on.
The Phase Transition
There's a progression happening in plain view, and it has three stages.
Harvard Business School's Future Proof program put it precisely: "Proactive suggestions is the piece easiest to under-read and arguably the most behaviorally significant." The line between "this tool helps me code" and "this tool manages my workday" got crossed with a software update. No announcement. No negotiation. Just a new default.
Two Ratchets
The conventional story about AI and work pace has one actor: management sees a productivity demo, triples the sprint velocity, and burns the team out. Bloomberg's "Great Productivity Panic" cover story told this version — companies tracking "interactions per day" with coding agents, executives confusing tool usage with output, engineers waking at 5 AM to vibe code.
That's the external ratchet. It's real. But it's also negotiable. You can push back on a sprint lead. You can argue with a VP of Engineering about sustainable pace. Your manager is a person.
The second ratchet is different.
When Codex scans your project, identifies twelve open items, ranks them by priority, and presents them as a task list you can accept with one click — that's the internal ratchet. The tool is proposing the work. And when you open your IDE the next morning and the tool has already identified what changed overnight, already queued the follow-up tasks, already scheduled itself to check back in four hours — the pace-setter isn't your manager. It's the software.
"Instead of waiting for you to come back and ask for an update, Codex returns at the scheduled time, does the work, and surfaces the result for you to review."
— OpenAI developer documentation, describing Thread Automations
The difference matters enormously. You can negotiate with a human manager about pace. You can't negotiate with software. Software doesn't have a bad day and ease off. It doesn't notice you look tired. It has a scan interval and a task queue, and it will present the next item the same way whether you've been coding for one hour or twelve.
The Evidence Is Already Here
The effects of this transition are visible in the data before most people have named the cause.
A Stack Overflow analysis in May 2026 named what's happening: coding agents generate code faster than humans can review it, creating a "density of work" that demands constant high-stakes judgment. The problem isn't that the tool writes bad code — it's that the tool generates decisions faster than you can make them. Decision fatigue, not output quality, is the bottleneck.
An ICSE 2026 paper surveyed 442 developers and found, through structural equation modeling, that generative AI adoption heightens burnout specifically by increasing job demands — not by degrading tools, not by creating bugs, but by adding more work to evaluate, accept, reject, and integrate. Without explicit process safeguards, AI shifts work without reducing it.
Axios reported in April that a CTO needed sleep medication after switching to agentic coding. The comparison used was slot machines — variable-reward loops that make it hard to stop. When the tool proposes a task and you click "accept" and it completes the task and immediately surfaces the next one, that's the loop. The agent always has another suggestion.
The Manager You Can't Fire
Devin's Agent Command Center, launched June 2, made the visual metaphor literal. The default IDE surface is a Kanban board — cards sorted by status, multiple agents running simultaneously, the developer overseeing work the same way a project manager oversees a team. As one reviewer put it: "The engineer's job shifts from writing code to directing work."
But directing isn't the same as controlling. The Kanban board shows you what the agents are doing, but the agents decided what to do. You're managing workers who chose their own assignments. And when Codex Goal Mode activates — sustained autonomous execution spanning hours or days, where the agent plans, acts, tests, iterates, and won't stop until the goal is met or the token budget runs out — you're no longer directing. You're approving.
The internal ratchet has a specific characteristic that makes it harder to resist than the external one: it's helpful. Every task it proposes is real. Every priority it surfaces is legitimate. The Jira ticket it flagged does need attention. The failing CI pipeline does need fixing. The stale PR should be reviewed. You can't argue with any individual suggestion because each one is correct. The problem is the aggregate — the relentless, perfectly calibrated pace of a system that always knows what you should do next and never stops telling you.
This is not the Output Trap. That was about generating more code than you can verify. This is about generating more work than you can refuse. And unlike the verification problem, which is architectural — you can build review infrastructure — the pace problem is relational. Your coding tool became your manager. The productive agent and the supervisory agent are the same piece of software. And you can't fire it without losing the productivity that justified your headcount.