One Month of Vibe Coding: Lessons Learned from Building Real Projects with Zero Coding Experience

Andrej Karpathy predicted in 2023 that "the hottest programming language of the future is natural language" — a vision that gave rise to the concept of Vibe Coding, where humans describe what they want in plain language and AI handles the code and execution. It sounds like a golden opportunity for non-technical users, and an existential threat to developers.

But what's the reality? One creator with zero software development experience spent an entire month using OpenAI's coding agent Codex to build two real projects — without writing a single line of code. His conclusion: you really don't have to write code anymore, but the pitfalls run far deeper than you'd expect.

Why Use a Coding Agent Instead of a Chat AI

Many people's first instinct when trying Vibe Coding is to use ChatGPT or DeepSeek as a development assistant. But coding agents like Codex are fundamentally different from chat AIs. Codex can directly invoke programming tools and languages on your local machine, autonomously handling everything from writing code to running it.

With a chat AI, you become the "messenger" between your local machine and the AI — constantly copying and pasting, reporting results. Worse, humans inevitably compress or distort details when relaying information, making the whole development process clunky and inefficient.

Of course, choosing Codex comes at a cost. A Plus account at around $20/month is barely enough for any meaningful real-world project — you'll need to upgrade to the Pro tier at roughly $100/month. The very first thing you feel with Vibe Coding is: it's expensive.

Two Real Projects Built with Vibe Coding

Project One: Obsidian Math Notes PDF Export Tool

The first project came from a genuine need: exporting Obsidian notes — packed with mathematical formulas and SVG/PNG illustrations — into a polished PDF. The workflow was straightforward: describe the requirements to Codex in plain language, let it create the code and interface, test it, ask for changes if unsatisfied, and iterate. About 20 rounds of iteration later, it was done.

The final product looked great: table of contents, body styles, image layout — all on point. It even included a Windows installer wizard. The whole process went smoothly, giving the author a huge confidence boost.

But as it turned out, that smoothness was the biggest trap of all.

Project Two: Automated Livestream Clip Generator

The second project was far more complex. The goal: take a 2–3 hour livestream recording and automatically complete the entire pipeline:

• Extract subtitles and correct typos
• Format the transcript and auto-save it to an Obsidian notebook
• Intelligently select 2–3 highlight clips (requiring AI to understand content and identify key moments)
• Compress clips by removing filler words and pauses
• Burn subtitles into the video
• Fully automated, no human intervention required

The project did eventually get built. After testing it on dozens of livestreams, all outputs met the requirements. But the development process was brutal — the author documented "a complete mental breakdown" across dozens of hours in posts on Bilibili.

The Biggest Vibe Coding Trap: Thinking Requirements Are Enough

After making countless mistakes and talking with experienced developers, the author arrived at a core insight: don't mistake Vibe Coding for a simple "describe → test → done" loop. It's nowhere near that simple.

The root cause lies in several inherent properties of large language models:

1. AI output is non-deterministic. Even when your skill document explicitly states rules — "don't touch this file," "must use this format" — the agent may not follow them. Unlike a traditional Python script that executes step by step, it "selectively executes."

2. Errors compound over time. Because LLMs predict token by token, if a mistake occurs mid-process and isn't caught immediately, subsequent reasoning amplifies the error until the output drifts far from the goal.

3. Natural language has gray areas. Humans leave a lot unsaid when describing requirements. For example, "generate subtitle styles based on this template" — the AI's interpretation may vary every time, resulting in ten different subtitle styles across ten livestreams.

Three Hard-Won Lessons from Vibe Coding

Lesson One: You Must Be Deeply Involved in the Entire Development Process

Even if you're not writing code, you need to know:

• Which scripts and tools the agent calls at each step
• What parameters each script accepts and what format it outputs
• How to detect failures and pinpoint the source of problems
• How each script actually works (otherwise the agent might "claim it's done while actually lying")

Wherever you're unclear on a detail, that's exactly where the agent is likely to go wrong. If you don't understand how something works, you can't design a proper acceptance check for it.

Lesson Two: Use Hard Acceptance Checks to Validate AI Output

This was the turning point that finally stabilized the project's quality.

The author had wasted enormous amounts of time dealing with inconsistent outputs and minor errors — the root cause being the absence of hard acceptance criteria. For example, the livestream summary articles: early on, the agent produced a different format every time, and sometimes wrote just three to five sentences while claiming it had "summarized all the content."

The solution was to build multi-layered hard acceptance gates:

• Article gate: Force-check whether the article contains required sections and whether each section meets a minimum character count
• Subtitle style gate: Verify that subtitle formatting matches the template
• Output file manifest gate: Check that all expected output files are present
• Video compression gate: Prevent the agent from cutting corners
• Archive format gate: Verify that filenames and directory structure meet the standard

If any check fails, the program returns a failure status and the agent must identify the cause and re-execute. You can't let the AI declare "I succeeded" — there must be a hard verification routine that makes the call.

Lesson Three: Manage Skill Documents in Layers

As more issues were discovered, the skill document ballooned from an initial 30 lines to hundreds of lines and tens of thousands of tokens. But an overly long skill document actually degrades agent performance — the longer the context, the more diffuse the attention.

The solution was a layered architecture: the main skill file (skill.md) contains only the core workflow and rules, while branching details, error-handling procedures, and instructions for calling check scripts live in a references directory and are loaded on demand.

More critically, the author established a dual-copy system:

• Machine execution version: Clean and minimal — only commands and execution rules, no comments
• Human-readable version: Maintained in Obsidian, documenting the rationale behind each rule, dependencies between rules, and global consistency notes

The reason: current AI lacks a "world model." When you modify rule #10, it won't realize that contradicts rule #134. Local optimization can cause global degradation — and humans are uniquely good at maintaining that kind of global coherence.

The Real Takeaway: How the Human Role Transforms

AI has genuinely made "writing code" easy — a natural language prompt can quickly become a script, function, or small tool. But real software development is far more than writing code: Is the requirement clearly defined? Is the system context properly understood? Who handles long-term maintenance?

The gap between "it runs" and "it runs reliably" is where the core value of engineering lives.

The more powerful AI becomes, the lower the cost of local implementation — and the more an engineer's value shifts upstream. The truly scarce skills are:

• Breaking down vague requirements into clear modules and interfaces
• Deciding what to decouple and which output formats must be fixed
• Ensuring deliverables are usable, reproducible, and debuggable
• Identifying where systemic risks are hiding

AI excels at producing impressive-looking results in isolated steps, but it struggles to judge whether the requirement itself is correct, whether an interface is suitable for long-term maintenance, or where the systemic risks of a given approach lie. Vibe Coding doesn't remove humans from development — it transforms humans from code-writing executors into system architects and quality gatekeepers.