Vibe Coding a Git Tool: Silly Idea, Serious Lessons

date

Apr 22, 2025

work-status

slug

vibe-coding-git-tool-silly-idea-serious-lessons

status

Published

TL;DR

🛠 Vibe coding isn’t bad—but coding without context is. Don’t ship what you don’t understand.

⚡ Tools like Lovable and Cursor can boost your speed—if you guide them properly.

🧠 AI makes mistakes—and so do we. That’s okay. But someone has to catch them.

📉 AI isn’t a replacement for understanding code logic—it’s only as smart as the developer behind the prompt.

🧩 Don’t lose your problem-solving muscle. Knowing when and how to prompt is just as important as writing code.

Lately, I’ve seen the phrase “vibe coding” tossed around like confetti on tech Twitter. It’s catchy, sounds fun—but also wildly misunderstood., Reddit and Linkedin. Let me be clear: I’m not against vibe coding. It’s actually pretty powerful when used with intention. But vibe coding without context? Without any clue of what the code is doing or how it fits in? That’s where it all starts to break.

I’ve seen AI tools generate code that looks fine on the surface—but is logically flawed, unscalable, or just flat-out wrong. If you blindly trust it, you’re not coding—you’re gambling.

That’s why I decided to try this for myself: take a real-world side project, use AI tools to build it, and see what vibe coding looks like when you actually know what’s going on under the hood.

The Idea: Build a Git Comparison Tool

I had a pretty straightforward idea:

Build a tool to compare contributions of up to 3 developers in a GitHub repository—or even across multiple repos—within a given time range.

Nothing fancy.

I wasn’t chasing perfection, scalability, or production-readiness. I just wanted to test the limits of AI-assisted development, see how far I could get, and understand the real developer experience behind all this vibe coding hype.

Picking a Tool: Lovable.dev

After trying out a few AI coding tools, I eventually settled on Lovable.dev. I had already used it during an attempt to revamp my developer portfolio, a project that, unfortunately, didn’t go as planned due to how specific and unconventional my use case was.

While Lovable does bring some great features to the table, I quickly ran into a wall of limitations that made it difficult to move forward. In the end, I had to bring in Cursor to get things back on track (but that’s a whole separate story I’ll save for another time).

Lovable offers 5 free prompts a day—which I blew through in no time. So I went ahead and paid for the 100-prompt monthly plan. That’s when things got serious.

My experience with Vibe Coding

I started with a PRD generated through ChatGPT, outlined the feature set (themes, privacy toggles, recent searches, etc.), and began building the MVP. What followed was part breakthrough, part breakdown.

Here’s what stood out—from most painful to least frustrating:

1. GitHub API Integration: A Full-Time Job in Disguise

This was easily the biggest time sink. What should’ve been a simple integration turned into a multi-hour debugging session. Lovable struggled here—from showing dummy data, forming incorrect API requests, to miscalculating metrics.

I found myself knee-deep in GitHub’s documentation, manually debugging request failures, rewriting prompts like a madman, and second-guessing what the AI was even trying to do. After wasting a pile of prompts, I had no choice but to fall back on Cursor and good old-fashioned developer intuition to get things moving.

Even now, it’s not flawless—but at least it works.

Expecting an AI tool to know everything? That’s on you, not it.

2. Refactoring? More Like “Breaking Everything”

Every time I clicked “Refactor X” as suggested by cursor, it felt like playing a game of Russian roulette with my codebase. Sometimes it failed to import a dependency, other times it broke the entire build, and occasionally it introduced delightful little inconsistencies that took way too long to track down. In short—it rarely worked the way I hoped.

It gave me flashbacks to my portfolio revamp disaster, where it randomly dropped triple quotes into a JSON file (because why not?), and I wasted three or more prompts trying to untangle the mess. Spoiler: I never fixed it. I eventually gave up on the redesign and just patched the old version like it was 2010.

With my Git tool project, it happened again. I asked it to fix a single bug. Just one. Instead, it completely nuked the layout. One step forward, five steps back.

3. Code Cleanup? You Wish.

As I added more features, the codebase began to smell. Lovable doesn’t clean up unused components or apply consistent formatting unless you explicitly ask for it. It also doesn’t optimise repeated patterns unless prompted—and even then, not always correctly.

For example, on my pledge page, the content was highly repetitive, but Lovable just duplicated it instead of abstracting or consolidating. I had to intervene manually to fix the structure and reduce redundancy.

Devs write bad code. So does AI. At this point, we’re just a very inconsistent team.

4. One Prompt Is Never Enough

This one surprised me. You’d think a simple prompt—like “add theme support with a primary color scheme”—would result in a comprehensive implementation. Nope. I got a half-baked version, which required multiple follow-ups to get right.

Each incomplete fix became a waste of a prompt, especially painful when you’re on a limited plan. Vibe coding only works if you’re ready to babysit every single change.

5. Types Are Often Just… Wrong

I kept seeing stuff like Promise<any[]> used for GitHub API responses. Technically, it works—but it’s sloppy and careless. You’d expect an AI assistant to promote good practices, not encourage lazy typing that’ll bite you later.

6. Eventually, I Just Wanted to Be Aware of What’s Happening

The original plan?

Build the entire MVP using Lovable—no manual coding, just clean prompts and pure AI flow. That dream lasted until the first time something broke and I had absolutely no idea why.

That’s when it clicked: I’m not against using AI—I just need to understand what it’s doing. Sometimes, You need to read the code, follow the logic, and be able to reason through what’s changing. Because when something goes wrong (and it will), you can’t just paste an error into a chat window and expect a magical fix. That’s not development—it’s just wishful prompting.

Lovable was still great for exploration, prototyping, and quick UI scaffolding—it really shines in those areas. But when it came to critical logic, integrations, or anything with multiple moving parts, I had to step in and take control—often with Cursor by my side.

Ironically, the real productivity boost came after I stopped trying to let AI do everything. Not by vibing harder—but by staying aware, intentional, and using AI as a powerful assistant—not a replacement for thinking.