I ran a census across my repositories recently. The count came back at 47 repos and roughly 707,000 lines of code. For fun I fed the numbers through COCOMO, the 1980s effort-estimation model that procurement departments still quietly love, and it returned a verdict: a $26.5 million program of work, requiring 49 engineers, over about four years.
It was one person in a home office in southern Sydney, directing a fleet of agents. I don’t write the code. I write the specs, make the decisions, and verify the output. The agents type.
A number that size is only worth publishing if you’re straight about what it doesn’t mean. So here’s the honest version, in both directions.
What the number overstates
Lines of code are a cost, not an asset. Nobody should be proud of 707,000 of anything; the best engineers I’ve worked with measured their careers in code deleted.
Agent-written code runs verbose. Given the choice, a model will write the belt, the braces, and a spare belt. Some fraction of that count is thoroughness a human team would have skipped, for better and worse.
Not all 47 repos are production systems. Some are experiments. Some are dead, and I keep the graveyard visible on purpose: there’s a cross-project dashboard in that count which I shipped in April and declared dead in July. It taught me plenty and serves nobody. “Shipped” and “load-bearing” are different words.
And COCOMO was calibrated on human teams typing every line by hand, in an era when code was expensive to produce. That era ended. Using its dollar figure as a valuation would be silly. Using it as a measure of what this output used to cost is exactly the point.
What the number understates
The census only sees code. The part of the work that matters most never shows up in a line count: the briefs, the engineering designs, the QA plans, the decision ledgers that let an agent run for eleven hours without waking me up. My delivery pipeline produces five specification documents before a line gets written. None of them are in the 707,000.
The orchestration layer isn’t in there either, and it’s the part I’d least like to lose. Delete all 47 repos tomorrow and I could rebuild them. Delete the operating system that produced them and the actual asset is gone.
What it proves, and what it doesn’t
It proves throughput. One operator, working this way, can now produce what recently required a floor of people. That isn’t a projection or a benchmark. It’s a census of things that exist and run.
It doesn’t prove team-scale maintenance, and I’d rather name that myself than have you wondering. The fair question about any solo operation is the bus factor. My honest answer: everything is specified, ticketed, and encoded before it’s built, because the agents require it. The documentation isn’t something I’d get to eventually; it’s the mechanism the whole thing runs on. A new engineer, or a new agent, inherits the specs rather than my memory.
The uncomfortable question
If one operator and a fleet of agents can produce a $26.5 million program’s worth of output, the interesting question isn’t about me. It’s about what the invoice from a 40-person delivery team is actually paying for.
For years my job title said I advise on technology delivery. The census says something more direct: I am the delivery. It took me an embarrassingly long time to notice the difference.