The Vibe Coding Paradox

Source: Dev.to

AI as Co‑Developer in Owned Systems

My last PR for Nudges was +96 −312, touched 38 files, and was about 90 % vibe‑coded. I’m confident in it.

While I was gliding through Hyrule, two different AI agents were quietly refactoring Kafka consumers, validating payload shapes, and committing changes—clean, scoped, and production‑ready. And here’s the thing: it feels good.

Because in that system, the AI isn’t just guessing—it’s working inside a system I built with intention.

That same experience—AI as co‑developer, frictionless and fast—feels completely different in my contracts. There, I don’t own the system. I don’t even trust the system. It still writes the code. The best code. And that—more than anything—is the paradox of this new era: AI removes the friction.

It started with one of those tickets that shouldn’t exist. A client wanted the UI to throw warnings if a form was in just the right state—rules that overlapped with a dozen others. It was a mess: a logic snarl wrapped in inconsistent naming conventions and years of “we’ll get to it next release” tech debt.

I opened the React component: 1,100 lines, most of it conditionals. No test coverage. No documentation. Just vibes and nested ternaries. I pulled up Copilot, hit Win+H, and started talking. I explained what I was trying to accomplish, why it mattered, and where to find context.

Then I leaned back and rubbed my eyes. An AI agent wrote the rest—a fresh set of variables and checks, each one memoized, each one defensive, each one carrying just enough semantic weight to let me keep going without refactoring the whole thing.

And here’s the seduction: it was more precise than what I would have written. So I kept it, checked it, and it worked. But I knew—deep down—I’d just added another 30 lines to a file that should’ve been 300 on its own. I was perpetuating bad patterns.

The Contract Work Paradox

The kicker? I submitted the PR. I could’ve extracted it, just written it myself, but that would’ve taken two hours of understanding the mess. That’s the math now.

On some contracts, I’m making dozens of these trade‑offs every week:

• The “right” way: extract, document, test — ≈ 2 hours.
• The “good enough” way: keep the naming clean, make it work, ship — ≈ 5 minutes.

Multiply that by countless decisions a week, and you start to see the shape of it.

I don’t write code with AI because I can’t do it myself, or because I’m lazy or don’t care. I write with AI because I’ve learned where my energy is best utilized. And this is where the game has changed: it’s trivially easy to do the “good enough” thing. It offers clean names, smart guards, reusable patterns. That’s the danger—you stop noticing you’re doing triage.

“Computers are amplifiers.” – Richard Campbell

If the pattern is clean, it scales clarity. But it also replicates everything:

• Inline functions that should be services.
• Defensive props on components that should be deleted.
• Patterns you meant to fix later, now baked into every new line.

And it does it without resistance—no red flags, no typos. You used to feel it, used to wrestle with the system. The difference isn’t the tool.

Owning the System vs. Not Owning It

In Nudges, I own the system. When AI adds something, I see it instantly: Does this belong here? Does this match the goal of the system I meant to build? If it doesn’t, I stop, I fix it, I nudge it back into alignment. Because I want it to hold. In that context, AI is an amplifier of care, without compromising my standards—those standards were embedded in the design from the beginning.

In my contract work, I don’t own the system. The questions become:

• “Is this best practice?”
• “Will this work? Will it ship? Will it survive the next merge?”

Because that’s the job.

Conclusion

The reward is the same either way. It’s not about skill, age, or speed. It’s about what I choose to do, and when. I merged that PR for Nudges—the one the agents wrote while I was playing a video game. It was beautiful. It was right. But it was right because I spent two years building the constraints that made it right.

Tomorrow I’ll tackle another ticket for a client. I’ll open a file that smells like 2018, regret, and maybe ask an AI to patch a hole I should probably fix at the source. It will be ugly. It will be “good enough.” And it will be exactly what the system deserves.

If the code writes itself, our hands are off the keyboard, but our fingerprints are everywhere.