Vibe Coding: I Built 3 Internal Tools Without Writing a Single Line Myself

The Hype vs. The Reality

You've probably seen the tweets: developers building entire apps in hours using nothing but prompts. AI-generated code pouring out of Cursor. Complex UIs materializing from v0.dev. The promise of "vibe coding"—where you describe what you want and AI handles the implementation.

I decided to test this with three internal tools I'd been putting off building. Not client work. Not production apps. Just internal utilities where I could afford to experiment and learn. Here's what actually happened when I stopped writing code and started vibing.

What is Vibe Coding?

"Vibe coding" is the latest term for describing what you want in natural language and letting AI tools generate the implementation. Instead of writing code, you're having conversations about code. Instead of debugging syntax errors, you're refining prompts.

The theory is compelling: describe the vibe of what you need, and AI handles the tedious implementation details. Focus on product thinking, not semicolons.

I used three main tools:

• Cursor: AI-powered code editor with context-aware code generation
• v0.dev: Vercel's UI component generator from text prompts
• ChatGPT: For planning, architecture decisions, and debugging help

Tool 1: Client Invoice Generator

What I needed: A simple tool to generate professional PDF invoices from project data. I had a spreadsheet workflow that was clunky and error-prone.

How I approached it: Started with ChatGPT to outline the architecture, then used Cursor to generate the React components and invoice logic.

Initial prompt to Cursor: "Build a React component that takes project details (client name, line items with descriptions and amounts, dates) and generates a PDF invoice with my company logo and branding."

What worked:

• First iteration gave me a working React component in under 2 minutes
• The PDF generation library suggestion (react-pdf) was sensible
• Basic styling and layout were surprisingly good
• Edge cases like tax calculations were handled correctly

What failed spectacularly:

• The AI assumed I had my logo already imported (I didn't)
• PDF rendering broke completely on Safari (worked fine in Chrome)
• Typography looked professional in the code editor, terrible in the actual PDF
• No input validation whatsoever—crashed if you left fields empty

Time breakdown:

• AI generation: 15 minutes across multiple iterations
• Fixing Safari rendering issues: 3 hours (I had to actually read react-pdf docs)
• Tweaking typography until it looked professional: 2 hours
• Adding proper validation and error handling: 1 hour

Verdict: Saved me probably 4-5 hours compared to building from scratch. But those 6 hours of fixes and polish were tedious work the AI couldn't help with.

Tool 2: Meeting Notes Summarizer

What I needed: A dashboard that pulls in my client meeting recordings (I use Loom), transcribes them, and generates action items.

How I approached it: Used v0.dev to generate the UI components, ChatGPT for the transcription API integration logic, then Cursor to assemble it all.

Initial prompt to v0.dev: "Create a dashboard showing a list of video recordings with thumbnails. Each item should have a 'Summarize' button. When clicked, show a loading state then display bullet points of action items."

What worked:

• v0.dev nailed the UI on the first try—looked polished and modern
• The skeleton loading states were a nice touch I wouldn't have bothered with
• Component structure was clean and well-organized

What failed spectacularly:

• The AI made up a fictional API endpoint for transcription
• No error handling for failed API calls
• No authentication check (anyone could access it)
• The "action items" extraction was supposed to use GPT-4 but the prompt was terrible—got back generic summaries instead of actual tasks
• No database—refreshing the page lost all summaries

Time breakdown:

• AI generation: 20 minutes
• Integrating real transcription API (AssemblyAI): 2 hours
• Writing a proper GPT prompt to extract action items: 1.5 hours (this took way longer than expected)
• Adding authentication: 1 hour
• Adding persistence (Vercel KV): 2 hours
• Actually making it production-ready: 3 hours

Verdict: The UI generation saved me time. Everything else took longer than if I'd just written it myself because I had to reverse-engineer what the AI was trying to do, then fix it.

Tool 3: Dependency Update Checker

What I needed: A script that checks all my repos for outdated dependencies and creates a weekly summary.

How I approached it: Pure ChatGPT for this one—asked it to write a Node.js script.

Initial prompt: "Write a Node.js script that: 1) Connects to GitHub API, 2) Finds all my repositories, 3) Checks package.json for outdated dependencies using npm, 4) Generates a markdown report of what needs updating."

What worked:

• The overall structure was solid
• GitHub API integration code was correct
• Markdown report formatting was clean

What failed spectacularly:

• The script tried to clone every repository (I have 20+). Killed my disk space
• Assumed npm was installed globally in the path it tried to use
• No rate limiting for GitHub API—got throttled immediately
• Tried to run npm outdated on repos that don't use npm (some use pnpm, some Yarn)
• Error handling was basically console.log("error")

Time breakdown:

• AI generation: 5 minutes
• Actually getting it to run without crashing: 4 hours
• Making it handle different package managers: 2 hours
• Adding GitHub API rate limiting: 1 hour
• Fixing the disk space issues (switched to API-only checks): 2 hours

Verdict: This one actually took longer than building from scratch. We spent more time debugging the AI's assumptions than we would have spent just writing a focused script ourselves.

The Hidden Costs

Here's what nobody tells you about vibe coding:

1. Review Time is Brutal

You have to read every line the AI generates. You can't just trust it. I found:

• Security issues (hardcoded secrets, no input validation)
• Performance problems (unnecessary re-renders, inefficient queries)
• Accessibility failures (missing ARIA labels, poor keyboard navigation)
• Logic bugs that would ship to production

Reading AI code is slower than writing it yourself because you're constantly thinking "would I have done it this way?"

2. The Context Window Problem

AI tools lose context fast. After 5-6 iterations of refinement, Cursor would suggest changes that conflicted with earlier decisions. I'd have to manually paste in previous code to remind it what I was doing.

3. Debugging AI Code is Weird

When something breaks, you can't just trace through the logic because you didn't write it. You have to reverse-engineer the AI's assumptions first. Why did it choose this library? Why this pattern? Often the answer is "because it's common in training data," not "because it's right for this use case."

4. Documentation Doesn't Exist

I didn't write these tools, so I didn't document them. Six weeks later, trying to modify the invoice generator, I had to re-prompt the AI to understand what it built. My own tools became black boxes.

What I Learned

Vibe coding works best for:

• Boilerplate and scaffolding (React components, API routes, database schemas)
• UI components where you can visually verify the output
• Well-understood patterns (CRUD operations, authentication flows)
• Prototypes and throwaway code

Vibe coding struggles with:

• Business logic specific to your domain
• Performance-critical code
• Security-sensitive features
• Anything that needs to integrate with your existing systems

My new workflow:

1. Use AI to generate initial scaffolding and boilerplate
2. Immediately review and refactor before building on top
3. Write custom business logic myself
4. Use AI for tedious bits (type definitions, test cases, error handling)
5. Document everything as if I wrote it myself

The Real Productivity Question

Did I save time? On the invoice generator, yes. On the meeting notes tool, marginally. On the dependency checker, absolutely not.

But here's the thing: I learned a ton about what these tools can and can't do. That knowledge is valuable for client work, where I can't afford to experiment.

Would I do it again? Yes, but with different expectations. Vibe coding isn't "build production apps without coding." It's "get a faster first draft that still needs real engineering."

The tweet screenshots of apps built in 30 minutes aren't lying. They just don't show the 6 hours of fixes afterward.

The Bottom Line

AI coding tools are genuinely useful. Cursor catches bugs I'd miss. v0.dev generates UIs faster than I could. ChatGPT is great for rubber-duck debugging.

But they're tools, not replacements. The actual engineering—understanding requirements, making architecture decisions, handling edge cases, ensuring security—still requires humans who know what they're doing.

The productivity gains are real but modest. Maybe 20-30% faster for straightforward features. Not the 10x improvement the hype promises.

Planning to experiment with AI coding tools? I've spent hundreds of hours testing these workflows on real projects. If you want to skip the expensive learning curve, get in touch and I'll share what actually works.

For more on my development process, check out my thoughts on bespoke web development and how I approach building custom tools for clients.