Senior Devs Vibe Code Too
After a long blogging break, I'm back with a blunt take: I've fully embraced AI and vibe coding, and it has fundamentally changed how I build software.
It's been a while since I last wrote here.
Part of that is life. Part of it is startups. But honestly, a big reason is that my workflow changed so much that I had to sit with it before talking about it publicly.
I'm now fully pro-AI. I vibe code. Daily. In production contexts. And I'm not apologetic about it.
A year ago, I would have told you AI is useful for autocomplete, boilerplate, and quick experiments. Today, it is a core part of how I ship features, explore ideas, and reason about systems.
Not as a replacement for engineering. As an extension of it.
Vibe coding is not a junior thing
There's a lazy take floating around that AI coding tools are for beginners who cannot write code.
That narrative collapses the moment you look at who is actually adopting these tools seriously.
Experienced engineers are using them aggressively. People who care about correctness. People who built large systems before LLMs existed. People who understand tradeoffs.
That matters.
If AI was only useful for shallow work, seniors would ignore it. Instead, what I'm seeing is the opposite: the more experienced the engineer, the more they let agents produce real output.
That sounds backwards until you understand why.
Senior engineers are not defined by how fast they type.
They are defined by:
- How clearly they describe problems
- How well they decompose work
- How quickly they spot incorrect assumptions
- How effectively they review
- How they orchestrate moving parts
Those skills map directly onto working with AI.
Prompting is just specification. Reviewing agent output is just code review. Running multiple agents is delegation. Managing context is orchestration.
Once you see that, the adoption curve makes sense.
I stopped measuring myself by how much code I write
Early in my career, I cared a lot about output.
Commits. Lines changed. Features shipped directly by me.
That mindset quietly breaks once you start working on real systems with real constraints.
At some point, you hit a ceiling. You cannot personally implement, test, maintain, and evolve everything anymore. The bottleneck stops being typing speed and starts being coordination.
This is where AI fits naturally.
These days, I spend more time doing things like:
- Writing tight specs instead of raw code
- Breaking features into agent-sized chunks
- Running multiple experiments in parallel
- Reviewing generated PRs
- Rejecting half-baked output
- Iterating on architecture instead of implementation details
A concrete example:
Instead of spending half a day wiring up a new ingestion pipeline by hand, I now:
- Describe the system boundaries
- Define the interfaces
- Ask an agent to scaffold the service
- Have another agent write tests
- Review everything myself
- Integrate manually
The code still goes through my brain.
But I'm no longer the one grinding through every file.
That shift is subtle, but massive.
AI writes code. Engineers decide what matters.
Let's be clear about something.
AI can generate working code.
It can build utilities. It can fix bugs. It can refactor modules. It can replace entire dependencies.
But it does not understand:
- Why this service exists
- Which tradeoffs are acceptable
- What breaks downstream
- What will be painful to maintain in six months
That part is still on you.
So the question is not "does the AI write code?"
It does.
The real question is:
How much are you willing to let execute before you read it?
For me, the answer depends on context.
If it's a one-off script on my laptop, I barely care.
If it's production code:
- I read it
- I test it
- I compare it against existing behavior
- I sometimes run a second model to review it
- I treat it like a junior engineer's PR
That last part is important.
AI is not magic. It is a very fast, tireless junior developer with infinite patience and zero ownership.
You still have to be the senior in the room.
Vibe coding works because clarity beats capability
Here's something that clicked for me recently.
We over-index on individual coding ability in this industry.
We reward people who can:
- Implement features quickly
- Debug obscure issues
- Hold complex systems in their head
Those are useful skills. But they top out.
What actually scales is clarity.
Clarity in:
- Requirements
- Interfaces
- Failure modes
- Expectations
- Communication
When you work with AI, this becomes painfully obvious.
Vague prompt? Garbage output.
Clear spec? Surprisingly solid result.
AI forces you to confront how fuzzy your thinking is.
You cannot say "build the thing" anymore. You have to explain:
- What the thing does
- What inputs look like
- What outputs must guarantee
- What edge cases matter
- What should explicitly not happen
That is engineering.
And this is why experienced devs adapt faster. They already spent years learning how to express intent precisely. They already know how to break work into parts. They already have strong priors for correctness.
Junior engineers struggle here because they are still learning what matters.
Delegation and orchestration matter more than ever
There's a moment every senior engineer hits.
You realize you could implement something yourself in a day.
But instead, you hand it off.
It comes back in three days. It's not perfect. You give feedback. It comes back again.
That feels inefficient at first.
But then something important happens.
That person now owns that code. They fix bugs. They understand the system. They carry context forward.
Your leverage increases.
Working with AI feels similar, except the ownership part is missing.
Agents will never own production failures.
So you still need humans for:
- Long-term maintenance
- Institutional memory
- Product intuition
But for raw execution?
AI is absurdly efficient.
I can spin up parallel agents to:
- Explore architectural options
- Prototype features
- Write migrations
- Build internal tools
- Generate scaffolding
This is orchestration.
My job becomes deciding what gets built, how pieces connect, and what quality bar applies.
Not typing everything myself.
That is a hard mental shift if your identity is tied to writing code.
I had to unlearn that.
Vibe coding is just supervised collaboration
People argue about "vibe coding" like it's reckless.
It depends on your definition.
If you mean blindly generating code and shipping it without reading, yes, that's irresponsible.
But that is not what most experienced engineers are doing.
What we are doing looks more like this:
- Describe the goal
- Let the agent propose an implementation
- Review critically
- Ask for changes
- Iterate
- Integrate
That is collaboration.
The only difference is your teammate runs on GPUs and responds in seconds.
I still:
- Reject bad PRs
- Ask for tests
- Question design choices
- Rewrite parts manually
The vibe part is simply letting go of micromanaging every keystroke.
You focus on outcomes instead of syntax.
Small side repos changed how I think
One unexpected benefit of AI is how cheap experimentation became.
I now spin up tiny repos constantly.
To test ideas. To validate assumptions. To explore libraries. To benchmark approaches.
Instead of forcing everything into a massive codebase, I'll ask an agent to create a minimal reproduction or prototype.
That habit alone improved my velocity more than any framework ever did.
It also made me more curious.
If I wonder how something behaves, I don't Google for 30 minutes.
I build a quick experiment.
That feedback loop is addictive.
Anti-AI takes usually miss the real shift
Most anti-AI arguments focus on code quality.
That's not the core change.
The real shift is that software engineering is moving away from individual implementation and toward system-level thinking.
Planning. Delegating. Reviewing. Orchestrating.
These were already the skills that separated senior from staff.
AI just drags everyone into that world faster.
If you only value personal coding output, this feels threatening.
If you already think in systems, it feels empowering.
I'm back to blogging because this change feels fundamental.
I'm building faster. I'm exploring more. I'm spending less time on mechanical work and more time on design.
I still care deeply about correctness. I still read the code. I still own what ships.
But I no longer believe that typing everything myself is virtuous.
AI is here. Vibe coding is real. And for experienced engineers, it fits naturally into how we already think.
The takeaway is simple:
If you learn to be clear, to delegate, and to orchestrate, these tools multiply your impact.
If you cling to measuring worth by keystrokes, you will struggle.
I chose the first path.