The Product Is a Minority of the Work

Ask founders what their company builds and they'll name the product. The git history disagrees.

Ours covers thirty months, two repositories, some 4,500 commits and 2.6 million changed lines: from first line to tens of millions of users, and eight figures in consumer revenue alone. The core capability got 24% of all code change. The machinery around it got 1.5× that — and in the last half-year before we let AI agents in, the machinery briefly took more than half.

We don't think our ratio is unusual. It's the default physics of a scaling product, because features are chosen; machines are summoned — each by a specific event, at a roughly predictable stage. Per stage, then: what to build, what to buy, what to refuse.

The six machines and their total bill:

Geoffrey Moore called everything that doesn't differentiate you context, and the dangerous kind mission-critical context — work that wins no customers and destroys you if it fails. That's most of this chart.

Zero to one: the machines don't exist. Keep it that way.

Our first six months — the ones that decided whether the company would exist — gave the machines 14% of code change and money zero. That was correct. Kent Beck's phase warning applies literally: "applying the approach from one phase to an idea in another phase kills ideas."¹

The advice is a refusal list. A payment link, not a billing system. One language. Auth from a vendor. Logs to stdout. An admin panel, an i18n pipeline, or SSO before PMF is procrastination with dignity.

The one exception is plumbing that costs days now and quarters later:

• An idempotency key on every mutating endpoint.
• Strings in one file, even with one language.
• An append-only event log — actor, action, target, timestamp.
• A tenant model, even while every "team" is one person.

These are the sockets the machines will plug into. Three of the four cannot be retrofitted honestly.

First revenue: money and identity arrive together

The money machine reached our codebase in month five — the first month real revenue did — and never left:

• Give billing an owner at the first chargeback. It's a product now, with adversaries and auditors, and its bugs are denominated in dollars.
• Start the append-only ledger with the first real dollar. Double-entry, corrections as new entries, never edits. Cheap at ten customers, archaeology at ten thousand.
• Fail closed. If the balance can't be written, don't charge and don't suspend. The card's case is the opposite: a billing system charging cards in a loop against a balance it couldn't update.
• Set the fraud dial consciously. The optimal amount of fraud is non-zero³ — zero fraud means you're turning away real customers and can't see it.

Identity arrived in month two, because accounts, teams, and API keys are how a product gets used at all:

One asymmetry decides this stage: the tenant model you cannot buy; nearly everything else you can. Consumer auth is a commodity. Enterprise SSO and SCIM are a commodity — the card's case, three engineers for three months, is the price of building what a vendor sells. Bolting teams onto a single-user schema later touches every table; that's why the fitting goes in at zero.

Going wide: distribution and trust

Distribution was a rounding error in year one. In the second half of 2025 it took 37% of all code change — more than double core's share. Nobody decided to go global; users from countries we never marketed to did.

• SEO is an engineering discipline, not a marketing task. The largest single machine part in our history: sitemaps, canonical URLs, structured data, programmatic pages — all code.
• Never gate a release on translation completeness. Tier locales into blocking and non-blocking with an SLA, or engineers will route around i18n by hardcoding English.
• Automate translation to extinction. Our pipeline now ends in a bot with its own git identity — no human touches routine strings. Mercari's LLM pipeline cut translation cost 100×⁶ the same way.

The moment you're visible, you're farmable:

Our smallest machine — and several parts of it exist because someone attacked us first. That's backwards; the order should be:

• Build the meter before the abuse. Layered rate limiters⁸, dark-launched, failing open. The version built after the bill spike gets built in a weekend, badly.
• When farming starts, raise the price of identity. The $1 card authorization became an industry standard after CI providers learned the economics: about $103,000 of farmed compute per $137 of attacker profit.

The team is the bottleneck: reliability and leverage

Somewhere in growth, the constraint stops being what you can build and becomes what you can operate:

• Watch fix-to-feat per surface. Our web surface ships nearly two fixes for every feature — that surface is infrastructure now. Staff it as infrastructure; don't exhort it to ship features.
• Argue with numbers or lose. SLOs and error budgets exist so the pager and the roadmap stop fighting on vibes.
• Stage config like code. Cloudflare's 2019 outage¹⁰ was one regex, deployed globally in seconds, through a path that skipped staging.
• Test restores, not backups. The card's case: three backup layers, all discovered broken at the same moment.

• Build the internal platform before the tenth tool. Shared auth, shared audit log, one-step deploy. Shopify runs 50,000 internal sites on one $200-a-month VM¹² because building was never the bottleneck — safe distribution is.
• Self-serve the top support actions into the product. Each one deletes a class of tickets permanently.

Maturity: the machines eat the roadmap — unless you delegate them

By the second half of 2025 the machines took 53% of all code change; core fell to 15%. Nobody chose that — users, revenue, and adversaries did, one ticket at a time:

The standard response is a "refocus on the product" memo. That's exactly wrong: the machines are load-bearing, and billing that gets "refocused" away corrupts ledgers. The only response that works is making the machines cheap. In 2026 we found out how:

We let AI coding agents in from March 2026 — every agent commit signs a co-author trailer, so the history keeps score:

Five months from zero to 69%, in whole units of work — the median agent commit is bigger than the median human-only one. Where the agents work is the point:

The most delegated code we have is the money machine: 76% agent co-authorship against a 39% average. Machine work is patterned, specifiable, judgment-light — exactly what delegates first. i18n sits at 11% only because that work left interactive sessions entirely and became a bot: the same instinct, carried to its end. Moore's endgame for context was outsource it. The 2026 edit is standardize, instrument, delegate — in-house and auditable, which matters most in the code that moves money.

The result is the era chart above: each 2026 quarter now moves more code than all of 2024, and core's share rose while it happened — 15% in the machine-eaten half, 26% now. Not by refusing machine work; by making it cheap.

What to buy, what to build

One rule sorts every part: vendors sell what's identical at every company; nobody sells the parts that encode yours.

Three calls on this sheet need actual judgment:

• A merchant of record trades ~5% in fees for the global sales-tax problem. A good trade until finance is a team.
• Vendors see traffic; only you see usage. Buy the edge, build the meter.
• Every pane of glass is buyable. Deciding what wakes a human at 3 a.m. is not.

The stage sheet

The product is what users see. The git history is what a company actually is: a capability surrounded by machines, arriving on a schedule you don't control. The schedule is knowable, though. Pre-plumb the fittings, meet each machine at its trigger, buy the commodity parts, build the parts that touch your money and your tenants — and make all of it cheap enough that your judgment stays where it differentiates.