DDoS'ing the human brain
tl;dr: AI made us mass produce code at a scale we never could before. More code, more problems, same brain. Somehow I'm more productive and more exhausted at the same time.
In a traditional DDoS attack, a server is flooded with so many requests that it can no longer respond to legitimate ones. As developers in the age of AI, we are beginning to experience a version of this in our own heads. The AI provides a massive volume of traffic, and our "thinking context" is increasingly spent just trying to sort, manage and steer the flood. But is spending more mental energy on housekeeping of AI code even a problem? I've been using AI extensively over the past years through various programming tasks and I kinda want to share some thoughts and observations of that.
Learning To Love The Machine
Whilst for some the shift was earlier than others, for me personally the shift happened in September 2025 with the release of the Opus 4.5 model. Sure, I've played around with AI here and there before but I struggled to integrate it into my daily workflow because it ended up causing me to be distracted, losing focus and constantly having to correct it. With the newer models this is less of a problem and they have reached a state where they are genuinely useful. They are amazing at debugging code, amazing at dealing boilerplate and the less fun part of development. It's very clear that AI has and will continue to change software development forever.
A lot of the skills you learn when working with AI resemble human learning in many ways. AI allows you to increase volume dramatically. You can output so much more code than you could ever before. It's a thrilling experience to be honest. But it also means there is more code to manage, more code to review, and more code that can go wrong. Despite those 1 million token context models, context still feels limited. I find myself flip-flopping between stages of: "this is amazing" to "why is this so dumb".
The Cache Hit In Our Brains
If we're thinking about context, we also need to think about ourselves and how our own brain works. Similar to AI we have limited context. We're even a lot worse at multi-tasking. When you really think about it, learning a skill and mastering it, is the process of committing behaviour or experiences into long lived memory, so that your current thinking context stays free and can exclusively focus on the task in front of you.
Picture a tennis athlete at the highest level. They are not thinking anymore about how to move their feet or how to swing the racket. They spend years, even decades, so that this happens unconsciously so that they can use the thinking context they have for tactics, exhaustion management and other things that are important to win the match.
Coding in a way is a similar skill that has always benefited from a similar process. As a seasoned developer you're not constantly fighting the language anymore like when you were starting out. There is this level of zen that you arrive at some point that allows you to mostly focus on the problem at hand and expressing that in whatever programming language of choice feels mostly mechanical. A lot of decisions happen subconsciously and allow your context to be free. You have likely already dismissed a lot of potential bad architectural mistakes because you have seen them so many times in the past. You have likely thought about the critical problems that can occur from the start and built a system that avoids them from the get go entirely and more.
Slowly Dropping Packets
AI changes all this. There is much more volume now and it seems likely that demand to ship even more software will just grow and grow. That kinda turns developers more into a blend of managing workers. You still need to think about architecture and how pieces fit together. AI often struggles with picking the right approaches and unless something is represented in the training data, it often fumbles and makes poor architectural choices. This happens quite often and no matter how much I try to combat that with phrasing in claude.md or agents.md or even using dedicated agents entirely, this is unsolved. Instead of thinking about the task at hand I'm realizing that I'm spending more time thinking about things that I have long committed to subconscious memory. My thinking context is occupied.
The irony is that while AI was supposed to elevate us to "Architects", it often forces us back into the role of "proofreaders". When you write code yourself, the "why" is often built into every line. You're constantly reassessing architecture and thinking about the current problem. When you review AI code, you have to reverse-engineer the "why" from the "what." This is a much heavier lift for the brain. It’s the difference between telling a story and fact-checking someone else's.
Because the volume of code is so high, the time we spend in this 'Hyper-Vigilant' state increases. We are constantly context-switching between the high-level goals of the project and the low-level housekeeping of correcting the AI’s 'subconscious' mistakes. Eventually, the mental buffer fills up. We start accepting 'good enough' designs because we simply don't have the cognitive RAM left to fight the AI for the 'great' design we would have built from scratch. I don't think the solution is to use AI less, the genie is out of the bottle and the gains are undeniable. But we might need to become more intentional about our cognitive budget. We have DDoS'ed our brain.
The Jet Engine in a Horse Carriage
This struggle has made me realize that part of the DDoS isn't just the AI's fault; it's that our toolings are stuck in the past. We're still inputting code character by character, keystroke by keystroke. Sure there is autocomplete and maybe the occasional snippet, but that's a far cry from where we should be.
I find myself desiring more advanced, intent-based features. Instead of typing, I want to be able to say: "Wrap this selection in an if-let block" or "Extract this logic into this pattern." etc.
We need tools that operate at the level of intent rather than syntax . We need editors that don't just autofill text, but understand the architectural patterns we're trying to implement. We need tools that can pre-fill git commit messages based on logic. We need tools that transform data structure across an entire project with a single gesture because they understand the language's semantics as well as we do. We should do less typing and more orchestrating.
Ultimately, the feeling of being DDoS'ed is a signal that we are in a transition period. We've gained the ability to generate code at scale, but we haven't yet mastered the interface to manage it. For now, we are in a strange middle ground. The DDoS might just be the inevitable result of using AI through an interface designed for a different era of computing.