The New AI Psychosis Inside Tech Companies
I strongly believe there are entire companies operating under heavy AI psychosis right now.
Not because AI is useless. Not because automation is bad. But because many teams have started confusing speed with understanding.
The scary part is how difficult it has become to even discuss this rationally.
The moment concerns are raised, the response is usually:
- ▸“The AI already fixed it.”
- ▸“We have full test coverage.”
- ▸“Bug reports are actually decreasing.”
- ▸“Development velocity is higher than ever.”
Locally, those metrics look healthy. Globally, the system may already be decaying.
We Already Learned This Lesson Once
Years ago, infrastructure teams went through a similar transformation during the rise of cloud automation.
At the time, everyone became obsessed with:
- ▸Automation
- ▸Self-healing systems
- ▸Fast recovery
- ▸Infinite scalability
- ▸Infrastructure as code
One debate dominated everything:
MTBF vs MTTR.
Mean Time Between Failure (MTBF)
How often systems fail.
Mean Time To Recovery (MTTR)
How quickly systems recover after failure.
Eventually, many organizations adopted an extreme mindset:
“Failures are fine because recovery is fast.”
And to some extent, that worked.
But over time, something dangerous happened.
Teams optimized recovery speed so aggressively that they stopped designing systems that were fundamentally understandable.
AI Development Is Repeating the Same Mistake
Now the exact same thinking is spreading into software development.
The mindset has become:
“It’s okay if AI ships bugs because AI agents can fix them faster than humans.”
That sounds efficient. Until the architecture itself becomes impossible to reason about.
The problem is not individual bugs. The problem is systemic comprehension.
Healthy Metrics Can Hide a Sick System
This is the part many companies miss.
Systems can appear healthy while becoming deeply fragile underneath.
Bug reports may go down because:
- ▸Users stop reporting small failures
- ▸AI patches symptoms instantly
- ▸Teams stop understanding root causes
- ▸Nobody can trace responsibility anymore
Test coverage may rise while semantic understanding collapses.
You can have:
- ▸95% test coverage
- ▸Fast deployments
- ▸Automatic fixes
- ▸Stable uptime
…and still be building a long-term catastrophe machine.
The Danger of Infinite Local Optimization
AI is exceptionally good at local optimization.
It can:
- ▸Refactor functions
- ▸Fix syntax
- ▸Generate tests
- ▸Patch edge cases
- ▸Improve performance
- ▸Automate repetitive work
But software systems are not collections of isolated local optimizations.
Real systems depend on:
- ▸Shared mental models
- ▸Architectural clarity
- ▸Long-term maintainability
- ▸Human intuition
- ▸Organizational understanding
When code changes faster than humans can understand it, architecture slowly becomes invisible.
And invisible systems are dangerous systems.
Infrastructure Taught Us a Brutal Lesson
In cloud infrastructure, we eventually learned:
You can automate yourself into a resilient catastrophe machine.
A system can recover from failures endlessly while becoming:
- ▸More complex
- ▸Less observable
- ▸Harder to debug
- ▸More fragile under rare conditions
- ▸Dependent on fewer people who actually understand it
Everything looks fine… until one day it suddenly isn’t.
And when failure finally arrives, nobody fully understands the machine anymore.
The Hidden Cost of AI Velocity
The current AI wave is massively increasing software velocity.
That sounds exciting.
But velocity without comprehension creates organizational debt.
Every AI-generated abstraction introduces another layer that fewer humans fully understand.
Over time, teams risk becoming operators of systems rather than builders of them.
That distinction matters.
Because operators can restart systems. Builders understand why systems fail.
The Real Risk Is Cultural
The technical risks are manageable. The cultural risks are harder.
Many companies are slowly normalizing:
- ▸Shipping before understanding
- ▸Trusting generated code blindly
- ▸Measuring productivity only through output
- ▸Equating tests with correctness
- ▸Replacing reasoning with iteration speed
The problem is that software engineering is not manufacturing.
More output does not automatically create better systems.
Sometimes it simply accelerates entropy.
AI Is Powerful — But Human Understanding Still Matters
None of this means AI should be avoided.
AI is already transforming development in incredible ways.
It can:
- ▸Reduce repetitive work
- ▸Speed up debugging
- ▸Improve developer productivity
- ▸Help smaller teams move faster
- ▸Lower barriers to entry
But AI should amplify engineering judgment — not replace it.
The healthiest teams will likely be the ones that combine:
- ▸AI acceleration
- ▸Strong architectural discipline
- ▸Human review
- ▸Deep system understanding
- ▸Long-term thinking
Because resilient systems are not built only by fixing failures quickly.
They are built by designing systems humans can still reason about years later.
Final Thoughts
What worries me most is not that AI will introduce bugs.
Software has always had bugs.
What worries me is the possibility that the industry is slowly accepting a future where nobody fully understands the systems being built anymore.
And history suggests that highly optimized, poorly understood systems eventually fail in ways nobody anticipates.
We already learned this lesson once in infrastructure.
I’m not sure the software industry realizes it’s learning the same lesson again.
