I Stopped Having Ideas and Started Building Them
In twelve weeks I shipped around forty-seven repositories. Web apps, a dozen-plus physical devices, a native Mac app, and a second brain that now runs my whole operation. I am not an engineer. I have spent ten years in marketing.
This is the honest version of how that happened, what AI actually changed, and where it didn't help at all.
For ten years the ideas kept coming and kept staying ideas. Building them myself was never on the table; that was the engineers' job, not mine. Then, messing around with these tools, something flipped: I could actually do this. No plan, no course. Just the moment I realized I can, and after that I couldn't stop.
The short version of the thesis: the interesting shift was not speed. It was the set of things that became possible at all. A marketer does not flash firmware onto a microcontroller on a Tuesday night. Until, suddenly, he does.
The flood (mid-March)
It started with three web dashboards in the same week. Around March 14 I bootstrapped an F1 analysis site (now FastLap.xyz), a city liveability dashboard (livabl.xyz), and a live sky dashboard (Überdir) more or less in parallel.
I expected the first one to take weeks. It took days. So I started the next one before the first was done.
livabl.xyz is the one that taught me the rhythm. The idea was a single page that tells you how liveable a European city is right now, pulling sixteen live signals: air quality, weather, pollen, transit, jobs, energy prices, cost of living, parking, water, even sport. On day one I had it building per-city pages with routes for each city. By the end of day one I had thrown that away and rebuilt it as one dashboard with a city switcher and auto-detected location. That instinct, cut the structure before it calcifies, became the single most useful habit of the whole run.
The other thing livabl set in stone was a rule I never broke afterward: free data only. Every signal came from a free or fallback-backed API. No scraping, no terms-of-service risk, no monthly bill. When a source got flaky, I swapped it for another rather than paying to make the fragile one reliable. That constraint shaped forty-six more projects.
By late March there were five of these live. The pattern underneath all of them looked the same: go all in for one to two weeks, ship it end to end, then let it settle and start the next thing. Not a gradual ramp. A sprint, then quiet.
Range (late March into April)
Then it got broader, and weirder.
Cappuccino was a specialty-coffee guide for fifty cities with an AI espresso dial-in tool: tell it your shot pulled sour and bitter and it walks you back to a good extraction. Built in twelve days. The interesting part was not the coffee. It was watching myself reflexively reach for the cheap option every time. Dropped Mapbox for Leaflet and OpenStreetMap in a single commit. Killed Google Places entirely and fell back to curated cards. The free-tier rule was turning into an actual design philosophy: assume zero budget, then design something that is better because of it.
Faithmap was a scripture explorer across seven traditions, with AI commentary, in English and Arabic with full right-to-left support. A hundred and thirty-one commits in one week. Two things from it stuck with me.
First, the AI architecture. I could not afford a paid model, so I built a cascade: Gemini for the slow batch work of pre-generating explanations (to protect my Groq quota), Groq for live user questions, and a static cache on top so popular verses never hit a model twice. Working inside the free tier forced a better design than a credit card would have.
Second, the night the deploy broke. Something went wrong in production and I was tired. Instead of debugging it live at the worst possible time, I reset to the last known-good commit and force-redeployed. Restore stability first, understand it later. I have done that a dozen times since. It is not glamorous and it is almost always right.
And then, the turn I did not see coming: hardware.
Pixel Pet is a Tamagotchi. An actual virtual pet living on a round 1.28-inch display driven by an ESP32-C3 microcontroller, with weather pulled from the sky over Düsseldorf and nine mini-games. A marketer, soldering, reading datasheets, fixing a crash by lowering the WiFi transmit power to 8.5 dBm because the chip was browning out. I did not know any of that in February.
The moment I fell in love with hardware was an OTA update. I had rewritten the pet's memory layout to support wireless firmware updates, which meant repartitioning the chip's flash. I pushed the new firmware over the air, fully expecting to reset the pet. It loaded its saved state cleanly and carried on. The pet survived the repartition intact, at age 1,403 minutes. A thing I made kept being itself through a brain transplant I did remotely. I rebalanced its survival mechanics the next day, mostly because I kept letting it get sick and felt bad about it.
Hardware turned out to be the best surprise of the whole run. It's tactile in a way software never is; you're holding the thing you made. It's also much harder, because there is no undo button. Flash the wrong build and you live with it until you fix it. That's exactly why it's so satisfying. The constraints and the limits of the board push back on you, and getting something to actually work inside them feels earned in a way shipping a web app never quite does.
The turn: building tools to watch myself (late April into May)
Somewhere around the end of April the work changed shape. I stopped only building things for other people to use and started building things to watch what I was doing.
The first was the brain. A plain folder of markdown: one note per project, one journal entry per day, a reference shelf for the gotchas I never wanted to relearn. It sounds trivial. It turned out to be the most important thing I built, because it solved a problem I did not have words for yet. Every new AI session started cold. It did not know my boards, my pin maps, my deploy conventions, my past decisions. I was paying the same tax every single day, re-explaining myself to a tool with no memory. The brain is the document I hand a fresh session so it already knows what a smart contractor would know on day one. The closer it gets to that, the better the AI performs. The rule I wrote for it was "capture cheap, organize later," and I have mostly stuck to it.
The second was DevDash, now live at bain.monster. It reads the brain and shows me today's journal, my active projects, what is shipping, and a daily AI synthesis of what I have been doing. It also did the most on-brand thing in this whole story: it started life as firmware for a small screen, and in mid-May I deleted the entire hardware layer and turned it into a web app. The hardware idea was quietly competing with the better web idea, so I killed the half I was more attached to. That is the "cut by default" principle costing me something, which is the only proof that it is real.
The third was DialDash, and it is the one that gives the game away. It is a small touchscreen that sits on my desk and shows me, in real time, how many tokens per second I am spending on Claude, colored green to red like a CPU meter. I built a device whose only job is to watch me use the tool I am telling you about. The technical wrinkle was perfect: I had two of these displays plugged in, and they were physically indistinguishable to the computer, identical serial numbers and shuffling port names. There was no reliable way to address one specifically. After a brief and greedy phase where I just broadcast everything to every screen (which hijacked a port another project was using), I settled on an explicit allow-list. The only honest way to tell two identical things apart is to write down which one you mean.
That month is the real inflection of the whole story. The first six weeks, AI was a way to go fast. Now it was becoming a thinking partner, and I was building the scaffolding for that partnership to compound.
Consolidation and craft (mid-to-late May)
Volume stopped being the point. Three things took over.
I killed the weak projects. A SEO Chrome extension called ZeroClick that I scaffolded in a single day and never shipped: the domain stayed unbought, the database never created. A Model Context Protocol server to drive Fusion 360 for 3D-printable parts, abandoned when CAD tooling fought back harder than expected. A Eurovision app whose moment passed. A Lebanon livability tracker that lost momentum. A kids' storytelling app with voice narration that did not earn its keep. I left every one of their notes in the brain, marked abandoned, with what got done and what never did. A portfolio with no failures in it is a brochure, and I do not trust brochures.
If one of them still nags at me, it's ZeroClick. The idea holds up: run the search check inside the user's own browser, so spotting when an AI Overview is eating your clicks costs nothing. No scraping bill, no proxies, no terms-of-service risk. I had the whole thing scaffolded in a day, and then it just stopped. The domain stayed unbought. What killed it wasn't the idea, it was me: once the interesting part was proven, the boring part that was left (polish it, launch it, keep it alive) couldn't hold my attention. That's the honest pattern across most of my abandons. I'm in it to find out whether a thing can work, not to run it once it does.
I documented patterns so I would stop relearning them. The clearest example is an e-ink transit board for my local stop, Staufenplatz. Building it, four separate failures stacked on top of each other, and any one of them alone would have shipped fine while all four together broke everything: the wrong flash partition layout, WiFi power-saving silently dropping packets, the slow e-paper redraw on one CPU core starving the update process on the other, and a reset that did not propagate to the screen so it froze on old content. Untangling that took real systems thinking. But the better story is what happened before I could even start: I had lost the source code. It was sitting in an abandoned branch of a different project, and I could not find it on disk. So I read the firmware straight off the device, dumped the flash, ran the binary through strings, and grepped for my own code until I found it. Embedded archaeology. I wrote all of it down so the next time costs minutes instead of a day.
And I started making things that were just delightful. Daily Bestiary generates one small 3D creature every day, where the anatomy encodes that day from my journal: legs are projects I touched, spikes are wins, antennae are decisions made, eyes are open questions, dents are the moments I got stuck. Its body shape comes from scoring the day's words into one of four "phyla." The plan is to print them and put them on a shelf, so that picking one up months later lets me decode the day from its shape. I gave it one hard rule: zero AI at runtime, pure procedural math, because the point was a permanent physical object, not another thing that calls an API. Concept to live gallery to packaged Mac app in a single day.
Now (late May into June)
The recent work is slower on purpose, and better for it.
I built a WebXR globe you can walk around in a VR headset, showing live earthquakes and the position of the International Space Station, narrated by a deadpan AI Earth. I shipped a pet-care handover app, end to end and live, so a sitter knows everything about your animal while you travel. I built an autonomous camera on an ESP32 that watches the room and keeps a narrated diary of what it sees. I turned a desk gadget with four buttons and two buzzers into six tiny games, including one you play by humming at the right pitch.
The difference now is that I am thinking deeper, not shipping faster. Early on, a project was one thing done quickly. Now a project is six games with a screensaver that reacts to sound, or a status dashboard that correctly tells the difference between "I checked and it is down" and "I could not check," because those are not the same and pretending they are is how you get woken up at 3am for nothing.
And about thirty others
The forty-seven is not a typo, so here is the rest of it, quickly.
A wall of Düsseldorf transit boards, because apparently I cannot stop: a round one for two bus stops, a rectangular CYD one, an e-ink one. A pile of e-ink experiments: F1 standings, a photo frame, a news ticker, a one-tap phone-to-screen printer, a tech-status board. An OLED clock that says blueclock.local. A climate sensor with its own little web magazine baked into the firmware. A camera that captions what it sees with AI vision. An inventory tracker with a physical knob. A coffee guide, a recipe app, a German-exam trainer, a 90s-internet nostalgia site, a South Africa travel guide with live load-shedding, a personal IPTV app, a multi-theme gaming hub. A control panel for my robot vacuum. A mini-keyboard remote. A Mac menu-bar app I wrote specifically so I could snap photos of my hardware and paste them straight to Claude. A deadpan reader of Wikipedia's live edit firehose that turns editing spikes into found poems.
Some are polished and live. Some are half-finished. A few are dead. All of them taught me something, which is the only reason to keep the dead ones on the list.
What AI actually changed
Here is the part I actually want to argue, now that I have the receipts.
It did not make me a 10x engineer. It removed the activation energy. The cost of starting something dropped to almost nothing, and starting was always the thing I could not do. The gap between "I have an idea" and "the idea exists" used to be a wall I could not climb. It is now an afternoon. When starting is free, you start more, and most of what you learn comes from the starting.
The free-tier constraint made the work better, not worse. Every time I refused to add a paid API, I was forced into a more honest design: run it in the user's browser, cache it, fall back to it, or cut the feature. Constraints are not the enemy of good work. They are most of it. Money is never my first answer to a problem. The question I actually ask is ROI, and reaching for a paid service is usually the laziest way past a constraint you could have designed around. Almost every time I refused to pull out a card, the thing I built instead was simpler, cheaper to run, and more mine.
My relationship with the tool went through four stages. It started as a velocity multiplier: ship five things in two weeks. It became a pattern finder: notice that three projects all reinvented the same fallback architecture. Then an infrastructure partner: let us build the brain together so the next session starts warm. And finally a reflection mirror: the brain got rich enough that the AI could read it and show me patterns in my own work I had not seen myself. The two principles it surfaced about how I decide, "cut by default" and "decide for future-you," were not things I told it. They were things it found in me.
The most important thing I built was not a project. It was the system for working with AI. The brain is the real protagonist of this story. Forty-seven things are what it looks like when you remove the activation energy from a person who always had ideas and never had a way out. So yes, I'm going to keep going. Twelve weeks ago I didn't believe I could build across web, hardware, and native at all. Now I know the bottleneck was never the building, it was the starting, and that wall is mostly gone. Next I want to push into the stuff I haven't touched yet: other platforms, other languages, whatever I currently don't know how to do. That's the whole point now. The distance between not knowing how and having built it is the shortest it has ever been, and I'm not going to waste that.
Built in Düsseldorf, March to June 2026, with Claude Code. Everything live is linked from vibed.website.