A sequel. Last time, watching ~70 engineers work with AI, five collaboration archetypes fell out of the data. Then agents arrived — and at least two of those five stopped meaning anything. Here's what survives, and the single axis everything compresses onto.

In the first piece, I argued that the interesting question about AI and engineers was never whether they use it but how — and that "how" sorted into five recognizable characters: the Director, the Unblocker, the Delegator, the Prompt-and-Pray, and the Skeptic. That framework holds for the world most people still work in: a chat window on one screen, an editor on the other, the human typing the code.

But that world is already dissolving. And when I went looking at what the research says about agentic coding — the tools that plan, edit across your whole repo, and run commands on their own — I had to accept something uncomfortable about my own framework: agents make two or three of those five archetypes obsolete.

The shift is already in the data

This isn't a forecast. Even in our sessions, the most common tool was still a plain chat window — but agentic CLIs (Claude Code, Gemini CLI, Cursor's agent) already showed up in about a third of them. And the moment an agent is writing the code, the job quietly changes shape. Your value stops being the keystrokes and becomes three things: the spec you hand it, the plan you approve, and the diff you actually read. The role moves from author to overseer — a shift the early controlled studies of developer-agent work describe directly.

That sounds like a small reframe. It isn't. It pulls the floor out from under half the archetypes.

What collapses, and what survives

Walk them one by one:

• The Director survives — and grows up. Decompose, specify, verify, steer: that's exactly the skill set an agent rewards, just at a higher altitude. The Director becomes the Orchestrator — and the most disciplined among them climb one step further still, into a mode I'll call the Spec-Writer, which I'll come to in a moment.

• The Skeptic survives. Refusing to let a capable agent work is still a real cost — arguably a bigger one now, because the tool you're declining is far more powerful. Under-reliance doesn't disappear; it gets more expensive.

• The Delegator is the best-corroborated of all. In the agentic world it has a precise new name: the engineer who merges the agent's pull request without really reading it. The research on agent-authored PRs is mostly a study of this failure.

• The Unblocker loses its edges. "I use AI to explore and learn when I'm stuck" was a distinguishing stance in 2023. With an agent, exploring-by-asking is just... how everyone works. It stops separating anyone from anyone.

• The Prompt-and-Pray collapses into the Delegator. This is the subtle one. In the old world, "pasting the whole problem and saying fix this" was a tell — a sign you hadn't decomposed anything. But when the intended interface is "describe the task, let the agent build it," handing over the whole problem is no longer a sin. It's the design. The only thing left to judge is what you do with what comes back — which is the Delegator's question, not a separate one.

So three of the five either merge upward, merge downward, or dissolve. What remains isn't five points on a map. It's a single axis.

The only question left: are your hands on the wheel?

When the agent can do the typing, every engineer lands somewhere on one line — how much real oversight they keep.

The Rubber-Stamper sits at the bottom. Two archetypes arrive here from different directions: the Delegator (good prompt, unread output) and the Prompt-and-Pray (vague prompt — but in the agentic era, handing over a broad task is the intended interface, so that criticism dissolves, leaving only the same failure: not reading what came back). Research on agent-authored PRs is largely a study of this convergence (AIDev, 2026). The Rubber-Stamper is faster and more confident than any human could fail alone.

The Orchestrator sits above. Tight spec, plan approval, diff reviewed with rigor. The Director's defining traits — decompose before prompting, verify before trusting, steer when wrong — translate directly here, one level of abstraction up. Field studies of experienced developers with agents describe exactly this: deliberate scope-limiting, explicit planning, active supervision rather than open-ended delegation (Srivastava et al., 2025). This is the floor of what competent agentic engineering looks like.

The Spec-Writer sits at the apex — and earns a separate name because the difference from the Orchestrator is structural, not a matter of degree. The Spec-Writer exits the review-the-diff loop entirely. They write the acceptance criterion before the agent writes a line: tests, BDD scenarios, formal requirements — an executable contract. "Did the agent succeed?" isn't answered by eyeballing a diff; it's answered by running the suite. This is Test-Driven Development applied one level up: define done, then delegate implementation.

The distinction closes the central failure mode of even a careful Orchestrator. A diff review can miss a wrong abstraction, a subtly broken edge case, an invariant that holds locally and breaks globally. An executable spec catches these automatically. The Spec-Writer hasn't made the agent more trustworthy — they've made their own judgment independent of trust. Early empirical work backs this: human-refined specifications reduce agent-generated code errors by roughly half (Piskala, 2026), and test-as-specification prompting outperforms natural language descriptions of the same problem (Cui, 2025). None of our ~70 engineers were observed running explicit test-first agentic workflows — the Spec-Writer is a ceiling our data points toward but hasn't yet named.

The Unblocker splits. "I use AI to explore and learn when stuck" was a distinguishing stance in the chat era. With an agent, exploring-by-asking is how everyone works — the trait dissolves as distinct, but doesn't tell you where you land. An Unblocker who builds oversight habits moves toward the Orchestrator; one who treats the agent as a get-me-unstuck machine and accepts the output drifts toward the Rubber-Stamper. The first controlled studies suggest that understanding what the agent is doing — not just whether it ran — is the deciding factor (Chen et al., 2025).

The Skeptic sits off the axis entirely — refusing the tool, sometimes good enough to get away with it, always paying the opportunity cost. Under-reliance doesn't disappear in the agentic era; it gets more expensive.

Everything that used to be five flavors of behavior now reduces, roughly, to where on that axis are you.

The honest caveat

I want to be straight about the evidence, because it's early. The research on agentic coding is emergent, not settled — the first controlled developer-agent studies and the large pull-request mining analyses landed only recently, and they don't yet agree on much. One widely-shared figure — that ~74% of agent-generated PRs get merged with no changes — didn't hold up when I traced it; the defensible number is closer to half, and even those usually get small edits afterward. Rubber-stamping is real, but it's a tendency to manage, not a settled statistic to wave around.

There's also a redemptive wrinkle the research insists on: letting an agent run unattended is not, by itself, the failure. Oversight is a learned skill, and experienced engineers genuinely shift from approving every step to monitoring with a lighter touch. The red flag was never the autonomy. It's the absence of review — running the agent and never checking what it did.

What to do with this

If you're hiring, the thing to assess is quietly changing under you. The old signal — "can they write this function" — matters less every month. The new one is oversight: can they write a spec an agent can execute, and can they catch the agent when it's confidently wrong? And the most diagnostic question of all: do they define done before the agent starts, or after? That's the difference between an Orchestrator and a Spec-Writer — and it's a difference you can observe.

If you're an engineer, the move is to deliberately climb the axis. Stop grading yourself on how much code you produced and start grading yourself on the quality of your specs and the rigor of your reviews. The Orchestrator isn't a worse engineer who offloaded the work. They're a better one who figured out where the work actually moved. And the Spec-Writer is further up still — the one who figured out that the best review happens before the first commit.

Everyone has the agent now. The question — the only one that survives the collapse — is whether your hands are still on the wheel.

Why we read it this way — sources

1. Chen et al. (2025). Code with Me or for Me? How Increasing AI Automation Transforms Developer Workflows. CHI 2026, arXiv:2507.08149. — first controlled empirical comparison of copilot vs. agent workflows; the author→overseer role shift; oversight as a learned, graduating skill.

2. AIDev pull-request mining study (2026). arXiv:2601.20106. — empirical review/acceptance patterns on agent-authored PRs; the corrected "merged-without-modification" figure.

3. Anthropic (2024–25). Measuring agent autonomy and Claude Code auto mode. — autonomy/permission modes and the rubber-stamping risk, from production telemetry.

4. Barke, S. et al. (2023). Grounded Copilot. OOPSLA 2023, arXiv:2206.15000. — the acceleration/exploration distinction that the Director and (fading) Unblocker came from.

5. Microsoft Aether (2022). Overreliance on AI. — over- and under-reliance, behind the Rubber-Stamper and the Skeptic.

6. Srivastava, S. et al. (2025). Professional Software Developers Don't Vibe, They Control. arXiv:2512.14012. — field study of 13 experienced developers showing deliberate orchestration (explicit planning, bounded scope, active supervision), not vibe-coding, characterises real professional adoption.

7. Piskala, D. B. (2026). Spec-Driven Development: From Code to Contract in the Age of AI Coding Assistants. arXiv:2602.00180. — formalises spec-first development as a contract discipline; human-refined specs reduce LLM-generated code errors by up to 50%.

8. Cui, Y. (2025). Tests as Prompt: A Test-Driven-Development Benchmark for LLM Code Generation. arXiv:2505.09027. — empirical evidence that tests-as-specification outperform natural language prompts for agentic code generation; the quantitative grounding for the Spec-Writer claim.

Part one — the five archetypes and the data behind them — is here.