I have thirteen public repositories on GitHub.

Three of them are real products.

The rest are half-shipped: interesting starts, side-quests, idea-shaped objects with a README and a pushed_at date and not much past it. Universal-codemode: clean idea, two demos, no users I can name. Vasted: works on my machine, never advertised, never used by anyone who isn't me. Smart-spawn: model router, never wired into anything I run daily. Mcclaw: Mac LLM checker, fun side build, abandoned at v0.2. Moltedin: a marketplace I sketched and walked away from. Lobster-tools. Tldr-club. Clawbot-blog.

I built fast. I shipped half. I posted screenshots.

That's the dominant mode on AI-builder X right now and I want to write the post about it as someone caught inside it, not above it.

The Builder.ai version

The loud version of this is Builder.ai.

The pitch was an AI named Natasha that built apps from a single sentence. Microsoft believed it. SoftBank's DeepCore believed it. The Qatar Investment Authority believed it. About $450M of capital believed it.

Behind the AI: 700 human engineers in India and Eastern Europe.

By 2024 the investigations had landed. Bloomberg. WSJ. The Information. By May 2025 the company was filing for insolvency, Microsoft and the creditors were inside the building, and "Builder.ai" had become culture-wide shorthand for AI-washing. Strap "AI" to a labor product, raise nine figures, ride the cycle until the cycle catches up.

That's the loud version of the pattern.

The quiet version is on your X feed every day, and it's not committing fraud. It's people shipping the half they can ship and calling it the whole. That's what I've been doing.

What a half-builder actually is

Tighter than "doesn't ship":

A half-builder is an operator who can do exactly one half of design-to-deploy, then skips the other half by simply not showing it. They post the artifact for their good half. The bad half is implied to exist. It usually doesn't.

There are three failure modes and I've personally lived all three.

The designer who can't code. Posts the Figma. Posts the AI-generated mock. Posts the screenshot, the concept, the "what if I built this?" thread. Never posts the running URL. The "build" is a frame around an image. I did this for years before I learned to ship.

The coder who can't design. Posts the diff. Posts the gist. Posts the prompt. The thing technically runs but you wouldn't keep it open for more than a session. The interface is a textarea and a <details> tag in Helvetica. I've published a few of these too. I called them "tools."

The either who can't ship. The most common failure mode by an order of magnitude. They can do their half competently. They can't deploy it, can't keep it up, can't onboard a single user, can't reach week two. Six demos a month. Zero products. The artifact dies in a screenshot.

The third failure mode is the one I've spent the most time in. I'd build a thing in a weekend, push it to a public repo, post a screenshot, get a few likes, and move to the next thing on Monday. I called that "shipping." It wasn't. It was sketching in public.

In all three modes the AI is real. The thing posted is real. Something got built. What didn't happen was building the whole thing. The half that wasn't shown was fake, missing, on someone else's calendar, or a TODO that never got picked up again.

That's a half-builder.

Why half-building is the default

It's not a personal failure. It's the structure of the industry for twenty years.

Design and engineering have been culturally separated since the early-2000s web. You picked a side at 22. The side trained you. Designers learned visual systems, components, motion, brand. Engineers learned data structures, infra, deployment, latency budgets. The handoff was the deliverable. Each side optimized for being good at their half, because their half was the whole job.

AI is collapsing that gap.

Every tool that closes the design-to-code distance (Figma-to-code generators, coding assistants, no-code with escape hatches, full-stack agents) pays out to operators who hold both sides in one head. The premium isn't on either half anymore. It's on the seam.

Twenty years of single-side specialization don't unwind in a hype cycle.

So the dominant cohort on AI-builder X is exactly who you'd expect. People whose career was built around being competent at one half. Learning AI in real time. Posting the half they can already do. Hoping the AI bridges the rest.

Sometimes it does. Most of the time it doesn't. The shipped product never appears. The next thread does.

I've been on this side of the timeline for years. Designers who became "builders" the day GPT-4 dropped. Engineers who became "AI engineers" the day Cursor got good. I'm one of them. The honest answer is that AI made it embarrassingly easy to look like a whole-builder while staying a half-builder underneath.

Builder.ai was that, with a $450M check on top.

What I've actually shipped (and what I've half-shipped)

Here's the honest receipts list. Not the highlight reel.

Real products people use:

• Dory. Shared memory layer for AI agents. Local-first, markdown source of truth, CLI / HTTP / MCP native. Open-source on GitHub, has actual users, gets actual issues filed. This is the only one I'd call run-grade.
• deeflect.com. Personal site, in production, anchors my entity online.
• blog.deeflect.com. Thirty-one published articles. Some of them are good. Not all of them are from this year, that was overstated in earlier drafts of this essay.
• dee.agency. Solo studio site, productized AI work.
• Don't Replace Me. Survival book on the AI apocalypse, paperback, hardcover, Kindle, on Amazon. Written end-to-end. People are reading it.
• The SEO-to-GEO Gap. First research paper, accepted and posted on SSRN this month with a real DOI. First peer-review-adjacent credential I've ever earned.

Half-shipped:

• ViBE. Twitter-based reception benchmark across 22 frontier AI model families, 2,965 judged mentions, $1.92 in judge cost. I love the writeup. I keep pitching the writeup. The benchmark itself is dogshit as a continuous product. It's a one-shot artifact, not a living thing, and treating it like a flagship was me confusing "interesting research" for "shipped product."
• Universal-codemode. Two tools that replace hundreds. Clever. Not used.
• Vasted. GPU-inference one-liner. Works. Unadopted.
• Smart-spawn. Model router. Demo grade.
• Castkit. CLI demo recorder in Rust. Cute. Sat down.
• Mcclaw. Mac-LLM checker. Fun. Abandoned.
• Moltedin / lobster-tools / tldr-club / clawbot-blog. Different shapes, same pattern. Started, posted, walked away.

The actual range underneath all of it:

Fifteen years of design. A cybersecurity bachelor. Firmware on ESP32 and marauder builds when the topic shifts. Designed for VALK across 70-plus financial institutions and 15 countries before walking out of that role earlier this year. Russian-born, lived across five-plus countries. ADHD wired enough to learn shit in a week and bored enough to walk away from it in a month.

The range is real. The shipping discipline isn't there yet.

In October 2025 I burned out and quit X for six months from a 200K-impressions-a-day peak. I'm reactivating from 640 followers as I write this. The list above is what got built around the crash year: three real products, a book, a paper, a personal entity I can point to, and a graveyard of clever half-things.

That's the honest picture. I'm a recovering half-builder.

The opposite cohort

The opposite of a half-builder is a whole-builder.

A whole-builder is one operator who covers design + code + AI + deploy + distribution end-to-end with no handoff. They pick fewer fights. They keep the artifacts alive past launch week. They have repos with users in the issue tracker, not just stars in the corner.

Pieter Levels is the canonical example. Design, code, deploy, distribute, monetize, all solo, all in public, receipts measured in MRR and screenshots. Marc Lou ships products with full visual identity attached. Theo runs an entire product line out of what he can hold in one head.

These aren't unicorns. They're the rarer category: operators who didn't pick a side and built their working pattern around not having a handoff. They're also the operators who said no to the next side-quest and kept the last one running.

I've copied the breadth half of that pattern. I haven't copied the discipline half. Whole-building isn't about doing more. It's about doing fewer things further. That part I'm still learning.

How to spot a half-builder (mirror included)

Most "AI builders" on the internet right now are half-builders, and most of us know which side we're on if we're honest about it.

The test is mechanical. It costs nothing. Run it on every "AI builder" account in your timeline this week, and on yourself.

Ask for the running URL. Not the prompt. Not the screenshot. Not the demo video. The URL someone else can open right now, on their phone, with no auth, no waitlist. If they can't produce one, you're talking to half a builder.

Ask for the repo. Public repo, last commit recent enough to matter, an issue tracker that isn't a ghost town. If "the code is private", fine. Ask for the deployed product. If neither exists, you have your answer.

Ask what they shipped this month. Not last year. Not "in their career." This month. Half-builders ship demos. Whole-builders ship products that someone else is using on a Tuesday morning.

If you ran that on me a month ago, you'd hear about ViBE and a clever Rust thing and a model router and a half-finished benchmark and a launch I almost did. You'd hear about everything except a product someone else opened on a Tuesday. The honest answer would have been Dory, and maybe the blog, and the rest is noise.

Show the repo or sit down, including the one I'm pointing back at when I write that.

Stopping

The exit from being a half-builder is mechanical, not mystical.

Pick the half you can't do and start doing it badly until you can do it. Designers shipping their first deploy. Coders learning visual hierarchy. Either learning distribution. The half you can't do isn't a personality. It's a backlog.

Pick fewer things. Keep them alive past the first week. Treat "shipped" as "someone else used it on a Tuesday," not "pushed to GitHub on a Sunday."

Whole-building is a slow accumulation of the second half by the first, until the seam disappears. None of that happens in a single weekend.

This essay is the first move. The next moves are: Dory gets the maintenance it deserves. ViBE either becomes a continuously-updating thing or gets retired honestly as a one-shot paper, not pretended into a flagship. The agency stops being a placeholder. The next side-quest waits its turn, or doesn't get started.

I'm writing this with the same uncertainty most of you feel scrolling past it. Am I the half-builder? Probably. What does the turn look like? Like this.

Build the whole thing.

Ship the running URL.

Show the repo.

Or sit down, including me.

That's the post.

---

Sources for the Builder.ai facts: Bloomberg's investigation into the company's engineering operations (2024), the Wall Street Journal's coverage of the May 2025 insolvency, and *The Information's reporting on the human-engineer back-end. Public, well-indexed; current URLs available via search.*