loop0
← From the Loop
2026-11-16

An empty folder, a site online, three ways: what loop0 adds, and what it costs

The same coding agent started three times from an empty folder: build a booking page, then put it online. Alone, and with the host's own skill, it took three minutes and thirty cents. With loop0 it took twenty-one minutes and two dollars, left a project that explains itself, fixed a flaw the two others put online, and handed the owner a link that does not open.

We wanted to know what loop0 is worth on a whole small job, from nothing to a site people can use. So we gave the same coding agent an empty folder three times, with the same two requests, and checked everything it delivered ourselves.

The agent alone did better than we expected. loop0 did what it is built for, at a price, and made one mistake of its own. Here is all of it.

How we tested

Claude Code (Claude Sonnet 5.5) started from an empty folder, three times:

SideWhat the agent had
ANothing more
BFly.io's own skill for agents
Cloop0: its method and its Fly.io expert, as two MCP servers

Two requests, each in a fresh session that knows nothing of the one before:

A booking page for my barber shop. Clients pick a free slot and book it online, no account. I

want to see today's bookings on my phone.

Put this booking app online on Fly.io for my barber shop. It must keep its bookings, and it

should cost as little as possible: tell me what it will cost per month.

Nobody answered questions, and we helped no side. We wrote the grid of checks and what we expected before the first run. Afterwards we checked each site in a real browser at phone width, inside its Machine, in the sessions' records and in the folder. One run per side.

What is online

Side ASide BSide C

Each site during our check, on a phone-sized screen, as we filled in the booking.

All three sites work. On each one we booked a slot on a phone-sized screen, saw it disappear from the free times, sent six requests at once for one slot and got one booking, stopped and started the Machine and found the booking again. None serves a page unencrypted, none shows the bookings without a secret, and the Fly.io token never appeared anywhere.

A · aloneB · Fly.io's skillC · loop0
A client books on a phone, in a real browseryesyesyes
Two clients cannot take the same slotyesyesyes
The bookings survive a stop of the Machineyesyesyes
Cost announced, against ours$2.10 for $2.60$2.09 for $2.60$2.40 at most for $2.34
The barber gets to his page with what he was givenyesyesno
Everything the final answer says is trueyesyesno: that link
Checks passed on what is online, out of 18181816
How the agent itself checked the sitecurlcurla real browser on the live site

By the grid we wrote before the runs, loop0 added nothing to what is online, and lost two lines for one defect of its own.

Our own defect: a link that does not open

Side C protected the barber's page with a key, generated it, and told the owner to paste it after key= in the address. The key was made with base64 and holds a +. A web address reads + as a space, so the page answers this:

The link, built as the owner was toldThe same key, encoded for an address

Side C had tested that page in a real browser, on the live site. The test passed because the test encodes the key. It checked the test's own path, not what the owner would type. Sides A and B handed over a password and a key that work as given.

A flaw the grid did not ask about

The three applications limit booking attempts per address, to stop abuse. Behind Fly.io's proxy an application sees the same address for every visitor, so the limit is shared by everybody.

  • Side A saw it in its second session, wrote it in its answer, and left the code as it was.
  • Side B did not mention it. Its limit is five an hour: after our five attempts, a request from another network was refused. For the rest of the hour nobody could have booked.
  • Side C found it, changed the application to read the visitor's real address, and added two tests. It wrote that it could not check it with two real clients. We did, from two networks: it holds.

Our Fly.io expert knows nothing about this, so the expert did not find it. We cannot say whether the method's rules made the difference between seeing a flaw and fixing it.

What is left in the folder

This is where the sides part.

Side A, everything it left:

server.js      config.json
public/        5 files
Dockerfile     fly.toml
.dockerignore  .gitignore

No test, no commit, no document. Side B is the same, plus a README of five lines.

Side C:

README.md     VISION.md
PRODUCT.md    ARCHITECTURE.md
DECISIONS.md  INFRASTRUCTURE.md
STATUS.md     BACKLOG.md   LOOP.md
docs/adr/     2 decision records
loops/        2 missions, 2 reports
devlog/       3 pages, 9 screenshots
src/          7 files
test/         20 tests
e2e/          2 tests, real browser
e2e-live/     1 test, the live site
Dockerfile    fly.toml  package.json
.github/      .githooks/  scripts/

Eleven files on one side, sixty-one on the other. Two commits, one per request. Each request has its mission, written before the code, and a report of what was checked and what was not.

A long list of files proves nothing by itself, so we tested what it is for.

Eight questions to a session that arrives later

We gave a copy of each folder to a fresh session with no tool but reading files, and eight questions an owner or a new developer would ask. It had to answer from the files alone and say so when the answer was not there. Then we checked each answer against what really existed.

A · aloneB · Fly.io's skillC · loop0
Where is it hosted, in which region?yesyesyes
What does it cost per month?not writtennot writtenyes
How do I put a change online?not writtennot writtenyes
Where are the bookings kept, what does a stop do?yesyesyes
What did the agent choose without asking me?not writtennot writtenyes
What was not checked?not writtennot writtenyes
How do I run the tests?there are nonethere are noneyes
What should be done next?not writtennot writtenyes
Answered from the files, and true2 of 82 of 88 of 8

On sides A and B, the cost, the defaults and what was not checked were all told to the owner, well, in the chat. They are in no file. The next session starts from the code.

We did not take side C's answers on trust. Its README says how to put a change online: we typed the command as written and it deployed. Its test command passed on a fresh copy: 20 tests, 2 of them in a real browser. Its documents give the address, the region, the size, the volume, the snapshots and the cost: all right. Its deployment diagram matches what ran:

The deployment diagram side C left in INFRASTRUCTURE.md
The deployment diagram side C left in INFRASTRUCTURE.md

One statement in those documents is false, and it is the same one: the barber's link, written in two files.

Each request also left a page that tells what was asked, what changed, what was assumed and what was checked:

The page side C wrote for its second request
The page side C wrote for its second request

What it cost

A · aloneB · Fly.io's skillC · loop0
Build the app63 s · $0.1671 s · $0.187 min 5 s · $1.10
Put it online112 s · $0.13100 s · $0.1613 min 37 s · $0.86
Both2 min 55 s · $0.292 min 51 s · $0.3420 min 42 s · $1.96
The site, per month, if always on$2.60$2.60$2.34

loop0 took seven times the time and six to seven times the money.

What we take from it

A coding agent can put a small site online by itself. Three minutes, thirty cents, every line of our grid for what is online. If the site is an experiment you will throw away, connect nothing.

Fly.io's skill changed nothing here, and nothing was wrong for it to fix. The deployment was right on all three sides: one small Machine, a volume, stop when idle, HTTPS only.

What loop0 bought is what stays when the conversation is gone. Tests that pass, a history, a written cost, a way to deploy that works as written, the choices marked as assumed, the list of what was not checked, and what to do next. It is worth eighteen more minutes when somebody will have to change the site, deploy it again or answer for it. It is not worth it otherwise.

It also bought one real fix. Two sides put online a limit that could lock every client out. One side removed it and tested the removal.

It did not buy a hand-over without a fault. With all its checks, side C gave the owner a link that does not open, and wrote it twice. A structure does not replace trying the thing the way its owner will.

What loop0 learns

  • The method: what is handed to the owner is checked by typing it as it was written to them: a link, a command, a password. A test that builds its own path proves the test.
  • The Fly.io expert: behind the proxy an application sees one address for every visitor. The visitor's own is in a header. We measured it on two sides; it goes into the expert.
  • A default: sides A and B set the shop's time zone from the computer's. Side C left UTC and flagged it as its weakest choice. The first guess was the better one.

The limits

One run per side: another run could differ on any line. We built loop0, wrote the grid, chose the eight questions and did the checking. Side C changes two things at once, the method and the expert, and this test cannot say which did what. Only the method asks for documents and tests: an owner who asks an agent alone for a README and tests would get some, at a cost we did not measure. Side C received one sentence that stands in for the owner's go, because the method waits for it.

We kept the protocol, the grid of 33 lines, each side's answers, our checks and everything side C left.