In a world where AI tools are becoming essential, vibe coding on existing codebases can lead to disaster. Discover why understanding the boundaries of AI in coding matters.

What VCs Don’t Understand About Vibe Coding

If you're not using AI tools to code in 2025, you're just behind the curve. But vibe-coding on an existing codebase? That's like handing the keys to your car to a drunk teenager. Sure, it might be fine, but it’s more likely to end in tears. 😬

AI Coding Tools: The Necessary Allies

AI tools such as Claude Code, Github Copilot, and Cursor's autocomplete are revolutionizing the way we program. Personally, I find that I code 10-20% faster on average with these nifty gadgets enabled. Fun fact: during a recent internet-less flight, I realized just how dependent I've become on Cursor’s autocomplete while waiting for unit tests that would never come!

However, there’s a catch! Understanding the limits of these tools is absolutely crucial. My team at Reffie primarily works with Python and FastAPI, so this discussion will focus on those, but I promise it’s relevant for whatever code you're crunching away at. 😄

A Primer on Vibe Coding

So, what’s vibe coding? 🤔 Coding agents generally operate in one of three modes:

Autocomplete / Copilot: Think of your email app auto-suggesting text. Coders get autocomplete suggestions on lines of code, functions, or even unit tests while drafting.
Agentic Editing with Human Approval: Imagine having an embedded chat (like ChatGPT) that suggests changes. You manually review and approve these changes, kind of like letting an autopilot steer your car while you hold the wheel just in case.
Vibe Coding: This is where things get spicy. AI takes over and starts live-editing and running commands without your approval. It's like letting your sleep-deprived intern handle production code—what could possibly go wrong?

In practice, vibe coding can be effective for rapid prototyping, generating early mock-ups, or crafting quick one-off scripts (with some caveats). But vibing on a production codebase? That's like tap dancing on a tightrope without a safety net!

Vibe Coding on an Existing Codebase

Most reviews on vibe coding focus on fresh projects or hobby coding. But what about those engineers entrenched in existing systems with tens or hundreds of thousands of lines of code? Spoiler alert: it’s a different game! 🎮

I won’t dive into the details of vibe-coded apps leaking users' data (yikes!), but let's chat about the distinction between greenfield and existing codebases, especially why AI tools struggle on the latter.

Where Do We Spend Time as Developers?

According to my team’s internal metrics, we spend three times as much time fixing bugs and enhancing architecture as we do actually writing new features! Which means when working with an established codebase, these aspects are crucial:

The code must be modern and idiomatic for the language and framework at hand.
Code needs to be easy to read instead of just fast to write. Internal consistency is everything! 📖
Debugging should be as straightforward as possible—no one wants a time suck.
Maximize code reuse: more often than not, there’s already a better version out there! 🛠️

Roles of AI agents fall apart at all these touchpoints.

Common Anti-Patterns in Python Code

It’s not you—it’s the AI! Many AI-generated Python scripts are rife with common anti-patterns, primarily because the AI gets its training data from past code, which often isn’t up to snuff.

Here are some prime examples of how Claude tripped over its own code:

Catching bare exceptions:
```
try:
    do_stuff()
catch Exception as e:
    ...
```
This approach essentially hides underlying errors and makes debugging a nightmare!
F-string formatted logging statements with computation:
```
logging.debug(f"This is the result of some computation: {my_func(thing)}")
```
Since logging statements are lazily evaluated, this eager evaluation can lead to unnecessary computations!
SQLAlchemy old-style code: With the release of SQLAlchemy 2.0, many older practices are deprecated. If Claude generates queries based on outdated conventions, it’s back to the drawing board!

The Takeaway: Should I Stop Using AI?

Ah, the burning question! 💡

Nope! AI-generated code is rapidly improving and there will come a day when the generated code is top-notch. Right now, though, you HAVE to read every line that’s generated. Treat the AI with caution, like that unreliable intern—it doesn’t really care if it messes up.

So, yes, keep using AI, but vet every piece of its output closely. After all, that's what a good coder does; we don’t just throw spaghetti at the wall to see what sticks! 🍝 And if that means enduring some awkward glances over a massive PR, so be it!

About Us

If you love using AI tools but want to build things beautifully from the get-go, we’re hiring! Shoot me a DM or email at [email protected]. Just a heads up: all roles are in-person in Toronto (because let’s be real—I want to stare deeply into your soul after you submit a 3k line PR).