Make your app idea real.

Practical guides for turning a clear brief into an app you can test and own.

Read product updates →

Start with a practical guide

All articles

Do not pretend the feature works

A user wrote one line in his prompt that every prototype should carry: do not pretend that AI voice, memory or autonomous actions work unless they are actually implemented. Why an honest prototype is worth more than an impressive one.

Three emails a solo founder sends, and what came back

AppX now sends three short emails from me: when your first app is ready, when you built one and did not come back, and when you signed up and never started. 56 sent so far. Here is what they say and the mistake that means I cannot tell what came back.

AppX is not at $0 MRR anymore

Three days ago I published a pitch deck that said $0 revenue and zero paying customers. Today someone subscribed to the $5 plan. Here is what that means and what it doesn't.

You have an idea and no code. The wall is gone.

For thirty years, turning an idea into software meant learning to code, hiring, or finding a technical co-founder. AI removed that wall — and the skill that replaced coding is one you probably already have.

The screenshot that triggered a 5-wave rearchitecture

'Done · 0ms' looked cosmetic. Eight hours of investigation revealed it was a structural bug class. A week of work shipped a 5-wave persistence rearchitecture. The narrative of how a UI screenshot turned into the biggest backend project of the month.

Three things we built and threw away this year

The Railover orchestrator fork, the one-shot bundle server, the V1 chat intent classifier. Each was a real working system in production. Each got deleted when the shape of the problem changed underneath it.

The first AppX architecture, and why we tore it down

v1 was a web-first React generator wrapped in Vite hosting. It demoed beautifully and failed in production. The honest autopsy — what stayed, what went, and why the demo and the product are different things.

Forge deep-dive: webhook-driven state, zero polling, no drift

Sequel to why-we-built-forge. Polling produces a structural drift window. HMAC-signed webhooks on every sandbox transition take state propagation from 5-10s to ~1ms. Idempotent handler, state-machine guard, replay-on-restart, and one slow reconciler kept as safety belt.

Persistent Metro: 1,750x faster than spawning expo export

One-shot bundlers pay cold-start every invocation. Persistent Metro dev server inside each preview container takes file writes to 4ms and warm bundles to 100ms. The pattern generalizes — any incremental build tool with a watch mode wants to be a daemon, not a script.

SIGKILL is the boss fight: design your sweeper for it

SIGTERM gives you cleanup time. SIGKILL doesn't. Deploys, OOM, and crashes all skip your graceful-shutdown handler. Your sweeper IS the SIGKILL handler — and its query shape should test for invariant violations, not row age.

Dice-coefficient autocorrect for failed SEARCH/REPLACE edits

Agentic edit loops bleed on whitespace drift and one-character mismatches in SEARCH/REPLACE blocks. Replace 'SEARCH text not found' with the top-3 similar candidates scored by Dice's coefficient — the LLM autocorrects on the next iteration at the cost of one O(n*m) scan.

Run Kahn's topological sort on every AI-generated plan

AI architects emit multi-file plans that compile, run, and crash because the dependency graph has a cycle nobody looked at. Validate the plan with Kahn's algorithm before you spend tokens generating. Twenty lines of TypeScript catches a class of runtime bugs at near-zero compute cost.

Stop fixing bugs. Start fixing classes.

Every non-trivial bug is one instance of a class. Patching the instance leaves the class alive — and it will mint the next bug. The lens, the patch+class split, the economics, and the trap of fixing classes that don't matter.

Wave-shaped refactors: modernize a hot path without a freeze

Big-bang PRs get skimmed. Multi-week branches drift. Neither works for a hot persistence path. The shape that does: 5 independently-shippable waves, shadow-mirror writers, and a kill-switch wave that turns modernization into actual debt reduction.

Ban raw column references: one rule against schema drift

Typed query builders catch schema drift everywhere except inside raw sql templates. The string column reference is the hole. Ban it. What's left is enough for every legitimate raw-SQL case — and the bug class becomes structurally impossible.

Inventory before refactor: 3 investigators rewrote our plan

Sibling to investigators-before-builders. Here's the concrete case: three parallel read-only investigators caught that only 8 of 32 fields warranted promotion — and turned a new-table refactor into an extend-table refactor, saving two weeks.

Defense in depth for stateful AI-agent loops: 4 layers

A frontend clamp papers over a bad column. A backend sweeper catches symptoms not causes. A DB constraint blocks bad writes but doesn't repair existing rows. You need all four — and the order to retrofit them when starting from a broken system.

Stop jamming AI-agent state into a metadata JSON column

Every soft field in a JSONB blob looks like flexibility. By month six it's a defensive ?? walk on the frontend and a JSON_EXTRACT join the planner can't index. Three forces pull fields out of JSON — and the migration shape that needs no freeze.

Step 0: delete dead code before you refactor with an LLM

Every byte you load into an LLM agent's context is a byte it has to keep track of. Dead code looks like signal — and agents preserve, extend, or mimic it. Our rule: a pure-deletion commit before any structural refactor of a file over 300 LOC.

Investigators before builders: a 2-phase LLM workflow

Most teams dispatch coding agents straight to the build. We run a read-only investigator phase first — and the findings have rewritten our plan in 30-40% of cases. Here's the shape, the brief format, and what to do when findings contradict the plan.