Day 1 · Lesson 6 of the series — Day 1 capstone

The Economics: Why the Dial Is a CapEx/OpEx Curve

Vibe coding isn't cheap. It's a loan at a high interest rate.

Five lessons built the system. This one puts a price on it, and reveals that the dial from Lesson 1 was an economic curve all along. Where you sit on it isn't just a discipline choice; it's a decision about when you pay.

Recall first (spacing — answer before reading on)

From Lesson 4: why is static context expensive?

It loads on demand
Every token, every call
It never loads at all

Every token is present in every interaction, billed each time. Hold that: the token economy is the hidden meter running under everything below.

The one idea: velocity is the wrong question

The conversation about AI usually begins and ends with velocity, how fast can we write code? For anyone accountable for a budget, the sharper metric is Total Cost of Ownership: the upfront cost to build (CapEx) versus the ongoing cost to run, fix, and maintain (OpEx). And in the AI era, OpEx is dictated by the token economy — every interaction is metered.¹

Now re-read the dial as a money curve:

            CapEx (build)      OpEx (run/fix/maintain)
VIBE CODING   ~nothing    ▁▁    ██████████  HIGH   ← the hidden debt
AGENTIC ENG   ██████ high       ▁▁▁         LOW    ← the investment
                                └ marginal cost per feature drops sharply

The hidden debt of vibe coding (low CapEx, high OpEx)

Vibe coding looks free: a subscription and a few prompts, near-zero CapEx. But it hides a compounding OpEx bill:¹

Token burn rate — dumping massive unstructured files into context and repeatedly asking the model to fix its own unverified mistakes. An expensive "prompting loop" with low first-pass success.
Maintenance tax — ad-hoc code lacks structural consistency; six months on, engineers spend days reverse-engineering AI-generated "spaghetti."
Security remediation — no eval harness means vulnerabilities ship as fast as features, and fixing a flaw in production costs exponentially more than catching it at design.

The investment of agentic engineering (high CapEx, low OpEx)

Agentic engineering flips the model: a deliberate upfront investment, API schemas, deterministic test suites, structured context, before a line of production code. The CapEx is higher, but the marginal cost of shipping and maintaining each feature drops dramatically, because the AI operates inside a governed factory: its output is structurally sound, pre-tested, and aligned.¹ That is the CapEx/OpEx flip, and it is the dial, seen through money.

Two levers that bend the curve

1 · Context engineering as a financial lever. LLMs charge per token; passing a 100,000-token repo into every prompt is financially unviable at scale. A dense, high-signal payload (a precise AGENTS.md, sharp guardrails) raises first-pass success and avoids the costly trial-and-error loops that define vibe coding.¹ (This is Lesson 4, now with a dollar sign.)

2 · Intelligent model routing. Vibe coding pays premium frontier prices for everything — even to fix a typo. A well-designed factory routes each task to the cheapest model that can do it:¹

Task	Model tier	Why
Requirements, architecture, initial implementation	Large frontier (premium)	High-complexity reasoning
Test generation, code review, CI monitoring	Small, fast, cheap	Deterministic, lower-complexity

Orchestrating a multi-model ecosystem keeps output quality high while systematically driving down token OpEx. This is the harness's orchestration logic (Lesson 2, component 4) paying off — and it's how you orchestrate the cheap 80% while reserving frontier models (and your own attention) for the expensive 20% (Lesson 5).

Linkage: this is Day 1, priced

DIAL (L1)      right = pay CapEx now to slash OpEx later
HARNESS (L2)   routing logic = the cost lever; build-once asset
FACTORY (L3)   the CapEx that makes marginal cost per feature ~0
CONTEXT (L4)   dense payload = higher first-pass success = lower token bill
MODES (L5)     orchestrate cheap models for the 80%, conduct the 20%

Every earlier lesson was also an economic argument. "Structure scales, vibes don't" turns out to be a statement about OpEx.

The governance layer, on cost

Governance overlay · Lesson 6

Cost is a governance pillar, not just a budget line

Unchecked token spend is exactly VERDICT's C Cost & Compliance problem, and its control is a spend cap: an automated circuit-breaker that halts an agent exceeding a threshold. That's a R Runtime Control mechanism: it only works while the agent runs, not at the next monthly invoice. VERDICT treats a runaway cost event the same way it treats a runaway action event, Knight Capital lost $440M in 45 minutes; an unbounded agent fleet burns a token budget just as fast.

Ladder read: cost observability (per-agent token/latency metering) is part of L2 Observed; enforced spend caps per agent are part of L3 Controlled. If you can't see what each agent costs, you're governing blind, and the OpEx debt above compounds unwatched.

Through your three lenses

Individual (IC)

Stop paying frontier prices for cheap work, route deterministic tasks to small models. And invest context upfront: a dense AGENTS.md buys first-pass success, which is the cheapest token you'll ever spend.

Team

Treat the harness and factory as shared CapEx that amortises across every project. Set a model-routing policy, and measure two numbers as a habit: first-pass success rate and token cost per shipped feature.

Organisation

Fund AI as an engineering investment (CapEx), not a productivity feature. TCO, not velocity, is the metric. Standardise a multi-model ecosystem and enforce spend governance, the C pillar, before the fleet scales.

Check the reflex

Recall, don't re-read.

Agentic engineering's economic profile is —

High CapEx, low OpEx
Low CapEx, high OpEx
Zero CapEx, zero OpEx

You invest upfront (schemas, tests, context) so the marginal cost of every later feature drops. Vibe coding is the inverse, cheap to start, expensive forever after.

A well-designed factory sends test generation to —

The biggest frontier model
No model, humans only
A smaller, cheaper model

Model routing: deterministic, lower-complexity work goes to fast cheap models; frontier models are reserved for architecture and hard reasoning. Paying premium for a typo is pure waste.

You orchestrate a fleet of agents overnight. The cost guardrail you need is —

A spend-cap circuit-breaker
A larger context window
A faster frontier model

VERDICT's C + Runtime Control: an automated cap that halts an agent exceeding a threshold while it runs. Without it, a runaway loop burns the budget before the invoice ever arrives, the cost version of walking away blind (Lesson 5).

Carry this into the week

Pick one recurring agent task you run on a frontier model. Ask: "could a small, cheap model do this deterministic job?" Route it down a tier and watch the token bill. That single move is the economics lesson, banked.

Go deeper (primary source)

Addy Osmani's "The Factory Model" and his workflow write-up both dig into the economics of CapEx-heavy, OpEx-light development. For the token-economy mechanics, the Day-3 companion paper on context engineering goes deepest.

Notes

Osmani, Saboo & Kartakis, The New SDLC With Vibe Coding (Day 1), "The Economics of AI Development" pp.39–42 (CapEx/OpEx, token economy, context as financial lever, intelligent model routing).

Day 1 complete. ✓ You've got the whole conceptual frame: the dial, the harness, the factory, context, the two modes, and the economics, six zoom levels of one system.

Up next → either a Day-1 synthesis checkpoint (recall the arc, no new material) or straight into Day 2, Agent Tools & Interoperability with MCP (how agents act on the world). Your call.