Case study · AI development economics

The $7.10 Bridge

An AI coding agent built a working 3-D Golden Gate Bridge simulator in 78 minutes of measured machine time. Pricing the tokens and the counterfactual engineer tells a sharper story than either number alone.

Fly the 3-D bridge ↗ Browse the code on GitHub ↗

Somewhere on a laptop there is a session log with an unremarkable name — session_935268ec — that records the construction of a bridge. Over eight user prompts and 123 successful model responses, the Kimi Code agent (model k3, thinking effort set to maximum) wrote an interactive Three.js application: a procedurally generated Golden Gate Bridge with terrain, water, sky, fog, day-and-night lighting, simulated traffic, orbit and free-flight cameras, and its own browser-automation scripts for taking screenshots of itself. About 1,250 logical lines of application and automation code, working in a browser, from a standing start.

What makes this session worth writing about isn't the demo — it's that the whole thing was audited. The local session artifacts record every request, response, token, and failure, which means we can do something usually impossible with AI-productivity anecdotes: put honest numbers on both sides of the comparison.

78 minutes, counted the hard way

The lazy number would be wall-clock time, and it would be wrong. The session hit Kimi's subscription rate limit twice and sat idle for long stretches while no agent work was happening. So the audit counts only active agent-turn time: for each of the seven agent turns, the span from the first logged request to the last successful response, with inter-turn gaps and failed rate-limited requests excluded. The sum is 1 hour, 18 minutes, 21 seconds.

Where the 78 minutes went

Active span per agent turn · hover a bar for detail

Turn 0

29m 12s

Turn 1

9m 6s

Turn 2

7m 44s

Turn 3

25m 10s

Turn 4

58s

Turn 5

2m 19s

Turn 6

3m 52s

Notice the shape: one 29-minute opening turn where the agent laid down the scene, a long middle turn where it resumed a big visual-quality pass after a rate limit, then sub-4-minute turns at the end. The expensive thinking is front-loaded; the tail is cheap course corrections and quick questions.

The entire spec was eight messages

The audit also preserved what the human typed, verbatim. It is worth staring at, because it is the full extent of the specification the agent received: eight casual messages, about 110 words in total, original typos included (“Cloudfare” appears twice).

Three things stand out. First, the ratio: the opening two-sentence request bought 29 minutes of autonomous implementation, and the single word “continue” bought 25 more. Measured in words, the leverage on the human side is even more extreme than the leverage on the cost side.

Second, none of this is “prompt engineering.” These are the messages you would send a contractor: an idea, a bug report (“it feels like stuck in the middle”), an ambition (“photo realistic as much as possible”), and some deployment questions. What they do encode is judgment — asking for a plan first, describing the camera problem by its symptom, knowing when to stop polishing and start shipping. The words are cheap; knowing which words, and when, is the human contribution the cost ratios can't see.

Third, the anticlimax: the final message — a question about a Cloudflare deploy command — was never answered. The session's second rate limit killed it, and the deployment was finished later, outside the measured session. Even a 175× acceleration still ends its day hitting a quota.

14.5 million tokens, and why they cost so little

The session processed 14,501,830 tokens. That sounds enormous until you see how they break down:

Token composition of the session

14.50M tokens processed · share of total

Cached input · 96.3%

Cached input 13,959,273 · 96.26% Uncached input 425,631 · 2.94% Output 116,926 · 0.81%

96.26% of everything the model processed was cached input. This is the signature of agentic coding: at every step, the agent re-reads a large, growing working context — the codebase, the conversation, its own prior tool results — and prompt caching makes that repetition roughly a tenth the price of fresh input. The actual new material was tiny: about 426K tokens of uncached input and just 117K tokens of generated output. The economics of AI-built software turn out to be, above all, the economics of caching.

One honest footnote: the session ran on a flat-rate subscription, so no per-session invoice exists. The $7.10 is the API-equivalent value of the tokens at published prices — a reproducible yardstick, not a bill.

The counterfactual engineer

Against what should we compare 78 minutes? Lines of code are a poor measure for 3-D graphics work, where most of the effort is visual experimentation — tuning geometry, lighting, materials, cameras, and GPU performance until it looks right. The audit instead builds a bottom-up estimate for an experienced Three.js developer working from a clear spec, reusing Three.js rather than writing an engine:

Manual implementation estimate

Experienced Three.js developer, clear specification

Work area	Developer-days
Scene architecture and rendering pipeline	2–3
Procedural bridge geometry	5–8
Terrain, water, sky, lighting, and fog	4–7
Orbit, free-flight, presets, and object interaction	3–5
Traffic and day/night effects	2–4
Visual tuning, debugging, and browser validation	4–7
Packaging vendored assets and automation scripts	1–2
Comparable scope	21–36 days

Put the two side by side and the ratio becomes almost cartoonish. The midpoint manual estimate is 175 times the measured active AI time:

One square = one 78-minute AI session

The midpoint manual estimate (228 hours) equals 175 of them

The entire AI build Estimated manual work, midpoint (each square = 78 min)

Manual labor at the central estimate costs roughly 3,200 times more than the tokens that did the work. But that ratio is leverage, not savings.

Why this project was a best case

Before generalizing, it's worth naming why this particular project was unusually well suited to an agent:

• The output was visually checkable. The app renders in a browser, so the agent could iterate screenshot-by-screenshot against something demonstrable.
• Three.js did the heavy lifting. A mature engine supplied rendering, controls, water, sky, and post-processing — the agent composed, rather than invented.
• Procedural geometry beat hand-authored assets. Code is a compact way to describe a bridge, and code is what models are best at producing.
• The loop closed inside one session. Edit, serve, inspect, refine — the agent ran the whole cycle with tools, without waiting on a human.
• Caching kept the growing context cheap — the 96% figure above is what made 123 model calls affordable at all.

What the numbers don't prove

The report behind this article is unusually careful about its own limits, and the article should be too:

The defensible claim is narrower than the eye-popping ratios, and it is still remarkable: for this project, an AI agent produced a substantial, working 3-D application in about 78 minutes of measured active time, using tokens worth about $7.10 at API prices, where a comparable manual build plausibly represents several weeks of expert work.

The insight to carry away isn't "software now costs seven dollars." It's that when a task is demonstrable, composable from mature libraries, and iterable inside a closed tool loop, the marginal cost of implementation collapses by orders of magnitude — and the scarce, expensive inputs shift to the things the ratios deliberately exclude: knowing what to build, steering the agent, reviewing the result, and owning it afterward.