Agencie.io Labs Case study ← All case studies

Case study · Accelerated coding

What it cost to build this — in AI spend and time.

A short case study on the economics of building a full-stack app with an accelerated-coding stack: CloudCode (the coding agent) + CodeEasy (the command center). The app, backend, docs, prototypes, and this whole dev-preview site came together over roughly 3 × 8-hour days of ideation and development, for a total AI/dev spend of about $500 — roughly $200 of autonomous auto-coding plus ~$273 of interactive AI coding. Shared as a data point for CodeEasy and possible labs benchmarking.

For information only. These are real usage captures from CloudCode on this machine — not a quote, a bill, or a committed budget. Costs are token/agent spend (not human time), approximate, and specific to these sessions. Human-directed ideation + development ran ~3 × 8-hour days alongside.

The headline

~$500 total AI/dev spend, over ~3 × 8-hour days

Two components make up the ~$500: autonomous auto-coding (~$200) and interactive AI coding (~$273 — the two captured CloudCode sessions below, $276.71).

~$200
Auto-coding · CodeEasy

Autonomous multi-agent build spend.

~$273
AI coding · CloudCode

Two captured sessions ($276.71).

~$500
Total AI/dev spend

Auto-coding + AI coding combined.

~3 × 8h
Ideation + development

Human-directed days, agents doing the build.

The stack

The accelerated-coding tools

Two tools by the same maker (agencie.io Labs), running on one laptop with a local model — the setup behind the numbers.

The agent · the "how"

CloudCode

agencie.io · autonomous coding agent

“Ship code with AI — not your codebase.” A Claude Code-style autonomous agent that reads, edits, tests, and ships diffs while source (and, optionally, the model) stays in your own perimeter. It was the hands-on driver of every edit and test here.

  • Ran on Claude, no API key — claude-cli (Claude on subscription), auto-routing light→efficient, heavy→Opus. LM Studio local models detected as fallback.
  • Governance — autonomous / safe-only / manual approval modes; per-project boundaries; tool-event hooks; a security "sentinel".
  • MCP + cost tracking — ~130 MCP tools, Code Easy connected; the usage panels below are its own accounting (Opus 4.8 / Fable 5 / Haiku 4.5).
justinjames.agencie.io/products/cloudcode →
The command center · the "what"

CodeEasy

agencie.io · command center + AutoCode

“The command center for the age of AI co-pilots.” A visual dashboard that keeps a human in control while agents work — codebase architecture in seven views, and compact structured context (~2k tokens vs ~50k raw files) fed to the agent so it stays efficient.

  • Multi-Agent Control Center — orchestrates a Codex implementer + a Claude validator in Full-Autonomous mode, with stage gates + decision tracking. Connected here as an MCP (~101 tools, ~8% of usage).
  • AutoCode — an 8-stage governed pipeline: spec → build → testing across 6 layers (incl. live UI) → decision log + session history, with hard guardrails.
  • Codebase intel — architecture graph, functions, and quality flags in real time as the agent changes files.
justinjames.agencie.io/products/codeeasy →
The machine. The entire build ran on one laptop — a MacBook Pro (M3, 36 GB) — with a local coding LLM served by LM Studio, connected to CloudCode. Perimeter control in practice: the code, and a model, stay on-device.
1× MacBook Pro M3 36 GB LM Studio · local LLM
How they combine. CodeEasy frames and governs the what (spec, context, stage gates, AutoCode); CloudCode executes and verifies the how (edits, tests, diffs) — cloud models for the heavy lifting, a local LM Studio model on the laptop at no token cost. That pairing is the accelerated-coding workflow behind ~18.9k lines for ~$500 over ~3 × 8-hour days.
CloudCode terminal boot banner — Codex CLI, LM Studio (2 usable models) and Claude Desktop detected; no API key, using Claude on subscription (claude-cli); 4 MCP servers / 130 tools; Code Easy connected.
CloudCode — boot: local models (LM Studio), 130 MCP tools, Code Easy connected
CloudCode command palette — slash commands including /agents, /claude-cli, /commit, /offline (local model), /sentinel, /security-review, /review, /test.
CloudCode — the command palette (agents, offline local model, security)
CodeEasy dashboard — codebase architecture force-graph for Psychometrictesting; project overview shows 26.3K lines of code, 95 files, 29 directories; seven views (Graph, Treemap, Tree, Arch, Business, User Flow, Planner).
CodeEasy — codebase architecture graph (26.3K LOC, 7 views)
CodeEasy Multi-Agent Control Center — Full Autonomous mode building 'Mirror v1.1'; Codex Watcher running; connected agents Codex (implementer) + Claude (validator); a work queue of IMPLEMENT and VALIDATE tasks; live observability log.
CodeEasy — Multi-Agent Control Center (Codex + Claude, Full Autonomous)

The captures

Two sessions, straight from the tool

CloudCode's own usage panel for two representative sessions — one building the app + ideation repo, one doing this devsite's marketing work. Tap either to view full size.

Session · app + ideation build

"Set up ideation GitHub repository"

Cost $249.95 Wall 10h 57m API 3h 52m Code +12,763 / −1,135
CloudCode usage panel — session total cost $249.95, wall time 10h 56m, 12,763 lines added, models Opus 4.8 ($96.95), Fable 5 ($153.00), Haiku 4.5; CodeEasy MCP 8% of usage.
Opus 4.8 $96.95 · Fable 5 $153.00 · Haiku 4.5 $0.0006 · CodeEasy MCP 8%
Session · devsite marketing

"Add image to marketing pages on Cloudflare devsite"

Cost $26.76 Wall 5h 54m API 49m Code +2,029 / −93
CloudCode usage panel — session total cost $26.76, wall time 5h 53m, 2,029 lines added, model Opus 4.8 ($26.76); CodeEasy MCP 8% of usage.
Opus 4.8 $26.76 · Haiku 4.5 $0.0006 · CodeEasy MCP 8%

The numbers

Cost breakdown

The two captured sessions side by side. All figures ex-VAT token/agent spend, from the tool's own accounting.

Session Wall clock API time Cost Code · models
App + ideation repo build 10h 57m 3h 52m $249.95 +12,763 / −1,135 · Opus $96.95, Fable $153.00, Haiku $0.0006
Devsite marketing work 5h 54m 49m $26.76 +2,029 / −93 · Opus $26.76, Haiku $0.0006
Total (2 captured sessions) ~16h 50m ~4h 41m $276.71 +14,792 / −1,228 lines
This table is the AI coding ≈ $273 ($276.71 captured, CloudCode). Separate from the ~$200 autonomous auto-coding (CodeEasy) — together ≈ $500 total. Two sessions on one machine; not human time.
  • AI coding · CloudCode ~$273
  • Auto-coding · CodeEasy ~$200
  • Architect + builder · three 8-hour days a lot of good coffee
  • One person shipping an app, a backend & this whole site priceless

For everything else, there's Mastercard.

Not affiliated with Mastercard — just the vibe. Internal wink only.

What's possible

One builder, the right tools

The point of the numbers isn't the numbers — it's what they imply about who can now build.

Solo builder + architect

A single technically-fluent operator — one person acting as builder and architect — took this from idea to a working app, backend, docs, prototypes, store pack, and this dev-preview site in roughly 3 × 8-hour days, for about $500 of AI/dev spend.

With an agentic toolchain (CloudCode + the CodeEasy MCP) the bottleneck shifts from headcount and hours to judgment and taste: what to build, how to shape it, and where the hard lines are (privacy, regulatory, safety). The tools do the volume; the human sets direction and holds the standard. That's the benchmarking story worth telling — not "AI writes code", but what one well-equipped person can now ship.

Lines of code

What got written

A snapshot of the repository today (git-tracked, measured with cloc). "Hand-written" excludes generated files like package-lock.json and the vendored Mermaid library. Full breakdown lives in docs/lines-of-code.md.

~18.9k
Hand-written code lines

Across the whole project, all languages.

226
Source files

TypeScript, HTML, SCSS, Markdown, config.

~47k
Incl. generated

With lockfiles + vendored libs counted.

44
Commits · 1 author

Trunk-based, small focused commits.

App Ionic/Angular
8,627
Dev preview this site
5,738
Backend Node/Fastify
3,631
Native shells iOS + Android
1,041
Docs concept + specs
968
Prototypes mock-ups
773
Web funnel landing
538
Store pack listings
309

Code lines by area (git-tracked, excludes blanks/comments). The remainder — root config, scripts, and assets — makes up the balance to ~18.9k.

The code

The repository

Everything above lives in one private GitHub repo — app, backend, native shells, docs, prototypes, store pack, and this dev site.

thejustinjames / Psychometrictesting
github.com/thejustinjames/Psychometrictesting · main
🔒 Private44 commits1 branch1 contributor
Open on GitHub →
GitHub repository view — thejustinjames/Psychometrictesting (Private), branch main, 44 commits, 1 contributor; folders include android, assets, devsite/public, docs, ideation, ios, prototypes, reasurch, scripts, server, src, store, web.
Repository root · one repo holds the whole project

What it shows

Read-outs for CodeEasy & labs benchmarking

Why this is a useful data point, and what drives the number.

A full product for about $500App + backend + docs + prototypes + this dev site — ~$200 auto-coding + ~$273 AI coding — built agentically over ~3 × 8-hour days. A concrete cost/throughput data point for benchmarking.
CodeEasy in the loop throughoutThe CodeEasy MCP was ~8% of usage across both sessions — the spec/plan/context layer the agentic build ran against.
Multi-model auto-routing keeps it cheapOpus 4.8 for reasoning, Fable 5 for bulk generation ($153 of the big session), Haiku 4.5 for cheap turns (fractions of a cent) — the router picks the tier per task.
Long-context sessions dominate cost~91% of usage was at >150k context and ~80% from 8h+ sessions — the expensive part is duration and context, not the edits themselves.
Throughput is the story~14.8k lines added across the two captures — the spend buys volume and iteration speed, not just a few edits.
Reproducible measurementNumbers come straight from the tool's usage panel, so a benchmark can be re-run and compared across models, tasks, and workflows.