Slowing Down in the Age of AI
June 18, 2026
A few months back, I found myself deep into a bunch of different tasks.
The hum of productivity as I jumped between worktrees, each with its own agent, or sometimes even multiple agents, working away. My tooling setup was dialed in. On paper, I felt more productive than ever. My commit numbers and LOC were at an all-time high, and I was shipping more than ever.
Compare this to just a year or two ago. I would have one primary task at hand, almost exclusively working directly with the code. Working head down, digging deep into documentation, issues, and the problem itself. It was, by all means, incredibly slow compared to what we are used to now.
AI has been incredibly beneficial, the productivity gains are off the charts. But, I am beginning to wonder if productivity is more beneficial than understanding.
When I am juggling multiple tasks and agents are doing the bulk of the work, I feel like my understanding of the problems diminish. Often I think I understand the problem but I've realized that the output of my agents is outpacing my understanding of the problem.
Now that we are writing code manually less often, we can move so much faster. Many people claim that coding is essentially solved, and in some regard they are right. But I don't think writing code was ever the hard part.
Coding wasn't valuable because writing code was hard. Coding was valuable because it forced us to slow down and spend time with a problem.
Every function we wrote required another decision. Another tradeoff. Another moment to realize our original design wasn't quite right. We weren't becoming better engineers because we typed code. We became better engineers because coding forced us to spend hours living with the problem.
Pre-AI, coding was a forced friction that we couldn't really get around. This friction caused us to touch each piece of the problem with our eyes and our brain as we worked through what to write. When we jumped to this frictionless type of coding, we inadvertently lost understanding. I don't think we've realized how much understanding we've lost because we are a bit blinded by productivity and speed.
The work AI leaves behind is precisely the work that requires understanding, judgment, and a rich mental model. Unfortunately, those are the very things that constant context switching kills.
Historically, as developers, we've always known that context switching kills productivity. But now it seems like abilities we have with AI have tricked us into thinking that the only way to be productive is to constantly context switch and work on many tasks in parallel.
My goal is not to use AI less. But I have realized that I need to be intentional about slowing down. I need to protect my ability to build one deep mental model at a time. We haven't really had to be intentional about slowing down before, writing code previously forced that on us.
I'm not convinced the answer is just less AI. I'm convinced it's fewer mental contexts.
Let ten agents execute one idea.
Don't ask your own brain to hold ten ideas at once.
The engineers who build the best software will not be the ones running the most agents, making the most commits, or running the most tasks in parallel. The best engineers will be the ones who know when to stop spawning new threads, slow down, and spend time understanding one problem deeply.
This is how the best software is produced. And I think it always will be.
