AI wrote thirty thousand lines for me I did not even know the language
After Rockpile, Spottt, and odds, a review of Vibe Coding’s real pitfalls, verification loops, and a seven-step release process.

In this signal
Evidence and limits
Vibe Coding has not eliminated engineering. It has shifted the scarcest work from code generation to verification and responsibility.
Sources
Sources
Could be wrong if
The problems may mainly reflect beginners’ lack of experience, rather than the AI development approach.
As models improve, testing and security may also become automated and may not remain bottlenecks over the long term.
Next observation
Rework, security issues, release success rates and project survival before and after adopting the process.
In my previous article, I wrote about the excitement of using AI to make my first program. 12800 lines of code, 48 hours, a little crawfish living in the notch. The subtext was: the barrier is gone; anyone can do this.
This article is the other side of that story.
After Rockpile, I went straight on to build two more programs. Spottt turns Spotify album covers into ASCII art inside a retro handheld-style desktop widget. odds lives in the menu bar, tracking Polymarket prediction-market odds in real time. Three programs, twenty days, thirty thousand lines of code, and more than 60 documented bugs.
Pure Vibe Coding, with no understanding of code, development processes, or what “done” means, will hit a wall.
Vibe Coding works. But it is no fairy tale. This is a list of pitfalls for anyone like me who got carried away by a first success and plans to vibe all the way through. At the end is a seven-step development process, also available as an open-source AI guidance skill, vibe-ship. It uses questions and answers to take you from idea to release, with no coding knowledge required.
You do not know what car you are driving
On Spottt's second day, AI and I had gone through dozens of exchanges, fixed more than ten bugs, and made 9 enclosure design concepts. The app ran, and there was a desktop widget.
Then I asked a question:

Concept illustration | Every change expands risk when the system boundary is unknown
“Was this app made with Python?”
Yes. It took two days to find out what language my own program was written in.
As soon as I learned the answer, I said: switch.
Python + PyWebView's window management on macOS was a mess. Windows kept covering other apps, full screen was not really full screen, the package was 45MB, and a rocket icon in the Dock made it look nothing like a proper app. I fixed more than ten of these problems; every fix brought two new ones.
After migrating to Tauri, Rust + WebView, the package shrank from 45MB to 5.3MB and most window-management problems disappeared. But all the earlier PyWebView debugging time was wasted.
AI does not volunteer that you are taking a detour. It executes; it is not an adviser. Say “do it” and it does it. If you do not ask, it does not tell you.
Code that runs ≠ usable ≠ done
The distances between these three stages were far greater than I expected.
It runs
The code compiles, the app launches, something moves on screen, and you think you are nearly there. You are far from it.
When Spottt's terminal version first ran, I was excited for about five minutes. Then the logo text began scrolling down the screen uncontrollably, forever. AI had forgotten the alternate screen buffer, one of the basics of terminal UI programming. More ironically, the reference project AI had told me to clone already used it, but AI had not consulted it while writing its own code.
odds had an even stranger problem. AI “generated” an IBM Plex Mono font file and put it in the project. The code compiled and the app ran, but the interface looked odd: wrong spacing, wrong weight. After a long investigation, I found it was not a real font. It was fake binary data. AI had fabricated a TTF, and the system silently fell back to the default font after loading failed.
AI can write code, but it cannot “generate” binary files. Fonts, images, and audio have to be real.
It is usable
The app runs, the features exist, and it responds to user input. Is it done?
No.
One odds bug kept me stuck for a long time: click “Follow” and nothing happened. No error, no message, no button change, no list update. Silence.
The root cause was duplicate data: an array and a set. Initialization populated the array, but not the set. The “already followed” check read the empty set and showed “+ Follow.” The add-on-click logic read the array, found the item already there, and returned. Each side was correct on its own. Together, they did nothing.
Silent failure is the scariest kind of bug. Users think the product is broken, but the logs are clean. You do not even know what information to paste for AI.
It is done
Mistaking finished code for a finished product was the deepest pit I fell into.
To distribute a macOS app, you need Code Signing, Apple Notarization, DMG packaging, Hardened Runtime, and a stapled ticket. I had heard none of these terms before doing it.
There is a more basic issue too: an `.app` bundle does not inherit shell environment variables. The API key you set in the terminal cannot be read after packaging. I hit this in Spottt's Python version, then hit it again after migrating to Tauri. Exactly the same bug, in two different stacks.
Rockpile was funnier: I completed Apple notarization on Day 2. Looking back, it was entirely unnecessary. There was not one user yet. Who was the notarization for?
odds had version numbers scattered across five files, with five different numbers: CHANGELOG said v0.2.1, README said v0.1.0, Settings said v0.2.2, onboarding said v0.1.2, and there was not a single Git tag. Someone asked what the latest version was. I could not answer.
Code that runs is only halfway there.
Design is the sweetest trap
Across the three projects, the time I wasted on design may have exceeded a third of all development time.
Spottt went through 9 enclosure concepts: Walkman, Tamagotchi, Discman, Teenage Engineering. Each change of direction discarded the previous work. After all 9, the chosen concept turned into something completely different during implementation anyway.
odds went further: HTML previews of 11 design directions, 3 rounds of logo exploration, shader-style icons, and a design voting page. In total, 21 HTML design drafts. Most went unused.
What went wrong? Say “another direction” and it makes one. Say “try retro” and it makes retro. Nobody stops you.
Rockpile's sprites were the same. I tried 5 styles: pixel, flat, 3D, hand-drawn, and vector. For each, I asked AI to generate the full 30 sets. I eventually chose Pixar 3D and threw away the other 4 sets, totaling 120 sprite images.
Making just one or two samples per style to settle the direction first could have saved 80% of the design time.
Rewriting the repository
This was the most nerve-racking day of the whole process.
A full code review of Rockpile found a real Gateway Token hard-coded into a test script. Right there in source code, in a public repository, where anyone could use it to connect to my server. I had put in a default for convenient debugging and completely forgotten to check before pushing to GitHub. When AI generated that code, it did not warn me that the token should not be in the source.

Concept illustration | Rebuilding cannot replace architectural understanding and security review
Fixing it was ten times harder than writing the code. Editing the current file was not enough. Git has history: delete the line, and anyone can still find the token in an earlier commit. I had to use `git-filter-repo` to purge the entire Git history, then force push over the remote. The repository's history was rewritten.
The same review found more: a TCP Socket listening on every network interface, allowing any device on the same WiFi to send forged events; JSON made by string concatenation rather than a serialization library, creating an injection vulnerability; an API Key in a plaintext UserDefaults plist, instead of Keychain; and no size limit on HTTP request bodies, allowing DoS.
These are common knowledge for professional developers. Pure Vibe Coders do not even know the risks exist. AI's code can have security holes you cannot see at all.
By the time I made odds, I had learned a little. Before pushing, I asked AI to scan for secrets, personal email addresses, and local computer paths in the code. But I only knew to do that because I had already fallen into the pit.
Remember this: before every GitHub push, ask AI to search for things that should not be public. If you already pushed them, deleting files is not enough. Git remembers the whole history; you have to clean the history too.
You will fall into the same pit twice
After Spottt was packaged, it crashed immediately. Configuration that worked in development could not be read in the packaged app. I fixed it, changed stacks, and hit the same issue again.
AI has no memory. Every new conversation and context starts fresh. Unless you remember your past pitfalls and warn it in advance, it will take you through them again.
Rockpile had similar problems. The crawfish had an “exhausted, belly-up” state. Once triggered, it stayed flipped forever, even after AI resumed normal work, because AI had forgotten the recovery logic. After a project rename, several references still used the old name; the mismatch broke the connection. Someone who cannot read code cannot foresee this kind of “renamed it, forgot the references” error.
I eventually started a pitfalls document, adding a note whenever a problem came up and pasting it for AI when starting the next project.
AI does not say “no”
Looking back over three projects, the biggest waste of time was not bugs, but building features I should never have built.
All three projects got three-language support. odds got a scrolling ticker and terminal startup animation. Rockpile integrated five AI providers at once. At the time, each addition seemed nice to have. Looking back, there were no Japanese users for the three-language support, the ticker duplicated the main list, most providers were unnecessary, and users would see the startup animation once, with no skip button.
Why did I build them? AI was too agreeable. Say “add Japanese,” it does. Say “make a startup animation,” it does. It never asks whether you really need it.
Every afterthought looks free because AI can implement it in minutes. Maintenance is not free. Three languages mean changing every interface string three times. Five providers mean adapting every new feature five times.
During an odds team review, the virtual CEO said something I still remember:
"有三种语言但在那些市场没有分发渠道,也没有需求证据。这是伪装成完整性的 scope creep。"
Later, I formed a habit: before adding a feature, ask myself whether the product still works without it. If it does, leave it for now.
Closing thoughts
I ended the previous article by saying the barrier between ideas and products was gone.
I still agree, with a footnote.
The barrier is gone, but there are pits in the ground. Without understanding development processes, you can waste days on the wrong stack. Without knowing the differences in code, you may not even know your program's language. Without understanding “done,” you can get stuck in the last mile of signing, packaging, and releasing after the code runs. Skip security checks, and your API key may end up in a public GitHub repository.
You do not need to learn to code. I still cannot write a line. But you do need to know what your program is built with, how far “runs” is from “releasable,” what to check before pushing to GitHub, and which features to build or cut.
This is not programming knowledge. It is product common sense.
Vibe Coding shifts what you need to know from how to write code to how to make a product. Technical ability used to block you. Now it is judgment. That is progress.
But if you think opening AI and saying a few words will carry you all the way to release, you will personally encounter every pit in this article.
Finally: a development process for pure Vibe Coders
After all these pitfalls, I put a process together for myself. Nothing profound, just the order of what to do first and next. Following it from my first project would probably have saved half the time.

Concept illustration | Reliable delivery comes from staged verification, not one-shot generation
Step one: think before asking
Do not open AI and immediately say, “Build me an XXX.” Spend ten minutes on three questions: who is this for, what is the one core feature, and what existing product is closest to it? Write down the answers before you begin.
Step two: ask about the stack
Tell AI what you want to make, then ask: “What is the most suitable technical approach? Why? What alternatives are there, and what are their strengths and weaknesses?” Make it explain in terms you understand. If you do not understand, keep asking. Ten minutes here can save days.
Step three: get the smallest version running
Build only the core function. No design, languages, animations, or nice-to-haves. Aim for the ugliest version with a working core. When it runs, save a screenshot: this is v0.1. Once it runs, I recommend asking AI for a code review to check for hidden problems.
Step four: release, including a security scan
Many people skip this and panic on the last day. First ask AI for a security check: no secrets, passwords, personal emails, local paths, or other information that should not be public. After it passes, ask: “What must be done to distribute this program?” List the steps and try them once. The earlier you make this path work, the calmer the rest will be.
Step five: now you can design
The core is stable, the release path works, and the security check has passed. Now is the time for design. Give AI two or three reference images you like, settle on one direction, and make no more than three concepts. Pick one and carry it through.
Step six: ask yourself before adding features
Before adding something, ask: “Would the product still work without this?” If yes, put it on a “later” list. Return to that list after polishing the core experience, choosing at most three items at a time.
Step seven: record everything
Note problems as they arise. A sentence such as “cannot read configuration after packaging” is enough. Paste the document for AI at the start of the next project. It will not remember by itself, but you can remember for it.
None of these seven steps requires you to code. Following this order can keep you out of most of the pits I fell into.
I turned this process into vibe-ship, an open-source AI development guidance skill. It walks you through the entire process via questions and answers, and anyone can install and use it.
Rockpile: github.com/ar-gen-tin/rockpile
Spottt: github.com/ar-gen-tin/spottt
odds: github.com/ar-gen-tin/odds
Don't Panic. Accelerate.
OpenAI Codex
Let an AI coding agent inspect a project, explain it, and make a small reversible change.