Is AI Making Us Dumber?
The hidden trade-off of AI coding: Speed increases while system understanding decreases.
Dave Garcia
Founder and Co-CEO
Mar 25, 2026
The shift nobody is really talking about
Working with AI feels like leverage at the beginning: You move faster, you unblock yourself instantly, and you produce in minutes what used to take hours. It genuinely feels like progress. But after a while, something more subtle starts to happen… You are still moving fast, but you are no longer engaging with the problem at the same depth. That’s because you stop holding the full system in your head, you stop questioning outputs as rigorously, and you start relying on the fact that the answer is “probably fine.” The change is not dramatic, but it is consistent, and over time it compounds.
From building systems to approving outputs
The core shift is not about intelligence, it is about behavior. AI changes the default mode of work from building to accepting.
Instead of constructing solutions step by step, you prompt and review.
Instead of reasoning through the problem, you validate the result.
But validation is inherently shallow. You check if something works, not whether you fully understand why it works or how it will behave over time. That distinction matters, because it changes your relationship with the system. You move from being the author of the logic to being a reviewer of outputs you did not fully generate.
The incentives push you in the wrong direction
This behavior is not accidental, it is perfectly aligned with the incentives. Understanding something deeply takes time and effort. Challenging an answer requires even more. Rewriting it from first principles is the most expensive path. Accepting it, on the other hand, is almost free. So most people accept, not because the answer is correct, but because it is good enough and the system keeps moving forward.
In isolation, that decision is rational. At scale, across hundreds of small decisions, it is how complexity accumulates and systems begin to degrade.
This is not new, but it is faster than before
There is a recent piece from Harvard Gazette asking whether AI is dulling our minds, focusing on memory and critical thinking. That framing misses the point for engineering. This is not primarily a cognitive issue, it is a structural one. Software has always degraded through small, unchallenged decisions that accumulate over time: Shortcuts compound, assumptions go untested, and abstractions become fragile. AI does not introduce this dynamic, but it dramatically accelerates it by making it easier to generate decisions and easier to accept them without friction.
The problem is not that AI is wrong
The real issue is not that AI produces incorrect outputs, but that it produces plausible ones. The code is clean, the structure makes sense, and the result often passes tests. It integrates well enough to move forward, and that creates the illusion that the system is improving. The problem is not the model, it’s the frame. Coding assisting tools have been gamified to get the dopamine hook rolling.
But underneath, complexity can be increasing and understanding can be decreasing. When you ship something you do not fully reason about, you lose a small piece of control over the system. That loss is incremental, but it accumulates with every accepted output.
Losing the system in your head
At some point, the shift becomes structural. If you are no longer holding the system in your head, you are no longer truly designing it. You are assembling it from generated pieces, trusting that they fit together. This works for a while, especially in the early stages, but it becomes fragile as the system evolves. Real software is not static, it changes continuously, and every new change interacts with everything that came before. Without a clear mental model, those interactions become harder to predict and easier to break.
The real trade-off we are making
AI is not making engineers less capable, but it is changing what is easy and what is hard. Speed becomes trivial, acceptance becomes the default, and depth becomes optional.
Over time, most people optimize for what is easiest, especially under pressure to deliver. The trade-off is not visible in the short term because everything appears to be working, but it shows up later in the form of fragility, rework, and systems that are harder to evolve.
What will actually differentiate engineers now
The engineers who stand out in this environment will not be the ones who produce the most output, but the ones who know when to slow down. They will be the ones who resist the default of accepting answers without fully understanding them. They will treat AI outputs as hypotheses that need to be validated deeply, not as solutions that can be shipped immediately. The skill is no longer just about building, but about maintaining ownership of the reasoning behind what gets built.
The real risk
AI is not making us dumber. What it is doing is making it extremely easy to disengage from the thinking process. In complex systems, that is enough to create the same outcome. Software rarely fails because of a single obvious mistake. It fails because too many small decisions were accepted without being fully understood. By the time the consequences appear, the context behind those decisions is gone, and the system is already drifting in a direction nobody fully controls.
The shift nobody is really talking about
Working with AI feels like leverage at the beginning: You move faster, you unblock yourself instantly, and you produce in minutes what used to take hours. It genuinely feels like progress. But after a while, something more subtle starts to happen… You are still moving fast, but you are no longer engaging with the problem at the same depth. That’s because you stop holding the full system in your head, you stop questioning outputs as rigorously, and you start relying on the fact that the answer is “probably fine.” The change is not dramatic, but it is consistent, and over time it compounds.
From building systems to approving outputs
The core shift is not about intelligence, it is about behavior. AI changes the default mode of work from building to accepting.
Instead of constructing solutions step by step, you prompt and review.
Instead of reasoning through the problem, you validate the result.
But validation is inherently shallow. You check if something works, not whether you fully understand why it works or how it will behave over time. That distinction matters, because it changes your relationship with the system. You move from being the author of the logic to being a reviewer of outputs you did not fully generate.
The incentives push you in the wrong direction
This behavior is not accidental, it is perfectly aligned with the incentives. Understanding something deeply takes time and effort. Challenging an answer requires even more. Rewriting it from first principles is the most expensive path. Accepting it, on the other hand, is almost free. So most people accept, not because the answer is correct, but because it is good enough and the system keeps moving forward.
In isolation, that decision is rational. At scale, across hundreds of small decisions, it is how complexity accumulates and systems begin to degrade.
This is not new, but it is faster than before
There is a recent piece from Harvard Gazette asking whether AI is dulling our minds, focusing on memory and critical thinking. That framing misses the point for engineering. This is not primarily a cognitive issue, it is a structural one. Software has always degraded through small, unchallenged decisions that accumulate over time: Shortcuts compound, assumptions go untested, and abstractions become fragile. AI does not introduce this dynamic, but it dramatically accelerates it by making it easier to generate decisions and easier to accept them without friction.
The problem is not that AI is wrong
The real issue is not that AI produces incorrect outputs, but that it produces plausible ones. The code is clean, the structure makes sense, and the result often passes tests. It integrates well enough to move forward, and that creates the illusion that the system is improving. The problem is not the model, it’s the frame. Coding assisting tools have been gamified to get the dopamine hook rolling.
But underneath, complexity can be increasing and understanding can be decreasing. When you ship something you do not fully reason about, you lose a small piece of control over the system. That loss is incremental, but it accumulates with every accepted output.
Losing the system in your head
At some point, the shift becomes structural. If you are no longer holding the system in your head, you are no longer truly designing it. You are assembling it from generated pieces, trusting that they fit together. This works for a while, especially in the early stages, but it becomes fragile as the system evolves. Real software is not static, it changes continuously, and every new change interacts with everything that came before. Without a clear mental model, those interactions become harder to predict and easier to break.
The real trade-off we are making
AI is not making engineers less capable, but it is changing what is easy and what is hard. Speed becomes trivial, acceptance becomes the default, and depth becomes optional.
Over time, most people optimize for what is easiest, especially under pressure to deliver. The trade-off is not visible in the short term because everything appears to be working, but it shows up later in the form of fragility, rework, and systems that are harder to evolve.
What will actually differentiate engineers now
The engineers who stand out in this environment will not be the ones who produce the most output, but the ones who know when to slow down. They will be the ones who resist the default of accepting answers without fully understanding them. They will treat AI outputs as hypotheses that need to be validated deeply, not as solutions that can be shipped immediately. The skill is no longer just about building, but about maintaining ownership of the reasoning behind what gets built.
The real risk
AI is not making us dumber. What it is doing is making it extremely easy to disengage from the thinking process. In complex systems, that is enough to create the same outcome. Software rarely fails because of a single obvious mistake. It fails because too many small decisions were accepted without being fully understood. By the time the consequences appear, the context behind those decisions is gone, and the system is already drifting in a direction nobody fully controls.
