Skip to content
Index

Software 2026

This Site, By the Numbers

A meta case study — this very portfolio is built and maintained by an autonomous AI-agent pipeline, and this page charts the receipts. The hook is 97× cost leverage: $110.73 of API spend produced an estimated $10,778 of human-equivalent labour.

  • Claude Code
  • Gitea
  • Cronicle
  • Astro
  • Data Visualization

fig.01 - the headline

Cost leverage

97×

$110.73 of Claude API spend produced an estimated $10,778 of equivalent human labour.

Jun 13 → Jun 27, 2026 · 52 issues · 5.8 h of compute

This page is a portfolio project about this portfolio. The site you're reading is built and maintained almost entirely by an autonomous AI-agent pipeline — and every run that pipeline makes is logged. The charts below are a real snapshot of that log: how much it cost, how much time it saved, and why the economics work out the way they do.

The portfolio measures itself.


fig.02 - cost vs. value · log scale

A rounding error against the labour it replaces

Plotted on a base-10 log axis so the API bar stays visible next to the human-equivalent figure it's dwarfed by.

$110.73 Claude API spend $10,778 Human-equivalent labour

fig.03 - time · compute vs. human

5.8 hours of compute, 104.8 hours saved

Roughly 18× wall-clock compression — about two-and-a-half work-weeks of estimated human effort, done in a single afternoon of agent time.

Claude compute 5.8 h Human time saved 104.8 h

fig.04 - effort by category · est. hours saved

Where the saved hours went

Estimated human-hours saved per job category. Planning issues are cheap to run but stand in for the most human deliberation.

planning 66.5 h · 21 runs · $45.89 sysadmin 25.5 h · 33 runs · $55.18 scripting 9.8 h · 3 runs · $6.76 dashboard 3 h · 1 runs · $2.90

fig.05 - throughput · cumulative issues closed

52 issues over 13 days

Cumulative issues completed across the window. A burst at launch, then a steady maintenance cadence as the weekly bot took over.

52

fig.06 - token economics · why it stays cheap

Caching does the heavy lifting

84.0M cache-read tokens versus 327K in / 795K out. Cache reads bill at a fraction of fresh input, so re-reading the whole repo each run barely moves the cost.

  • Cache reads 84.0M 98.7% 83,996,095 tok
  • Output 795K 0.9% 794,872 tok
  • Input 327K 0.4% 326,531 tok

fig.07 - complexity mix · runs by tier

Mostly small, self-contained work

Each issue is heuristically tagged with a complexity tier. Keeping work small enough to finish in one ~15-minute run is what makes the pipeline reliable.

medium 25 runs · 79 h est. small 17 runs · 12.8 h est. trivial 15 runs · 5.1 h est. large 1 runs · 8 h est.

fig.08 - the snapshot · core numbers

The full readout

Calendar span
13 days
Issues completed
52
Agent sessions
57/58 ok
Total API cost
$110.73
Avg cost / issue
$2.13
Claude compute
5.8 h
Human time saved
104.8 h
Human-equiv. cost
$10,778
Avg ROI multiplier
116×
Code churn
+5,504 / −2,149

° estimated · all other figures measured exactly


fig.09 - reality check · external validation

But is the $10,778 a real number?

The headline leans on one estimated figure — the $10,778 of human-equivalent labour. A model produced it, so it's fair to ask whether it survives contact with the real world: what would it actually cost to hire a human to build a site of this scope — a hand-coded Astro portfolio with 52+ shipped issues, 32 case studies, bespoke inline-SVG data-viz, full theming, accessibility work, and motion design? Two independent checks, below, both bracket the number.

Check 1 · top-down — what a shop would quote

Drop $10,778 onto the going rate for a custom-built (not templated) multi-page portfolio in 2026. It lands right where a freelancer hands off to a small agency — the lower-middle of the custom band, not an inflated outlier.

Freelance, custom build $7.5k–$15k Studio / agency, custom $10k–$50k+

Check 2 · bottom-up — the implied hourly rate

Run it the other way: $10,778 ÷ 104.8 estimated human-hours is a blended $102.84/h. That's an ordinary US mid-level developer rate — comfortably below what a senior who can architect bespoke UI and hand-rolled SVG charts would bill. If the rate is honest, so is the total.

US generalist freelancer $60–$120/h Mid-level developer $80–$130/h Senior developer $130–$200+/h

Both methods converge on the same place. A custom portfolio of this scope quotes between roughly $7.5k and $15k from a freelancer, and $10k+ from an agency; the implied $102.84/h blended rate is squarely mid-market. The modelled $10,778 isn't a best-case fantasy — it's close to the midpoint of what the real market charges, which is the most defensible place for an estimate to land.

The honest caveats still apply: the 104.8 human-hours are themselves an estimate, so this validates the magnitude, not the last dollar. A real human also wouldn't bill 104.8 uninterrupted focused hours, and would carry overhead a token meter doesn't. The claim is only that $10,778 is the right order of magnitude — and the market data says it is.

Sources (2025–26 pricing): freelance & agency project ranges — The Web Factory, Jim.com, Lounge Lizard; hourly rates — Index.dev, Upwork.


fig.10 - the approach

How an issue becomes a deploy

Work is filed as Gitea issues on a self-hosted instance running on the NAS. Each issue is scoped to be self-contained — small enough for one agent to finish end-to-end in a single ~15-minute run.

A Cronicle job runs every 5 minutes. It picks up one open issue assigned to claude and runs Claude Code headless to implement it: read the codebase, write the change, commit, and push.

The push auto-deploys to Vercel, live at www.leoszeto.com. No human in the loop between “file the issue” and “it's on the site.”

Every run is logged to issue-runs.db — cost, tokens, elapsed time, lines changed, estimated time saved — which is exactly the data this page visualises. A weekly maintenance job keeps the site healthy and the numbers fresh.

On the estimates

“Time saved” and “human-equivalent cost” are estimates, not stopwatch measurements — each run is heuristically tagged with a complexity tier and an estimated human-effort figure. API cost, tokens, run count, compute time, and lines changed are measured exactly. The leverage figure is honest about which side of that line it sits on, so the case study stays credible.