The debate around "vibe coding" often gets stuck on one question:
Who wrote the code — the developer or the AI?
I think that's the wrong question.
We've been moving toward higher levels of abstraction in software development for decades.
We went from machine code to assembly, from assembly to higher-level languages, from manual memory management to garbage collection, from writing everything ourselves to frameworks, libraries, IDEs, autocomplete, linters, static analysis and code generators.
AI-assisted coding is another step in that direction.
Vibe coding is essentially pushing the abstraction layer even further.
The interesting part isn't that AI can write code.
The interesting part is what happens to software engineering when writing code becomes cheaper.
Coding Was Never the Whole Job
A software engineer doesn't just write code.
Before a line of code is written, there are questions such as:
- What are we actually trying to solve?
- What architecture should we use?
- Where should the boundaries between components be?
- Which database makes sense?
- Which libraries or frameworks should we choose?
- What are the security implications?
- What are the scalability requirements?
- What happens when the dependency we selected becomes unsupported?
- How should failures be handled?
- How should the system be tested?
- What are the operational and maintenance costs?
- What should we deliberately NOT build?
And after the code is written:
- Can we maintain it?
- Can another engineer understand it?
- Can we observe it in production?
- Can we debug it six months from now?
- Can we change one component without breaking five others?
- Does it perform under real workloads?
- What happens when assumptions change?
None of these questions disappear because an AI can generate 500 lines of code in 30 seconds.
AI Makes Implementation Cheaper
This is where I think the current debate is missing something important.
AI is dramatically reducing the cost of implementation.
That's a good thing.
If I can describe a requirement and have an AI generate a first implementation, I don't need to spend my time typing boilerplate.
The same way I don't manually write every getter and setter anymore.
The same way I don't manually remember every API signature because my IDE can autocomplete it.
The same way I don't manually search every documentation page when tooling can surface the information.
AI is becoming another layer between the engineer and the implementation.
But lower implementation cost doesn't eliminate engineering.
It increases the value of engineering decisions.
The Hard Part Moves Up the Stack
When code becomes cheap, decisions become more important.
Choosing the wrong library can create years of technical debt.
Choosing the wrong architecture can make scaling painful.
Choosing the wrong data model can make future requirements extremely expensive.
Choosing a technology because an AI suggested it doesn't make it a good engineering decision.
The AI can generate the implementation.
But someone still needs to ask:
Why this architecture?
Why this database?
Why this library?
Why this API boundary?
Why this security model?
Why this deployment strategy?
What happens when this assumption is wrong?
That's engineering.
Vibe Coding vs Engineering
I don't think vibe coding is necessarily bad.
For prototypes, experiments, internal tools, proof-of-concepts and learning, it can be incredibly productive.
The problem starts when we confuse:
"The software works."
with
"The software has been engineered."
Those are not the same thing.
A generated application can compile.
It can pass a few tests.
It can look impressive.
It can even reach production.
And still have terrible architecture, poor security, unnecessary dependencies, weak observability, difficult maintenance and enormous technical debt.
The Engineer's Job Is Changing
I don't think AI is making engineering less important.
I think it is changing what good engineering looks like.
Less time typing.
More time thinking.
Less boilerplate.
More architecture.
Less implementation effort.
More validation.
Less memorising syntax.
More understanding systems.
Less "How do I write this function?"
More "Should this function exist here at all?"
That is a much more interesting future.
The best engineers won't necessarily be the people who write the most code.
They will be the people who can understand the problem, make good technical decisions, use AI effectively, challenge its output, and build systems that remain reliable and maintainable long after the initial excitement is gone.
Vibe coding isn't the death of software engineering.
If anything, it may finally force us to recognise that software engineering was never just about writing code in the first place.
#multimindSDK #ai2innovate #opensource #AI #LLMops #MLOps #MachineLearning #Python #AIDeveloperTools #framework
#devops #tutorial #webdev #aidevtools #mlops #programming
Top comments (0)