Live velocity dashboard
Production economicsJune 16, 2026Data refreshed June 14, 2026

The Cost of Building Software Is Collapsing

Modern engineers with agentic workflows are redefining what it costs to create and maintain software — and what products can eventually charge.

For two decades, software prices were anchored to how many people it took to build and sustain a product. That anchor is breaking. This article uses measured output from my live velocity dashboard to walk the arc: what it used to cost, what it costs now, how large the efficiency gap is, and why that points toward more affordable software — not bigger headcount budgets.

The thesis

When the cost to produce falls by orders of magnitude, the price of software does not have to stay where headcount-era economics put it. Incumbents may hold list prices for a while — margins absorb the gap first — but new entrants can undercut on economics alone. Over time, that is the road back to affordable products and services: clinical tools, vertical SaaS, internal platforms, and consumer apps priced for adoption, not for covering a 500-person delivery org.

~5×

output vs. a 100-engineer team

~$104M–$140M

what that pace used to cost / yr

~388–806×

cheaper to build (full org, onshore)

Step 1 — output is rising

Recent full months measure 401K net lines across managed codebases — roughly 5× a 100-engineer hand-coded team (generous Capers Jones baseline: 750 net lines / developer / month). The chart below shows the trajectory, not month-to-month noise.

Overall trajectory (purple curve) fit to monthly net lines. Faint dots = actual months; the story is the trend, not month-to-month noise. Amber = 100-engineer baseline (75,000/mo). Recent pace ≈5×.
Engineering velocity trend curve0201K401K100 engineers, no AIFebAprJunAugFebAprJunAugOctDecFebAprMaypurple = exponential trajectory

Step 2 — what it used to cost to build & maintain

At this measured pace, a traditional model implies about 535 coders — or a 986-person delivery org once you add PM, QA, platform, IT, HR, leadership, and facilities overhead. That is the old economics software pricing was built on.

Ratios modeled per 100 coding FTEs

  • Engineering managers10
  • Directors / senior eng leadership2
  • Product managers / owners15
  • Program / project managers5
  • UX / product design5
  • Technical writers3
  • QA / test engineers25
  • DevOps / SRE / platform8
  • IT support / helpdesk6
  • HR / recruiting (allocated)5
  • Facilities & corporate overhead+14–23% on payroll
Headcount to match recent output: ~986 FTE across engineering, product, QA, platform, and operations (per 100-engineer ratios).
Delivery org headcount by function6001501340~986 total FTE
Engineering (600)Product & design (150)QA & test (134)Platform / DevOps (43)IT & HR (59)
Onshore payroll by function (mid estimate) before facilities overhead — engineers are the largest slice, but PM/QA/platform add materially.
Onshore payroll stacked by org function$140M$25M$18MPayroll subtotal ~$198M+14–23% facilities / corp overhead → full org below

Engineers only

~$104M–$140M / yr

Floor: coding payroll only, onshore, fully loaded.

Full delivery org

~$194M–$282M / yr onshore

What it actually took to ship at enterprise scale — the cost base behind legacy pricing.

Step 3 — what it costs now

A principal-level AI-native operator with product judgment — fully loaded salary, benefits, and tooling — runs ~$350K–$500K/yr in this model. Same measured throughput band. Radically different production economics.

What it used to cost vs. what it costs now to produce the same measured output (log scale). Top bars = traditional build & maintain; green = modern operator. The distance between them is the production-cost collapse.
Traditional vs modern cost to build the same output$500K$5M$50M$200Mannual cost to build & maintain (log scale)Eng-only$104M–$140MFull org US$194M–$282MFull org offshore$60M–$87MOne operator$350K–$500K← modern production cost; traditional bars are hundreds of times larger

Step 4 — the efficiency multiplier

Divide old production cost by new production cost. Same output, fraction of the spend — roughly ~209–400× on an engineers-only comparison, and ~388–806× against a full onshore delivery org. That is the lever that can eventually show up in what customers pay.

How many times cheaper it is to produce the same measured output today — the efficiency gain that can flow through to product pricing over time.
Production cost efficiency multipliersvs engineers-only (onshore)209–400× cheapervs full delivery org (onshore)388–806× cheapervs full delivery org (offshore)120–249× cheaper

Step 5 — what this means for price

Production cost and list price decouple slowly — contracts, roadmaps, and brand moats lag behind engineering reality. But the direction is clear: when building is ~388–806× cheaper for equivalent output, someone will price like it. A $50K/yr vertical SaaS product with a $200M build org behind it faces a structurally different competitor than one built at modern production cost.

Affordable software is not a charity outcome — it is what happens when creation gets cheap again. Healthcare workflow tools, clinician-facing AI, internal ops platforms: categories priced for enterprise headcount can be re-built and re-priced on efficiency. Not overnight. But the math points there.

Modern engineers are not valued by their payroll line — they are valued by how far they move the production-cost curve, and therefore what products and services can sustainably charge.

What this analysis does not claim

  • Lines ≠ business value. Net LOC is an auditable production proxy — not revenue or clinical impact.
  • Prices do not fall automatically. Competition, regulation, and go-to-market still matter; this is about the floor moving.
  • Not every team can run this way. Senior judgment, domain depth, and disciplined agentic workflows — not tools alone.
  • Cloud and vendors are additive. We model people cost to build; infrastructure bills remain.

See the live production data

Metrics refresh weekly from git history — the input to every chart above.

AI Engineering Velocity