I Stopped Having Ideas and Started Building Them
In my first 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 spent ten years in marketing.
01My first twelve weeks, ~47 projects: web apps, ESP32 hardware, a native Mac app, and a second brain. I'm a marketer, not an engineer.
02The change wasn't speed. AI removed the cost of starting, and starting was the only thing that ever stopped me.
03A strict free-data, no-paid-API rule made almost everything simpler, cheaper to run, and more mine.
04The thing that mattered most isn't any one project. It's the "brain": the system that lets every AI session start warm.
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 I started messing around with these tools and realized I could actually do this. No plan, no course. Once I knew I could, I couldn't stop.
The interesting shift wasn't speed. It was the set of things that became possible at all. A marketer doesn't flash firmware onto a microcontroller on a Tuesday night. Then one Tuesday night I did.
The flood (March 2026)
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. By morning I had it building a separate page and route for every city. By that night I had thrown all of it away and rebuilt it as one dashboard with a city switcher and auto-detected location. Cutting structure before it hardens became the most useful habit I picked up.
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 one rule shaped everything I built after it.
By late March there were five of these live. They all ran the same way: go all in for a week or two, ship it end to end, then let it settle and start the next thing. Not a gradual ramp. A sprint, then quiet.
Range (March–April 2026)
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 it walks you back to a good extraction. Built in twelve days. The lasting part wasn't the coffee, it was catching myself reach for the cheap option every time without thinking. I dropped Mapbox for Leaflet and OpenStreetMap in one commit and killed Google Places. The free-tier rule was hardening into a real way of designing: assume zero budget, then build something that's better for 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 couldn't 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. A credit card would have let me build something lazier.
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. Get it stable first, figure out why later. I've done that plenty of times since. It's not glamorous and it almost always works.
And then hardware, which I never saw coming.
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 didn't know any of that at the start of the year.
The moment I fell for hardware was an OTA update. I'd 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 over WiFi. I rebalanced its survival mechanics the next day, mostly because I kept letting it get sick and felt bad about it. That's the whole appeal of hardware: there's no undo. Flash the wrong build and you live with it until you fix it. The board pushes back, and getting something to work inside its limits feels earned in a way shipping a web app never quite does.
The turn: building tools to watch myself (April–May 2026)
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 fixed a problem I couldn't yet name. Every new AI session started cold. It didn't know my boards, my pin maps, my deploy conventions, my past decisions. I was paying the same tax every day, re-explaining myself to a tool with no memory. The brain is the document I hand a fresh session so it walks in knowing what a good contractor would know on day one. The closer it gets to that, the better the AI works. The rule I wrote for it was "capture cheap, organize later," and I've 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's shipping, and a daily AI synthesis of what I've 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. "Cut by default" only counts when it costs you the half you love.
The third was DialDash, the most on-the-nose thing I built. It's a small touchscreen that sits on my desk and shows me, in real time, how many tokens per second I'm 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'm 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, greedy phase where I broadcast everything to every screen (which hijacked a port another project was using), I settled on an explicit allow-list. To tell two identical things apart, you have to write down which one you mean.
That month is where the story actually turns. For the first six weeks, AI was a way to go fast. By then it was becoming a thinking partner, and I was building the scaffolding for that to compound.
Consolidation and craft (May 2026)
Volume stopped being the point. Three things took over.
I killed the weak projects. A SEO Chrome extension called ZeroClick I scaffolded in a 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 didn't 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 just a brochure.
ZeroClick is the one that still nags. 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. What killed it wasn't the idea, it was me. Once the interesting part was proven, the boring part left over (polish it, launch it, keep it alive) couldn't hold me. 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'd 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. Any one alone would have shipped fine; all four together broke everything: the wrong flash partition layout, WiFi power-saving silently dropping packets, a slow e-paper redraw on one CPU core starving the update process on the other, and a reset that never reached 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'd lost the source code. It was sitting in an abandoned branch of a different project, and I couldn't 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. I wrote all of it down so 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 idea is to print them and put them on a shelf, so 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 phones an API. Concept to live gallery to packaged Mac app in one day.
Deeper, not faster (June 2026)
The work got 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. And I rebuilt a gaming hub I'd half-abandoned into Playabl: seven deterministic puzzles a day, the same for everyone, server-scored, with a weekly champion. A small daily ritual for a group of friends, not another thing built to be looked at once.
The difference is depth, not speed. Early on, a project was one thing done quickly. Later it was six games with a screensaver that reacts to sound, or a status dashboard that knows the difference between "I checked and it's down" and "I couldn't check." Those aren't the same, and pretending they are is how you get woken at 3am for nothing.
And about thirty others
The forty-seven is not a typo, so here is the rest of that first stretch, quickly.
A wall of Düsseldorf transit boards, because apparently I can't 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. An OLED clock that answers to blueclock.local. A climate sensor with its own little web magazine baked into the firmware. An inventory tracker with a physical knob. A Mac menu-bar app I wrote specifically so I could snap photos of my hardware and paste them straight to Claude. And 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. Every one of them taught me something, which is the only reason the dead ones are still 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 couldn't do. The gap between "I have an idea" and "the idea exists" used to be a wall I couldn't climb. Now it's an afternoon. When starting is free you start more, and most of what you learn comes from 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 aren't the enemy of good work; a lot of the time they are the work. Money is never my first answer to a problem. The question I actually ask is what the return is, 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 has gone through four stages so far. 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's build the brain together so the next session starts warm. And then a reflection mirror: the brain got rich enough that the AI could read it and show me patterns in my own work I'd missed. The two rules it surfaced about how I decide, "cut by default" and "decide for future-you," weren't things I'd told it. It found them in me.
The most important thing I built was not a project. It was the system for working with AI. If I had to keep one thing from that first stretch, it's the brain, not any single project. Forty-seven things in twelve weeks is what it looks like when you take the activation energy away from someone who always had ideas and never had a way to act on them. So yes, I'm still going. When I started 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. I keep pushing into the stuff I haven't touched yet: other platforms, other languages, whatever I don't know how to do yet. That's the whole point. The distance between not knowing how to do something and having already built it is the shortest it's ever been, and I'm not going to waste that.
Written in Düsseldorf, June 2026. Still going. Built with Claude Code, and everything live is linked from vibed.website.