Builds / EXP-005

EXP-005● BuildingPilotUsed by three family households, lightly so far. Opening it to friends' households needs the open security and privacy findings fixed, backups running, and accounts tried on a real database; production needs evidence that outsiders will add their own books, and paid plans that stop it ever losing money.▸ Request an invite▸ Under the hood

Cheap to build, hard to stop: when AI builds faster than you can learn

Fold is a recipe app for vegetarian households with a vegan at the table, built with one AI session writing specs and another writing code. I built it for my own family's needs, so its first features needed no outside evidence; once I began to see its wider potential, I added a fair amount of complexity without checking whether it was warranted, which is the risk of building as fast as AI allows. Here's what that cost, what broke, and the rule that now makes every new piece of work name the assumption it tests.

Fold · Oct 2026

The question

Can one person with two AI sessions build a product for real households at full speed, and keep it safe, affordable and honest about what it knows?

Started
Oct 2026
Status
Building
Readiness
Pilot
Tools
Claude Code · React + Vite · Vercel · GitHub Actions · the stack

Under the hood

Timeline. First commit on 15 October 2026 and the first tagged release (v1.0.0) on 18 October, then a quiet stretch from 19 to 23 October. Ten releases by v1.9.0 on 29 October. The reverse PRD, strategy and decision log were written on 29 October, and the review panel started work the same day. Allergy profiles were removed on 30 October. Still building: an invite-only beta, starting with friends' households, is being prepared.

Stack

  • App: a React progressive web app (Vite, React 19, TypeScript) that works offline, on Vercel's free plan
  • Data today: private repositories and a hosted database
  • Data next: a hosted Postgres database in the UK, with per-household access rules and sign-in by emailed code; built and tested against stand-ins, not yet switched on
  • Models Fold calls (as of October 2026): Claude Opus 5.5 reads recipe photos, links and pasted text; Claude Haiku 5.5 reads book covers and checks every drawing; Google's Nano Banana 2.1 draws dishes and technique steps
  • Spend guards: a per-household allowance and a daily cap on Claude calls, which fails closed
  • Checks: a validator and a matching save check, unit, data and layout tests, and six review agents (Fold's review panel)
  • Built by: a Claude chat session writing specs as UPDATE files, and a Claude Code session building, in one repository

Demo. Request an invite to the beta; the stack is above.

Fold started as decluttering. I wanted one master copy of the recipes I actually cook from my cookbooks, readable on an iPad and printable, in a form that suits a household where not everyone eats the same. Nothing I could buy did that, so I built it. It has become something more specific: a vegetarian kitchen that knows who's vegan, shows how each recipe could be made vegan where possible, where to split it into two pans, and how much each person needs. It's deliberately not "for vegans"; it's for the mixed table.

Fold's introduction card: a risotto split into two pans, three vegetarian portions and one vegan, beside the line 'Cook once, for everyone at the table'.
How Fold works: one recipe, split where it goes vegan. November 2026.

How it's built

Two Claude sessions share one folder. A chat session handles product, design, specs and research, and writes each piece of work as an UPDATE file straight into the repo (84 by 1 November). Claude Code does the engineering, branches, tests and merges, and sends REQUEST files back when it needs a decision. I coordinate and own the decisions. Small fixes take a fast lane, where CI merges them when checks pass, "so fixes ship even when Emily is out of credits"; features take a gated lane, and anything that changes stored data waits for me.

At its peak, 181 commits reached the main branch in a single day (28 October). No person could review that line by line, which is why Fold has a review panel.

Never loss-making

The rule: no free action triggers inference, and every AI cost is prepaid by the household that causes it, under a hard global ceiling. I wrote it down as a rule on 29 October, but the guards came first: a per-household allowance from 17 October (now 60 recipe reads to start, then 20 a calendar month), and from 24 October a global daily cap on Claude calls, taken atomically so parallel requests can't both slip past. If the cap can't be counted, nothing is called. The family and the friends' beta are subsidised by me; the rule applies from the first public release. October's bills came to about £72, most of it one-off setup (the ledger). The honest caveat: Fold's own cost log is calculated per call from a price table, and hasn't yet been reconciled with those bills.

What I got wrong

  • I added complexity without checking it was warranted. Fold began with my own family's needs, so its first features needed no outside evidence. Once I began to see its wider potential, the nice-to-haves went in as well, because at the speed AI builds nothing forced me to descope them; I think that's the real risk of building this fast. Allergies are the clearest example: Fold collected allergy profiles and used them to hide a recipe or show a warning on it, which seemed like a good idea at the time, but I hadn't realised the risks, including legal risks, and I removed allergy profiles on 30 October (decision 10). The Know-how section of technique guides is another; it's a nice-to-have rather than core to the app, but it has been very complex to build well, especially the illustrations. The next point is how I found out.
  • The problem statement was never written down whole. I had three partial records of it: decluttering (15 October), cooking mid-flow (16 October) and "cook once, for everyone" (28 October). After about 700 commits in a fortnight, my AI builder team and I wrote a reverse PRD, reconstructing the intent from what had been built. It read those three records as two pivots, which they weren't: it was always one problem, and I've now recorded it whole. More usefully, it found there were no success or stop rules for the beta at all. The response is now a house rule: every new piece of work names the assumption it tests, or it goes to the backlog.
  • I broke my own staging rule. The spec said paid photo-to-recipe should wait for evidence from cheaper stages; it was built on day two.
  • Free tiers ran out. I won't pay for GitHub or Vercel, so they're hard limits rather than bills. October used 2,163 Actions minutes against 2,000 free, 2,162 of them on CI, and runs stopped on 26 October, and Vercel's 100 deploys a day ran out on 28 October, so nothing could go live for a day. Those limits changed how Fold is built more than the money did: deploys are rationed, docs ride with code, and CI only runs what a change needs.
  • A check failed open. For two days the save check crashed and reported "no errors" for every save, and invalid data reached the main branch. Now a crash means "couldn't be checked".
  • First use is hard. Three family testers were overwhelmed or missed key features, which is evidence against one of my riskiest assumptions.
  • The scheduler toasted risotto rice 49 minutes early, because nothing in the data said it couldn't wait.

The riskiest assumptions, and where they stand

The reverse PRD mapped sixteen assumptions and ranked them by risk and uncertainty. The scores are judgement, not measurement, and they're there to order cheap tests rather than to justify building anything. These matter most:

AssumptionWhere it stands
New households will add their own books, unaidedThe riskiest. Untested: no household outside my family has used Fold yet
The mixed-table problem is real and frequentAssumed. A survey and five conversations are planned
There are enough mixed households who cook from books to sustain a small productAssumed. A rough bracket is 150,000 to 250,000 UK households, before narrowing to those who cook from books and would pay
First-timers can learn FoldEvidenced against: three family testers were overwhelmed or missed key features. The fix is untested with a new user
AI reads need only a light checkUnproven. There's no reference set yet, and the save check once failed silently for two days
One person with two AI sessions can keep this pace safelyEvidenced, but strained: CI stopped, there were no backups, and the deploy limit was hit
AI reads are safe enough to hide recipes from someone with an allergyRemoved rather than tested: Fold no longer holds allergy data about anyone (decision 10)
Forecasts ("ready at 19:30") are accurate enough to trustWaiting for the beta: the family's logs are too thin to say

No claim on this page rests on measured usage yet.

Research before outsiders

Before any household outside my family used Fold, I ran nine Perplexity prompts as desk research, ending with one that tried to prove there was no market. It sharpened the audience (cooks with big cookbook libraries are why people would start; the mixed table is why they'd stay) and the pricing (pay upfront for a first batch, so the expensive part is prepaid). What it couldn't tell me is how many households like mine exist, so a two-part survey is next, with its thresholds agreed before any results arrive.

A cookbook's page in Fold, with the recipes as illustrated cards, a 'Vegan or can be made vegan' filter and a key to the timing bars.
One of the household's cookbooks in Fold, every recipe drawn in the same style.

What's next

An invite-only beta, starting with friends' households and open to anyone who cooks for mixed diets and will tell me how it goes, at fold.emilybuilds.ai, once its safeguards are in place. Three are done: allergy profiles are gone (decision 10), the review panel is merged, with all six reviewers now run (the cost and recipe reviewers for the first time on 1 November), and CI runs on Fold again. The rest aren't yet. The reviews of the beta's accounts work found 13 security issues and 15 privacy issues. The one Critical is moot now that allergy profiles are gone; the rest are waiting for my decisions. The nightly backup isn't set up yet (it failed all three of its recent runs), and I'm setting it up next. The accounts also need trying against a real database rather than stand-ins, and before any household outside my family adds a book, I want a legal view on copyright.

If you're building fast with AI and trying to keep the evidence in step, I'd be glad to compare notes. Get in touch.

Then / Now

AspectWhen it bit, October 2026By 1 November 2026
GitHub Actions minutesCI ran in full on every push: 376 runs used up October's free minutes by 26 October, and after that only local checks stood between a change and mainData and docs changes skip the code steps, superseded runs are cancelled, and layout tests run only when they're relevant, aiming to average under an hour a day
Vercel deploysEvery push to main deployed, testers' saves included, and the 100 a day ran out on 28 OctoberOnly main and preview branches deploy; docs ride with the code they describe; branches are pushed when ready, not after every commit
My Claude usageOften ran out mid-session, with testers using FoldSmall increments that are always shippable, handoff notes after each one, and reviews run at the depth a change needs
A check that failed openFor two days the save check crashed and reported "no errors" for every saveA crash means "couldn't be checked", and the build runs the validator first, so an error on main stops the deploy
Knowing what it's forThree partial records of the problem, and no success or stop rule for the betaThe problem recorded whole, a ranked assumption map, and every new piece of work naming the assumption it tests

Who did what

I framed

  • The problem: one usable copy of the recipes we actually cook, for a household where not everyone eats the same
  • The ambition: a portfolio build exploring whether Fold can become a small business, on condition that it never loses money
  • The constraints: free tiers only for GitHub and Vercel, and no household outside the family until the safeguards are in
  • The team: a chat session writing specs and a Claude Code session building, passing UPDATE and REQUEST files between them
  • A per-household allowance on recipe reads, and a daily cap on paid calls that fails closed
  • Rationing deploys, with only main and preview branches deploying
  • Reading recipes from photos with a paid model on day two, ahead of my own staging rule
  • The reverse PRD, written with my AI builder team: what Fold is for, reconstructed from what had actually been built

I set up the team

1 reviewer · 1 builder session · 2 planning sessions · 3 models in the product · 2 people · 8 standing rules · 7 constraints

See the team ↓

I decided

  • The problem never pivoted: the three dated statements were partial records of one problem, so I corrected the reverse PRD
  • Two lanes: small fixes merge once checks pass; features merge once every local check passes, because I review most things in production; changes to stored data wait for me
  • New work names the assumption it tests, or goes to the backlog
  • The friends' beta goes through the full database migration, not a thin separate copy
  • Fold holds no allergy data about anyone; allergens are a label on each recipe
  • Web-first through the beta and a first launch
  • Nano Banana 2.1 to draw, after a side-by-side trial

Claude built

  • Fold itself: 84 UPDATE specs from the chat session; the code, tests, merges and releases from Claude Code
  • Proposed, and I approved: allergen labels that say who checked them
  • Proposed, and I approved: "Too late" only for a planned meal
  • Proposed, and I approved: grouping the queued work into one release

The team

How the team workedMe at the top, then the people working with me, then lanes for Plans, Builds, Reviews, In the product. Arrows show briefs from me to Plans; specs from Plans to Builds; changes from Builds to Reviews; findings from Reviews to Builds; calls from Builds to In the product; questions only I can answer from Reviews to me. Inside 8 standing rules and 7 constraints.How the team workedMe at the top, then the people working with me, then lanes for Plans, Builds, Reviews, In the product. Arrows show briefs from me to Plans; specs from Plans to Builds; changes from Builds to Reviews; findings from Reviews to Builds; calls from Builds to In the product; questions only I can answer from Reviews to me. Inside 8 standing rules and 7 constraints.

Agents and models

NameRoleModelWhat it was for
Chat sessionPlansClaude Opus 5.5Product, design, specs and research; writes each piece of work as an UPDATE file in the repository (84 by 1 November)
Builder teamPlansClaude Opus 5.5Wrote the reverse PRD and assumption map with me, as a product team in one chat (UX lead, CTO and product voices)
Claude CodeBuildsClaude Opus 5.5Engineering: branches, tests, merges and releases; sends REQUEST files back when it needs a decision (13 so far)
Review panel (six agents)ReviewsClaude Opus for security and privacy; Claude Sonnet for the other fourIndependent checks from a fresh context, called for the changes that need them; see Fold's review panel
Recipe readerIn the productClaude Opus 5.5Reads cookbook photos, links and pasted text into recipes; the most expensive tier, kept until a reference set shows a cheaper model is as accurate
CheckerIn the productClaude Haiku 5.5Reads book covers, and checks each drawing against the recipe
IllustratorIn the productGemini Nano Banana 2.1Draws dishes and technique steps from written notes, never from the book's photograph; won a side-by-side trial at about half the price

People

  • Me Product owner: set the problem and the constraints, coordinated both sessions, made the calls
  • Family testers Three family households with access to Fold; their feedback and their thin usage logs are the only usage evidence so far

Standing rules

  • Small increments, always shippable, with handoff notes after each, so work survives my usage running out
  • main is production: every piece of work on its own branch and pull request
  • Changes to stored data are tested against a copy of the real data, must be reversible, and wait for me
  • Every paid call counts against a daily cap, and recipe reads against an allowance too; if the cap can't be counted, nothing is called
  • Deploys are rationed: docs ride with code, and branches are pushed when ready
  • New work names the assumption it tests, or goes to the backlog
  • Decisions are logged with their reason and what would reverse them
  • Commits cite the spec or brief behind them

Constraints and unblocking

  • GitHub Actions: 2,000 free minutes a month. October's ran out on 26 October, and I won't pay for more
  • Vercel's free plan: 100 deploys a day. They ran out on 28 October
  • My Claude plan (Max 5x), whose usage often runs out mid-session
  • Inference I pay for: £32.67 for Gemini and $52.79 for Anthropic in October, mostly one-off setup. Gemini's image models had no free tier as of November 2026, and a standard budget alert only warns
  • Fold's own limits: 60 recipe reads per household to start, then 20 a calendar month, and a daily cap on Claude calls across Fold
  • Unblocked: approved the dish and equipment drawings before they went live, and every proposed recipe-tag change before it was applied
  • Still mine to do: the accounts database, the email domain and DNS for fold.emilybuilds.ai, and setting up the nightly backup

Reviewers

  • Me Final say on stored-data changes, drawings, accepted risks and product decisions
  • Fold's review panel Six fresh-context reviewers for security, privacy, QA, cost, analytics and recipe truth

Tools

  • Claude Code The building session, working in the repository on branches
  • Claude chat The planning session, writing UPDATE specs straight into the repository folder
  • GitHub Private repositories for code, pull requests, and testers' saves
  • GitHub Actions CI, on the free monthly minutes only
  • Vercel Hosting and deploys, on the free plan
  • Perplexity Nine prompts of desk research on the market, ending with the case against
  • Decision log and handoff files Decisions with reasons and reversal conditions; where the work stands, for the next session

Ledger

ItemValueBasisNote
Commits, 15 to 30 Oct1,073 across all branches: 682 code, 240 merge, 151 data saves (917 on main)MeasuredFrom git history. My separate logs repository adds 23 (as of 29 October) and is not included.
ReleasesElevenMeasuredGit tags v1.0.0 (18 October) to v1.10.0 (1 November).
Recipe readsAbout 10 to 25¢ (about 7 to 19p) eachModelledFrom token counts and a price table, 8 to 12¢ (about 6 to 9p). Fold's first cost audit (1 November) models about 10¢ (about 7p) with the prompt cached and about 25¢ (about 19p) without, and whether the cache hits in use isn't measured yet; one measured spot check, four real reads, came to about $0.77 (about 57p).
Drawings$0.034 (about 3p) each ($0.017, about 1p, in a batch)ModelledThe list price in Fold's code as of October 2026, plus a Haiku check of a fraction of a penny. Trials and redraws aren't in it: see the Gemini bill below.
Gemini API, 1–29 Oct (mostly one-off setup)£32.67MeasuredBilling. About £28 on a single day (~26 Oct), then roughly £1–1.50 a day.
Anthropic API, October (mostly one-off setup)$52.79 (about £39)MeasuredBilling. Spikes of ~$31 (about £23) on 17 Oct and ~$16 (about £12) on 18 Oct, then under $5 (about £4) a day.
Combined inference, Octoberabout £72ModelledThe two bills added, with the Anthropic bill at HMRC's monthly rate for October 2026. Gemini covers 1 to 29 October, Anthropic to about 30 October. All of it is Fold.
Hosting, database, email and CI£0MeasuredAs of October 2026.
Per recipe, Anthropic (one-off setup)under ~$0.20 (about 15p)Upper boundA ceiling from the bulk days, not a unit price.
Per recipe, Gemini (one-off setup)~£0.10Upper boundA ceiling from the bulk days, not a unit price.
Active session time, 15 to 30 Octabout 54 to 89 hours, depending on the cut-offModelledElapsed. From Fold's Claude Code transcripts, 18 sessions, parallel sessions counted once. 54.3 hours counting gaps under 10 minutes; about 75 at 30 minutes; 89 at 60. Includes Claude working unattended and excludes chat-only work, so this is not hours worked.
My own interaction timeat least 10.2 hoursModelledWorked, as a floor: gaps under 10 minutes between my turns, overall, 14 to 31 Oct. Misses reading time.
Turns and messages328 turns from me; 9,510 assistant messagesMeasuredFrom the same transcripts. Several sessions had no turns from me because another session started them.
Claude planMax 5xMeasuredAs of October 2026. Plus my Claude subscription, which I use for everything else too. Listed separately, not apportioned.
Claude Code usage (subscription)Opus about 8.2M output and 4.2bn cache-read tokens; Sonnet about 0.16M outputMeasuredCovered by the subscription, not billed per token, so it is not money spent. Separate from the measured API bills above.
Measured
counted or timed directly
Modelled
estimated from a stated method
Upper bound
the most it could be
Estimated
my own estimate, not measured

Time figures say whether they are elapsed or worked. Time between commits is never presented as hours worked.

Non-sterling costs show the amount paid, with an approximate sterling figure at that month's average rate. Rates from HMRC's monthly exchange rates.

Outside the lab

What this would take in an organisation.

When building gets cheap, the scarce thing in an organisation stops being engineering capacity and becomes the discipline to stop. Fold''s first features served my own family, so they needed no outside evidence; the trouble started when I saw its wider potential and added a fair amount of complexity without checking whether it was warranted. When AI builds this fast, nothing forces you to descope the nice-to-haves, and I think that''s how escalation of commitment now arrives, at machine speed. What worked here would work in a team. Write the problem down whole before the backlog grows, make every new piece of work name the assumption it tests, and agree in advance what result would make you stop. Hard limits helped as much as rules did: free quotas that stop the service rather than bill it changed how Fold is built more than the money did, and a cost rule written before launch is easier to keep than one retrofitted after the first bill. In an AI product team I'd want an assumption map that gets read rather than filed, and a named person who owns the decision to stop.

Notes from this build