How It Works
The whole road, idea to live. No accounts, no cost — your plans stay on your device.
You walk in with a rough idea
It doesn't have to be polished. It doesn't have to be smart yet. Just say what you want to build.
We read it back to you
You see what we understood — what it is, where it belongs, who it's for — before any plan appears. If a detail is missing and it actually changes the build, you get one question. Not a form.
You get your plan
What version one does, what it already has, what must not break, and what we're deliberately leaving out. Plus the calls we made for you, so you can overrule any of them.
You hand it to your builder
Your plan becomes a real execution brief — scope, assets, what to preserve, what to skip, how to test it. Paste it into the building tool you already trust. You review and approve what it builds.
You test it locally
Use the real thing yourself before anyone else does. The plan's definition of done is your checklist. If it doesn't work for you, it's not ready.
You send it to Open Mirror to push
Tested and working? Send it in with your test results. Open Mirror pushes it live — a real deploy, a real address on the internet.
It lands on the Live page
Every push joins the Live Products page — proof it made it out of the ring. Then you come back for the next round: fix, refine, expand, or launch.
The steps above are one trip through the ring. This is how the same loop runs again and again — the actual method, written down so you can run it on your own machine.
A low-cost build machine is a checklist, not a purchase. Commands vary by system — treat these as templates and use each tool's official install page.
- An OS you're comfortable in (an old laptop with Linux works fine).
- A code editor (VS Code) and a terminal you're not afraid of.
- Git, plus a GitHub account for backup and deploys.
- Node (or the runtime your builds need) — template: install from the official site, then `node --version`.
- Claude Code or the AI builder you trust, signed in.
- A browser for testing, and a deploy platform (Vercel's free tier is enough).
- Secrets live in local files that never enter git — never in code, never in prompts.
- One folder where every repository lives, so nothing gets lost.
Say the idea in the planner, choose an engine in the Engine Room, or continue one that started on iDontCry. One creation at a time.
- The idea goes in however it comes out — the system reads it back before anything is planned.
- A creation that starts anywhere carries its record everywhere: no retyping between engines.
The step most projects skip. Before any prompt exists, you can read what's being made, who it serves, the smallest outcome, whether software is even needed, and what's deliberately excluded.
- Correct anything wrong — the plan re-reads, it doesn't re-interview.
- The software-necessity call is honest: some ideas should be tested on paper first, and the plan says so.
Every creation exports the same portable pack.
- creation-brief.md — idea, interpretation, specification, acceptance test, and the builder prompt, human-readable.
- creation.json — the validated record, re-importable later.
- The builder prompt alone copies to the clipboard when that's all you need.
Open the right repository (or an empty folder for a standalone build), start a fresh Claude Code session, paste the prompt, and let it work.
- The prompt carries the working method: inspect first, smallest stack, mobile-first, test for real, stop only at safety gates.
- Your Builder Defaults decide how far it goes: prototype, commit, or commit-and-push.
The builder's report is a claim, not a verdict. Check it yourself.
- Use the real product — phone width and desktop, mouse and keyboard.
- Read the git diff; confirm only the intended repository changed.
- The acceptance test from the Build Pack is the checklist.
Export the finished creation, keep the prompt and acceptance tests with it, and start the next idea. The loop is the product.
- Builder Defaults persist, so the next prompt starts right.
- When an engine's output was weak, that's a bug in the engine — improve it before the next run.
Part of Open Mirror LLC. Kids should build with a parent or trusted adult.