I am not against AI.
Let me start there — clearly.
Artificial intelligence is one of the most powerful tools ever created. It is accelerating medicine, research, accessibility, and creative work. In programming, it can explain complex concepts in seconds, scaffold boilerplate, suggest optimizations, and help developers break through mental blocks.
Hell, I'm using AI to generate the images for the posts, I use it every day.
AI is not the enemy.
What concerns me is something else.
What concerns me is vibe coding.
The Difference Between Using AI and Replacing Yourself
There is a meaningful distinction between leveraging AI and outsourcing your thinking to it.
Using AI to:
- Look up an unfamiliar pattern,
- Generate a helper function,
- Explain a compiler error,
- Or suggest alternative implementations —
That’s assistance. That’s augmentation.
But asking it to generate entire architectures, entire features, entire products — and then shipping them without deeply understanding them — that’s something else.
That’s not acceleration. That’s abdication.
And the consequences are subtle at first.
The Illusion of Speed
Vibe coding feels fast.
You prompt.
It fills.
You tweak.
You ship.
The app runs. The UI renders. The API responds. It feels productive.
But fully vibe-coded programs almost never turn out as robust and secure as they need to be.
And that creates two very real problems.
1. Security Becomes Accidental
Security is not something that emerges from luck.
It comes from careful design:
- Where is state stored?
- How is data validated?
- What assumptions are being made?
- Where can this break under stress?
When you don’t consciously design those things, you don’t own them.
And if you don’t own them, you can’t defend them.
The more layers of generated abstraction you pile on without comprehension, the more your application becomes a black box — even to you.
That’s not innovation.
That’s roulette.
2. Maintenance Becomes a Nightmare
At some point, something breaks.
It always does.
And now you’re facing a codebase you didn’t truly design:
- Patterns you didn’t choose.
- Dependencies you didn’t evaluate.
- Architectural decisions you didn’t consciously make.
You must reverse-engineer your own product.
Fixing these systems often becomes harder and more error-prone than designing them properly from scratch. Every modification feels like pulling on a thread in a sweater — you’re not sure what will unravel.
Speed at the beginning becomes friction at the end.
What We’re Actually Losing
But the technical risks are not even the saddest part.
The saddest part is what we’re losing culturally.
Older software had character.
Not because it was objectively better.
But because it was designed by people who were thinking deeply.
Look at early applications from companies like Winamp, Nullsoft’s chaotic masterpiece. It wasn’t just a media player — it had personality. Skins. Weird visualizers. Experimental UI decisions.
Or early versions of Apple software under Steve Jobs — polarizing, opinionated, deliberate. You could feel that someone cared obsessively about how it felt, not just that it worked.
Even early indie software — small utilities written by a single developer — had quirks. Sometimes ugly. Sometimes imperfect. But distinct.
Now?
Open ten new productivity apps.
They:
- Use the same component libraries.
- Follow the same SaaS template.
- Have the same onboarding flow.
- Use the same pastel gradients.
- Use the same hero section layout.
Different logo. Same soul.
It feels like innovation has been flattened into aesthetic conformity.
The Illusion of Innovation
What’s happening today is strange.
Someone has a genuinely good idea.
Something interesting.
Something novel.
But instead of carefully designing a product that expresses that idea uniquely, they take the shortest path to implementation.
AI scaffolds the backend.
AI generates the frontend.
AI writes the landing page copy.
AI designs the logo.
And the result works.
But it feels like every other app launched that week.
We’ve optimized for speed so aggressively that we’ve sacrificed distinctiveness.
When everything is generated from the same statistical patterns, everything starts to feel statistically average.
The Beauty of Thinking
There is something deeply beautiful about wrestling with a problem.
About modeling your data structures from scratch.
About choosing an architecture intentionally.
About rejecting an abstraction because it doesn’t feel right.
About spending hours simplifying something that technically already works.
That friction is not inefficiency.
It is craftsmanship.
It is where intuition forms.
It is where taste develops.
It is where you become more than someone who “assembles code.”
Vibe coding short-circuits that process.
The generate → patch → regenerate → ship loop removes the cognitive tension that creates growth.
And without tension, there is no strength.
AI as a Tool, Not a Substitute
AI should help you find what you’re looking for faster.
It should:
- Reduce search friction.
- Provide reference implementations.
- Fill in mechanical boilerplate.
- Teach you patterns you don’t yet know.
Using it to generate a function you don’t know how to write — that’s fine.
Using it to understand a concept faster — that’s powerful.
But when the whole system is just… generated… and barely understood by its creator, something fundamental is missing.
Ownership.
When you write something, truly write it, you carry its logic in your head. You know why decisions were made. You know where it can break.
That confidence cannot be prompted into existence.
Everyone Is in a Hurry
We are addicted to shipping.
Shipping fast.
Shipping MVP.
Shipping before someone else does.
But we rarely ask: what are we shipping into the world?
A temporary demo?
Or something designed with care?
Slowing down does not mean rejecting progress.
It means respecting complexity.
It means choosing depth over velocity.
It means valuing long-term understanding over short-term output.
We Need to Slow Down
Not because AI is bad.
Not because speed is evil.
But because quality requires thought.
Because security requires intention.
Because innovation requires courage.
Because character requires time.
The developers who truly understand their systems will always outgrow those who merely prompt them into existence.
We don’t need fewer tools.
We need more responsibility.
We need more taste.
We need more craftsmanship.
We need to slow down.
