Process
How it works
Custom software used to mean a quote, a long wait, and a hand-over you had to take on trust. We sell it the way you buy anything else online — fixed scope, fixed price — and then build it in the open: you watch the team of AI agents work live, the engine refuses to release until every quality gate passes, and you receive full documentation shaped on the international standards.
1 · Two ways to order
Pick a blueprint, or describe your own
Pick from the catalog
100 researched blueprints, each with its standard features, popular additions, tech stack, timeline and a fixed tier price. Customize it: custom features quoted per item, your business details, up to three extra languages, design references.
Browse the catalogDescribe your own software
Type the specs, details and description. Our analyst model drafts the product page — features, popular additions, tech stack, assumptions — and the store prices it with the same fixed tier rules. Refine until it is right, then configure it exactly like a blueprint.
Describe your softwareThen: the Build Agreement
Your configuration becomes a Build Agreement — the itemized scope of what will be delivered: the standard features, your custom features ($50 simple / $150 moderate / $300 complex), business details, languages and design references. Nothing is charged until you have read and agreed to it. It is the document the planner reads, the testers test against, and the warranty refers to. Prices: Small $500 · Medium $1,500 · Large $3,500.
2 · The build team
A team of AI agents, each with a role — working in parallel
After payment your order is queued on our build engine and run by a team of agents inside a private VS Code workspace of its own. The engine — not the agents — owns the budget, the phases, the gates and the recording.
Planner
Claude Fable 5.1
Reads the Build Agreement, writes the plan, the requirements (REQ ids with acceptance criteria), the architecture and the design, and splits the work into phases — one per feature.
Orchestrator
Claude Fable 5.1 (the same session)
The planner continues as the orchestrator: it drives the build in the project's own VS Code, briefs the helpers, reviews what comes back, keeps the documents current and decides when a phase is done. This is the screen you watch.
Implementers
Claude Opus 5.5
Build the features in parallel — database, server logic, screens, unit tests — each in its own lane, reporting back to the orchestrator.
Testers
Claude Sonnet 5.5
Design the test cases and user journeys from the requirements, write the system-integration tests and the usability review, and hand defects back to the implementers.
Models named are the engine's defaults at the time of writing; the role structure is what stays constant.
3 · Watch live
You watch the real build — not a progress bar
Your order page has a private Watch your build livelink. It opens a filmed view of the orchestrator's VS Code: the file tree, files opening, code being typed, tests running in the terminal. Beside it, a text lane per helper shows what each implementer and tester is doing right now, and a phase strip at the top shows where the build is — plan, requirements, architecture, one phase per feature, tests, UI/UX, documentation, release.
- Live means about 8–15 seconds behind the agents' screen.
- Recorded from the first second: open the link later and play from the start, or seek to any phase.
- After the build: a final video with chapters per phase and role, plus the full event recording.
- After every phase the orchestrator writes a plain-language summary you also see on your order page.
- Watching is view-only. If the build needs a decision from us, our engineers step in; you see it in the recording.
What you see on the watch page
- Phase strip
- Every phase of the build with its state — done, running, waiting.
- The orchestrator's VS Code
- Filmed live: editor tabs, the file tree, typed code, terminal output of the gates.
- Helper lanes
- One lane per implementer and tester with their running commentary and the files they changed.
- Agent badges
- Which role and model is working, on every turn and every chapter.
- Recording controls
- Live, from the start, or any phase; later the final video.
4 · Quality gates
The engine refuses to release until every gate passes
The agents write the code and the tests; the engine runs the gates itself, in the build workspace, and reads the measured results. A failing gate goes back to the team to fix and is run again. Only a build with every gate green is packaged as a release — with the test report, the traceability matrix and the UI screenshots inside it.
- 1
Type check
The whole project compiles with strict TypeScript.
- 2
Lint
Code-quality rules pass with no errors.
- 3
Build
A production build succeeds — the same build that runs when you use the system.
- 4
Unit tests · 100 % coverage
Business logic, API routes and server actions are covered to 100 % measured line coverage; a single uncovered line fails the gate.
- 5
System-integration tests
The built app is started and every route is exercised end to end against a real database.
- 6
UI/UX tests
The engine's own browser runs the testers' user journeys on mobile, tablet and desktop, audits every page for WCAG 2.2 AA accessibility with axe, takes screenshots, measures load times, and the tester writes a usability review against Nielsen's ten heuristics.
- 7
Documents + traceability
Every required document and section exists for the phase, and every requirement traces to at least one test case that ran and passed.
5 · Full documentation, by standard and by reader
A documentation set your next developer, auditor or operator can actually use
Every build ships a complete documentation set whose documents follow the structure of the international standards for software documentation. We are not certified against these standards and do not claim to be — we use their document shapes and required sections so the result is complete, consistent and familiar to anyone who has worked with them.
| Document | Shaped on | For | Contains |
|---|---|---|---|
| REQUIREMENTS.md | ISO/IEC/IEEE 29148 | Management · Developers · Testers | The software requirements specification: purpose, scope, stakeholders, every requirement with an id and acceptance criteria. |
| ARCHITECTURE.md | ISO/IEC/IEEE 42010 | Developers · Operations | Architecture description with viewpoints (context, containers, components), decisions and quality concerns. |
| DESIGN.md + DECISIONS.md | IEEE 1016 | Developers | Software design description per viewpoint — data model, interfaces, flows — plus the architecture decision log. |
| test/TEST-PLAN.md, TEST-CASES.md, TEST-REPORT.md | ISO/IEC/IEEE 29119-3 | Testers & QA · Management | Test plan, test design and cases, procedures, the test log, incidents and the completion report with results. |
| USER-GUIDE.md | ISO/IEC/IEEE 26514 | End users | Task-oriented user documentation per role and screen, also seeded into the system's own Help module. |
| OPERATIONS.md | runbook | Operations | Deploy, configuration, start / stop / health, backup and restore, logs, incident playbooks, upgrades. |
| test/TRACEABILITY.md | engine-written | Everyone | The matrix from every requirement to its test cases and the run in which they passed — generated by the engine, not written by hand. |
Organised by reader
Tabs for management, end users, developers, testers & QA and operations — each sees the documents meant for them, with a search across the set.
Download or print
Every document as Markdown or PDF, the whole set as a ZIP or one PDF with a linked table of contents, and a print view for each.
Traceability
The engine generates the matrix: requirement → test cases → the test run that passed. Nothing is in the release that is not traced.
6 · Delivery
Live minutes after the gates pass
The release is deployed with its own database and sign-in; your order page shows the private link and the initial admin credentials. External services (e-mail, SMS, payment gateways) are connected at official delivery.
7 · Handover
You own everything
Source code, documentation set, test report, recording and video, hosting and database access, every credential. Subscriptions transfer to your name — no markup, no lock-in.
8 · Warranty
6 months, against the Build Agreement
Any defect against the agreed scope is fixed free; the traceability matrix makes “agreed” unambiguous. Warranty & handover
Why this matters
What you gain from a build you can watch, verify and read
Transparency
You watch the real build, not a status bar. Every file opened, every test run, every decision is on the recording — with a plain-language summary after each phase.
Verifiability
The gates are enforced by the engine from measured results — coverage numbers, test logs, axe reports, screenshots — and the test report ships with the release. You can check every claim.
Standards-based handover
The documents follow the structure of the international software-documentation standards, so a new developer, an auditor or an operations team knows where to look on day one.
No black box
Requirements trace to tests, tests trace to code, code is yours. Nothing depends on remembering what was agreed — it is written down and linked.
An audit trail
The recording, the final video with chapters, the documents and the test results are kept with your order and can be downloaded any time.
Faster, at a fixed price
Implementers work in parallel and the gates catch defects as they appear, so builds finish in hours to days rather than weeks — and because the price is fixed by tier, rework is our cost, not yours.
Guided tour
See the four flows, step by step
1. Catalog
Start from one of 100 proven blueprints
Every blueprint lists its standard features, popular additions, tech stack, timeline and a fixed price. Filter by category or tier, open one, and customize it: custom features priced per item, your business details, extra languages, design references.
- Fixed price per tier — $500 / $1,500 / $3,500
- Full scope shown before you commit
- Custom features quoted $50–$300 each