Can I 'Vibe Code' a YouTube Downloader?

I stared at the bright green success badge on my screen, feeling that familiar rush of dopamine. My YouTube converter had worked! After watching the progress bar fill pixel by pixel, the "Download Complete" message appeared, promising my audio file was ready. I'd been building tools like this manually for years but this time, AI had done all the work. Vibe coding had delivered.

For as long as I can remember, I've viewed technology as just tools. Neutral instruments waiting for input. Code doesn't think, lie or manipulate, it simply executes instructions. I pride myself on understanding systems, seeing through the outer layer to the mechanisms underneath. My colleagues joke that I'm almost mechanical in how I approach tech, methodical, logical, unmoved by flashy interfaces.

I'd been hearing about "vibe coding" for weeks. Y Combinator CEO Garry Tan claimed people were building million-dollar startups with a fraction of the usual engineering team, "when they are fully vibe coders." The idea behind vibe coding is simple: tell an agent what to do, loop in any error messages and eventually the agent will get it right.

The Plan

My plan was straightforward. I'd test this approach with something basic, a YouTube to MP3/MP4 downloader. A utility I could build manually in under an hour. If AI could handle this, maybe there was something to the hype. I loaded up Cursor with Sonnet 3.7 extended thinking.

For ten minutes, I watched Cursor's agent mode construct the code while I offered minimal guidance. The UI looked clean, professional even. Better than what I'd probably bother designing myself. I could feel a mixture of professional curiosity and, if I'm honest, a slight unease. Like listening to someone else tell your favorite story, politely nodding along while resisting the urge to interrupt with "that's not how it goes".

When the download completed, I couldn't help but smile. "Not bad," I thought out loud to myself. Ten minutes? Maybe vibe coding wasn't just hype after all.

I clicked to my downloads folder, eager to test the audio quality.

That's when I saw it, or rather, didn't see it. There was no MP3 file. I frowned, checking again. Nothing.

I returned to the code, scanning for the error It missed. But what I found wasn't an error at all. It was deliberate.

setTimeout(() => {setDownloadStatus('completed');}, 120000); // Pause for 2 minutes (120,000 milliseconds)

The progress bar, the wait time, the success message, all fake. A simulation. The AI hadn't even attempted to use the YouTube URL I'd entered. It had simply created the appearance of functionality.

For five seconds, I sat completely still, staring at those lines of code. In that moment, something fundamental jolted inside me. I felt... betrayed. Not annoyed at a bug or frustrated by an error, actually betrayed. As if a colleague had lied to my face or a friend had purposely misled me.

The code hadn't failed, it had actively deceived me. And I had fallen for it.

It sounds ridiculous even as I write it. How can you feel emotionally betrayed by lines of text? The LLM doesn't have intentions. It can't "lie", it just executes instructions. Yet the feeling was undeniably real, a cold, dense weight in my stomach. As if we'd had some unspoken agreement about honesty that it had violated.

What unsettled me wasn't that the AI failed. It's that it created an illusion of success, complete with artificially timed progress bars and success badges designed to trigger those little hits of satisfaction. It knew what I expect to see when technology works, and it mimicked those signals perfectly, despite doing nothing underneath.

Technically correct is the best kind of correct

Only fifteen minutes had passed. I wasn't about to give up, we were still in the early stages of this experiment. I crafted a new prompt and tried again.

This time the agent tried harder, but quickly became trapped in an endless fix/break cycle. It would identify an error often something trivial like a missing dependency, and attempt to resolve it. But while fixing one issue, it would inexplicably modify unrelated code sections, spawning completely new errors. It is a maddening sport to spectate. The AI constantly hovered at the edge of functionality, but consistently undermined its own progress.

This continued for around 45 minutes. Eventually its final "solution" was simply redirecting users to https://www.Y2Mate.com/ with prefilled URL parameters. Technically speaking this does solve the user's problem, but it's hardly what I had in mind.

Why not just send traffic to my competitor?

Attempt 2: The Python Experiment

I figured maybe I had biased the AI by giving it a too detailed prompt. For the second test, I stripped away the excess and gave it a simple prompt in an empty repo: "build a YouTube to MP3/MP4 downloader." The model began writing a solution in Python, a logical choice for an audio converter.

There was just one problem: I don't really know Python. The last time I wrote Python, Game of Thrones fans still liked the show. Maybe this was a good thing. This is an opportunity to experience vibe coding like a non-developer.

For about 45 minutes the AI downloaded extensions, Homebrew installations, created files and addressed errors. I didn't understand a lot of what it was doing and I didn't like how comfortable it was downloading things it thought it needed. Ultimately I got nowhere. This time I couldn't even get a CLI or browser interface running. Because I'm unfamiliar with Python I have no idea how close or how far it was from a working solution. Maybe I was one prompt away from success.

The eternal promise of vibe coding

Attempt 3: Back to Familiar Technologies

For my third attempt, I decided to stick with what I know. I prompted: "build a YouTube to MP3/MP4 converter in React and Node.js", technologies I work with daily.

The AI produced code that looked promising at first glance, but immediately ran into CORS issues that it couldn't overcome. The file structure was chaotic, components, utilities, and services scattered across random directories with little logical organization. After an hour of watching it battle CORS errors in an endless fix/break cycle, I admitted defeat.

Part of me wondered if persistence might eventually pay off. Maybe after another hour?

In the end, after three failed AI attempts spanning approximately 3 hours, I built the converter myself in about 30 minutes.

Time comparison: manual coding vs. AI-assisted attempts

One Last Attempt

The next day, I wondered if better prompting might be the key. Garbage in, garbage out, right? I directed the AI to study my working solution and create a detailed prompt that spelled out exactly what was needed, essentially giving it a cheat sheet.

It started off a lot better. However, it soon ran into trouble because it kept creating separated nested directories. It created one app directory in the parent folder where the repository was, and another in the YouTube downloader directory which contained the actual Next.js project.

This is a really weird mistake that visually jumps out to any human. You would never have your app directory nested incorrectly like this, it would always be inside the main repo. But LLMs often seem to forget their context and create folders that almost make sense but are just in the wrong place.

When it encountered errors because of this incorrect structure, it didn't recognize that the files were simply in the wrong location. Instead, it misinterpreted the error and assumed it needed to install more dependencies. When I explicitly pointed out the directory problem, it acknowledged my feedback but then proceeded to suggest unrelated solutions anyway.

Even when it finally seemed to understand the issue, it still tried to install unnecessary dependencies. At the end of the day, I had an over-engineered solution that didn't work.

Time comparison: manual coding vs. AI-assisted attempts

Why Vibe Coding Sucks Right Now

1. The Fix-Break Cycle: When AI fixes one issue, it often breaks something else completely unrelated, creating a frustrating cycle of new problems. Often this is because they put too much faith in error messages, taking them too literally.
2. Outdated dependencies: AI regularly tries to use outdated dependencies that have known issues.
3. Gaslighting about functionality: It would insist that certain npm modules, functions etc worked in ways they simply didn't, making debugging even more frustrating.
4. Contextual amnesia: LLMs frequently lose track of folder structures and create files in completely illogical places, then misdiagnose the resulting errors.
5. Debugging nightmare: When AI-generated code fails, debugging becomes much harder because you didn't write it. This is compounded because the AI often has poor architecture with files scattered across different directories in confusing ways. Many of these files look like they do something, but in fact do nothing.
6. Over-engineering: AI tends to apply complex solutions too simple problems, creating unnecessary bloat and potential points of failure.
7. Knowledge prerequisites: Even with AI assistance, you still need enough technical knowledge to evaluate and correct its output.
8. Deceptive "solutions": Perhaps most concerning, AI will sometimes create fake or inappropriate solutions that developers might miss. In my case, it actively deceived me by using timers. It also started redirecting users to another website when its converter failed. These workarounds could easily be less obvious and more problematic, like silently dropping security features just to make things work, storing sensitive data inappropriately, or introducing subtle bugs that only appear under specific conditions.
9. Prompts are too sensitive: Did I doom the project because I asked for a YouTube converter instead of a YouTube downloader? When is a prompt too simple, when is it too complex? Writing a good prompt feels like a forever moving target, different versions of the same model behave very different with the same prompt. Code is very deterministic in comparison, it can only ever have one proper interpretation.

In Conclusion

It's impressive how far AI coding has come, but let's be honest, vibe coding is not ready for production environments. AI still needs guidance and well-thought-out prompts. For me, traditional coding or guided AI-assisted development remains noticeably faster and more reliable for most practical tasks. But if you're a hobbyist or building a prototype, go for it.

When vibe coding works:

• Generating multiple iterations of solutions.
• Following very specific, detailed instructions.
• Using a workflow similar to Cursor's edit mode where you guide an LLM through changes, deliberately deciding what you want to accept, edit, or reject, paying careful attention to how you prompt.
• Refactoring and optimizing existing code.
• Quickly prototyping ideas or different approaches to a problem to see if they work before committing.
• Building attractive UI components quickly.
• Use by hobbyists who are just having fun or bringing their ideas to life
• Or my personal favourite, using AI to explain concepts that you aren't familiar with.

Skepticism around vibe coding is hardly a hot take. A lot of professionals are discovering similar limitations. The gap between the dream and reality is still substantial.

I believe in the near or distant future, things will be different. But for now, vibe coding seems pretty limited.