Building is cheap now. Here's how I measure what isn't.

A few years ago, the hard part of software was building it. Now an agent writes the boilerplate, drafts the tests, wires the integration, and does it while you read the diff. The cost of producing code fell off a cliff.

So everyone says the same thing: we ship fast. It is the most worthless sentence in engineering right now. Fast compared to what? Fast at building what? A landing page in a day is not the same achievement as a fraud-detection platform in a week, and "fast" flattens them into the same brag.

If building is cheap, then "I built it fast" is not the flex. The flex is what you built fast, and how hard it actually was. Which means you have to measure two things honestly, not one: speed, and difficulty. Here is how I do it, entirely from the git history, so the numbers are reproducible and hard to game.

Speed: worked hours, not calendar time

Calendar span lies. A repo with a first commit in April and a last commit in June did not take three months; it took a handful of evenings. So I do not count days. I cluster the commit timestamps into work sessions: a gap over two hours starts a new session. Then I sum the time inside each session, plus a fixed block per session for the work done before its first commit.

That gives worked hours, an honest estimate of human time at the keyboard, not the wall-clock distance between the first and last commit. It is approximate, and I say so. It still beats the alternative, which is a number that flatters you by an order of magnitude.

Difficulty: a profile, not a line count

This is where most "metrics" cheat. Lines of code is the easiest thing to measure and the worst proxy for difficulty. A million generated lines from an ORM are not complex. Two hundred lines of distributed, stateful, regulated logic are. Size is volume. Difficulty is something else.

So complexity is not a number, it is a profile across six axes, each scored 0 to 4 against a fixed rubric of countable things, so the same repo gets the same score twice:

• State is the data model, persistence, the consistency it has to hold.
• Concurrency is async, queues, distribution, partial failure.
• Integrations is external systems, each one a contract and a failure mode.
• Trust is auth, PII, payments, a regulated domain.
• Intelligence is AI and agents, non-deterministic by nature.
• Code is actual cyclomatic complexity, measured with a tool, not eyeballed.

Each level is anchored to observable criteria. Integrations is a count: zero, one, two-to-three, four-to-six, seven-plus. State is the number of persisted entities and whether the data is partitioned. Code is the average cyclomatic complexity and the share of functions over a threshold. You are not rating difficulty on vibes; you are reading it off the repo.

The six axes sum to an index out of 24. I call it an index on purpose, not a measurement. Summing ordinal axes assumes equal weight and equal spacing, which are assumptions, not facts. The profile is the real artifact; the number is a convenience. Saying that out loud is the difference between a metric and a marketing chart.

The result

Now the part that is the whole point. I have one company I built the old way, before I had a framework and before AI could write code with me: Insttantt, an identity and regulated-processes platform that has served close to a million people. Measured the same way, it took roughly 19,766 worked hours across its repos, over years, and it scores 19 of 24 on complexity. That is the baseline. The "before."

Then there is RootBlocks, a security, identity, and fraud platform with an agentic build engine, built now, on the framework, with AI as a co-architect. It scores 20 of 24, as complex as Insttantt, and a little more. It took about 168 worked hours against Insttantt's 19,766.

Same class of difficulty. Adjusting for the fact that RootBlocks is the more complex of the two, that is about 124 times less time for the same kind of build. On raw hours it is roughly 118; the rest is that complexity adjustment.

It is not a fluke of one project. Datta, a data-ownership platform with a vault, a Flutter app, workers, and an MCP gateway, scores 18 of 24 and sits at a few hundred worked hours, still in progress. The pattern holds: the things that used to take a team years now take one person weeks, at the same complexity, because the constraint moved.

What actually changed

The bottleneck is not building anymore. For most of the history of this craft, the question "can we build it?" ate the budget. Now building is cheap, and the questions that are left are the ones that were always the hard ones and are now the only hard ones: why to build a thing, what to build, and how to build it so it survives. That judgment is the work. It does not show up in worked hours, and it never will, because it happens before the first commit.

So I do not count it on the velocity page. I am precise about that: the numbers measure the building, which is the easy part. Thinking time, the extensive part, the part where the actual value is created, is deliberately excluded. The graph is not a brag about how fast I type. It is evidence for a thesis: building is now a commodity, and the moat is judgment.

Why I bother being this careful

Because the moment a number is impressive, it is also suspect, and a sloppy one takes the credible ones down with it. So the method is built to survive scrutiny:

• Worked hours are an approximate sum; multi-repo products over-count slightly and I say so.
• The baseline is measured, not estimated, or the whole comparison rests on a guess.
• The Code axis is read by a tool where the language allows and by hand where the tool undercounts, and I mark which is which.
• The composite is an index, not a fundamental measurement.

A skeptic can check every one of these against the repos. That is the point. In a world where everyone claims to ship fast, the only interesting claim is the one you can audit.

Building is cheap now. The numbers prove the easy part is easy. What they are really there to say is the opposite: if building was the thing standing between you and what you wanted to make, it isn't anymore. Now it is just you and the hard questions, with no excuse left.