I cannot code I used AI to build my first program
With no development background, an ordinary person used Claude Code to build Rockpile in 48 hours—a native macOS app that passed Apple notarization.

In this signal
- 1. Two thoughts collide: where the idea came from
- 2. The first command: from a black terminal to a red crawfish
- 3. What Vibe Coding actually feels like: managing a product
- 4. The pitfalls: Vibe Coding is no fairy tale
- 5. Runaway evolution: from one crawfish to an ecosystem
- 6. The last mile: actually being “done”
- 7. What I thought about afterward
- 8. A model to take away
Evidence and limits
The most important change in AI programming is that people previously excluded from software production are beginning to deliver working products, rather than simply writing code faster.
Sources
Sources
Could be wrong if
This may be an exceptional result achieved by a highly committed individual. Ordinary users may find the result difficult to reproduce.
A first release may be feasible, while long-term maintenance still requires traditional engineering skills.
Next observation
Completion rates among beginners, time to release, security defects and survival after six months.
I cannot code. I do not know Swift, nor can I tell front-end from back-end development. Before starting this project, I did not even have a GitHub account. To me, the terminal was just a black window. The only command I knew was cd, and AI had taught me that. My day job has nothing to do with programming, but my interest in AI had led me to use Claude Code for all sorts of chores over the past six months. I was a heavy user.
Then, in two days, I built a native macOS app with 12800 lines of code.
Rockpile is open source: GitHub - Rockpile
This article records how an ordinary person with no development knowledge used AI to turn an absurd idea into a product that could actually be installed and distributed.
1. Two thoughts collide: where the idea came from
Products begin when two unrelated things collide.
One was Notchi, which I came across online. Someone had built a Claude Code status monitor into the notch area. That got me thinking: this part of the screen can actually be used.
The other was my own setup. Claude Code ran on my MacBook, while a little crawfish, OpenClaw, lived on my Mac Mini. Both were consuming tokens, but the information was scattered. I wanted to bring every AI's status into one place and express it through a living creature with emotions: busy when working, waiting when a reply was needed, angry on errors, and belly-up when tokens ran out.
In the past, this idea would have died in my notes. Guaranteed.
Here is a slightly embarrassing admission: my ambitions have always outpaced my abilities. My head is packed with ideas, but whenever I try to make them real, things I cannot do get in the way: an unfamiliar framework, an API I cannot connect, an environment I cannot configure, a compiler error I cannot understand. The enthusiasm drains away, and the idea quietly rots on line 47 of my notes.
This time, I opened Claude Code.
An experienced developer hearing the idea would probably list the technical challenges: macOS window management, special rendering around the notch, a sprite animation system, Socket communication protocols… and then tell you it would take at least a few months.
But I knew none of that. Not knowing how hard something is can be the best reason to begin.
2. The first command: from a black terminal to a red crawfish
I opened Claude Code and typed one sentence:
“I want to build a macOS app: a little pixel crawfish living in the MacBook notch, moving in response to the AI's working status.”
Claude did not say, “That is hard,” or, “Go learn Swift first.” It got straight to work.
It generated project.yml, created the project with XcodeGen, and wrote the first SwiftUI view to place a static pixel crawfish in the notch area. Following Claude's instructions, I typed compilation commands into the terminal. Then I saw it.
A little red crawfish stood quietly beneath the notch. It was around ten at night.
The feeling was strange. It was not achievement; I had not written the code. It was an unfamiliar sense of dislocation: I had just done something I understood nothing about, and it had really happened. A crawfish was looking at me from the screen, and I could not even explain how it had appeared.
At that moment, I realized something: the gulf that had always separated an idea from a product had been bridged.
3. What Vibe Coding actually feels like: managing a product
What followed looked nothing like traditional programming. I wrote requirements, not code. Put simply, I chatted with AI.
“The crawfish just stands there now. I want it to move, with different animations: waving its claws while thinking, scurrying around while working, leisurely blowing bubbles while idle.”
Claude modified CrawfishSpriteView.swift and added a sprite-sheet animation system.
“Underwater, there should be swaying seaweed, bubbles rising from the bottom, and light filtering down from the surface.”
Claude drew the whole underwater scene using Canvas and TimelineView: the seaweed's sway, the bubbles' sizes and speeds, the angles of the light. It wrote all of it.
“Can AI token consumption be shown like a health bar in a game? Think oxygen tank: green when full, flashing red when nearly empty, K.O. at zero.”
That became the O₂ oxygen-tank system: a Street Fighter-style Pixel Health Bar, shifting from green to yellow to red to a flashing K.O.
There was a counterintuitive discovery here: people who do not understand technology dare to ask for bolder things.
A developer would censor themselves: “That animation is too complicated,” or, “I cannot handle that communication protocol.” Someone who does not know development will not. If you do not know what counts as complicated, you dare to ask for anything. Whether it is complicated is AI's problem.
4. The pitfalls: Vibe Coding is no fairy tale
If you think Vibe Coding is one smooth conversation from start to finish, that is far too optimistic.
The real test is not “how to write code,” but “what to do when there is a bug.”
The first maddening problem was Socket communication. The crawfish needed status events from Claude Code, but large packets kept getting truncated. Once I described the symptoms, Claude diagnosed a receive timeout of 100ms as too short, changed it to 5 seconds, and added exact reads using Content-Length.
More often, though, the symptoms were “the crawfish suddenly stopped moving” or “the app crashed.” I did not even know how to describe the problem. That taught me something: paste the logs for AI to read. Terminal errors, Xcode crash logs, console output: you do not need to understand them, just copy and paste.
Once, the crawfish's timer kept running in the background after a session ended, and the app grew slower with use. I did not even know the term “memory leak.” I told Claude, “It gets slower after a while.” It investigated, found that sleepTimer in SessionData was not being cleaned up, and added a cleanup() method.
Those problems taught me this: the central skill in Vibe Coding is describing a problem. You do not need to know its cause, but you must say clearly what happened: which action triggered it, when it appeared, and exactly what it looked like. That has nothing to do with programming. Observation and expression are enough.
5. Runaway evolution: from one crawfish to an ecosystem
How did the development gradually get “out of control”?
It started with one crawfish. Then I thought: there is AI running on the Mac Mini too. Could the MacBook show the remote status? That became remote mode, allowing the two machines to pair.
Then: could I send instructions directly from my MacBook to the remote Agent? That became two-way communication. Expanding the notch revealed an input field at the bottom. Type in it, and you could control the AI on the other machine.
Then: one crawfish looks lonely. Could I keep another creature? That became a two-creature system: a hermit crab tracked local AI; the crawfish tracked remote AI. They swam separately in the same tank, sometimes bumping apart, chasing in circles, or fist-bumping with their claws. The first time I saw them collide and bounce away on their own, I laughed aloud. Three in the morning, grinning at two pixel creatures in a notch.
Later, I thought: supporting only Chinese would be a shame. That became a three-language system: Chinese, English, and Japanese, switchable at runtime.
Claude implemented every one of these afterthoughts. From v0.1 to v2.0.5, we iterated through 7 versions in two days. On the second afternoon, I looked at the line count and got a shock: a few hundred lines had swollen to 12800.
Looking back at that growth, something stands out: the marginal cost of each new feature was almost zero. My only work was deciding what I wanted and finding words to explain it clearly to AI. As the cost of implementation approaches zero, ideas themselves become the only scarce resource.
6. The last mile: actually being “done”
Finished code does not mean a finished product. I had not expected this step at all.

Concept illustration | Running is only the start; signing, notarization, and packaging make a release
A macOS app needs Code Signing, Apple Notarization, and DMG packaging. Developer ID, Hardened Runtime, stapling a notarization ticket… Every term was new to me.
Claude wrote build-release.sh to compile, sign, package, and notarize with one command. It was not smooth: notarization failed several times, for different reasons each time. Eventually, though, a DMG file with Apple's approval appeared on my desktop.
Double-click. Drag into Applications. Open. The crawfish appeared in the notch, blowing bubbles and waiting for the AI to give it work.
It was not a demo or a prototype. It was a finished app that could be distributed for anyone to use.
Only 48 hours separated “I do not even have a GitHub account” from “a DMG that passed Apple notarization.”
What happened in those 48 hours? Claude created 71 Swift source files, integrated 35 sets of sprite animations, built both local and remote communication protocols, completed three-language switching, and added session history, menu-bar controls, and launch at login. It even added accessibility support, which had never occurred to me.
I did not do all this alone. AI and I did it together. More precisely, I decided what to make; AI handled how to make it.
7. What I thought about afterward
After finishing this project, I thought back over how I had used AI for the previous six months: mostly questions, chats, and help editing text. Honestly, I had thought of AI as a slightly smarter search engine. Claude Code is something else entirely. It can operate on files, run commands, and compile code. It was not answering me; it was doing work for me. The gap was far bigger than I had imagined.
But results did not come without effort. I barely slept during those two days. AI wrote the code, but deciding what to build, describing requirements, and judging the result and direction were all my job. It felt more like suddenly having a tireless technical co-founder, with me as the product manager.
Looking back, what really changed was the location of the bottleneck. The ideas that used to die in my notes were blocked by the technical gulf between idea and product. AI has now filled that gulf. What bottleneck remains? Imagination: what can you think of, and how clearly can you describe what you want?
At this point, though, I need to be honest with myself. I cannot understand a single one of those 12800 lines. If AI says it is fine, I can only choose to trust it. If it has buried a mine somewhere, such as a security flaw or logic that was not properly cleaned up, I cannot spot it. The barrier is gone, but the cost has not evaporated. It has moved: from whether I can write the code to whether I can judge it. AI paid the coding part for me. Verification and judgment are still on my tab. That bill will come due; I just do not yet know what I will pay it with.
I do not know what this means for professional developers. That is not mine to judge. But for someone like me, with ideas and no ability to implement them, this was the first time I felt I could simply go and make something when I wanted to.
8. A model to take away
If only one sentence survives from this record, I hope it is this:
As the marginal cost of implementation approaches zero, ideas become the only scarce resource.
In the past, the idea was a fraction of a product's cost. Everything else was implementation: learning languages, configuring environments, debugging, packaging, and releasing. Ideas could afford to die; leaving them to rot in a note did not hurt. Now that ratio has reversed. Implementation approaches free, while deciding what you want and describing it clearly becomes the entire cost. Those “I will do it when I have learned how” thoughts on line 47 of my notes no longer have “wait” as an option.
Two days earlier, I did not even have a GitHub account. Now a crawfish and a hermit crab live in my MacBook's notch. They wave their claws, blow bubbles, and flash emotions according to AI status. They track token use across three AI platforms, communicate both ways with a remote server through WebSocket, support Chinese, English, and Japanese, and have passed Apple notarization.
12800 lines of Swift. 71 source files. 35 sets of sprite animations.
All made by chatting with AI.
The barrier that once stood between an idea and a product really is gone.
But costs do not disappear into thin air. They wait for you somewhere else. Knowing how to code used to be the threshold. Knowing good from bad will be the next one.
I made a product, and acquired a heap of problems I had never qualified to have before. Perhaps that is what progress looks like.
Rockpile is open source: GitHub - Rockpile
Don't Panic. Accelerate.
`Time layer: event layer (48-hour personal account), pointing to the structural layer (a phase change in the barrier to development)`
`Confidence: marginal implementation cost approaching zero — high | ideas becoming the only scarce resource — medium (verification and judgment costs are not included)`
Rockpile
An AI-built personal macOS project documented through a public repository and an explicitly unverified release claim.