Deep Work in an Agentic World — Does Cal Newport's Superpower Still Hold?

In my Deep Work post I argued that focused, uninterrupted concentration is the most important productivity tool an engineer has. I still believe that. But something has changed — and I think it challenges, or at least evolves, Newport’s thesis in a way worth talking about.

I now regularly run multiple AI agents in parallel. One is refactoring a module, another is writing tests, a third is drafting documentation — all at the same time, while I’m thinking about something else entirely. So what does “deep work” even mean when your throughput is no longer limited by how fast you can type or think through one problem?

What Newport wrote still stand up today

Let’s be clear: the core of Deep Work is not about how much you produce. It’s about the quality of the thinking you bring to hard problems. And that hasn’t changed one bit.

Agents are fast. They’re often brilliant. But they don’t know your business context, they don’t understand the trade-offs your team has already argued about for six months, and they absolutely do not bring the judgment that comes from 20 years of watching systems fail in production. That judgment — that deep, contextual, experience-backed thinking — is still entirely your job.

Newport’s point that the ability to focus deeply is becoming rarer and therefore more valuable? In an agentic world, I’d argue it’s becoming even more so. The bottleneck has shifted from “who can produce the most code” to “who can direct agents with the most clarity and review their output with the most rigour.” Both of those things require deep, focused thinking. Not shallow, reactive attention.

But the Environment Has Changed

Here’s where it gets interesting. Newport describes shallow work as the enemy — the meetings, the emails, the context-switching that fills the day and crowds out real thinking. And one of the most genuinely exciting things about agentic coding is that agents eat shallow work for breakfast.

Documenting services? Agent. Writing boilerplate tests? Agent. Drafting the PR description, the release notes, the Jira ticket update? Agent, agent, agent. The stuff that used to cost you two hours of low-energy afternoon time now costs you five minutes of task delegation.

So in theory, agentic tooling should amplify your ability to do deep work — not replace it. You’re not context-switching to write the docs yourself anymore. You delegate it, and you stay in flow.

The New Deep Work — Orchestration

If I’m being honest, I think orchestrating agents is deep work now. And I don’t mean that lightly.

Directing an agent well is not a shallow task. You need to understand the problem deeply enough to decompose it into clear, bounded instructions. You need to anticipate where the agent will go wrong — and they will go wrong, often in subtle ways. You need to review the output with the same critical eye you’d apply to a junior developer’s pull request. As I wrote in my Vibe Coding post, you’re the head chef. What goes out under your name is your reputation.

That requires concentration. It requires context. It requires you to actually understand the system you’re building — not just accept whatever the agent produces because it looks right and the tests pass.

The Trap — Agent Context-Switching Is the New Shallow Work

Here’s the danger I’m seeing, and I’ll put my hand up: I’ve fallen into it myself.

Running five agents in parallel sounds productive. And it can be. But if you’re ping-ponging between agent threads every ten minutes — reviewing one output, redirecting another, kicking off a third — you’re not orchestrating. You’re just doing a new flavour of context-switching. The tasks are being done by machines, but the shallow, reactive attention pattern is exactly what Newport warned us about.

The discipline is this: batch your agent reviews the same way Newport tells you to batch your emails. Set up your agents, let them run, and then do a focused review session. Don’t hover. Don’t micro-manage. Use the time the agents are working to do the thinking that only you can do.

Final Thoughts

Deep Work in an agentic world isn’t dead — it’s just moved up the stack. The focused thinking, the hard problem-solving, the architectural judgment — none of that goes away. If anything, the bar gets higher, because now you’re not just responsible for the code you wrote. You’re responsible for everything your agents produced under your direction too.

Newport told us to protect time for deep thinking. That advice hasn’t changed. What’s changed is what you do with that time. Stop writing boilerplate. Start thinking harder about the problems only you can solve.

So here’s the question I’ll leave you with: are you using agentic tools to create more space for deep work — or are you just filling that space with more agent threads to babysit?