TL;DR: We measured everything in the GopherTrunk repository — 370k lines of Go, five TypeScript web apps, a clean-room ACELP vocoder, and a 2.7 million-word documentation site — and estimated what it would take a human team to build it: roughly 35,000 hours (~17 person-years) of coding, engineering, and writing, or about $4.3 million at market rates. The repository’s actual commit history spans 17 calendar days. That gap is the point: AI didn’t just make this project cheaper — it made a project exist that no company would ever have funded and no individual could ever have finished.
Key takeaways
- A full audit of the repo counts ~425k lines of code (44% of the Go is tests) and ~2.78 million words of prose across 2,300+ pages.
- Priced bottom-up at specialist rates, the human-equivalent effort is ~20,000 hours of coding, ~8,000 of engineering, and ~7,400 of writing — a defensible range of $3.0M–$5.5M, centered near $4.3M.
- The commit history covers 17 days. Nobody compresses 17 person-years into 17 days by typing faster — the compression is the story.
- AI didn’t remove the engineering. The judgment calls — field captures, failing-first tests, on-air verification — stayed human. What changed is that one person’s judgment now goes 100× further.
GopherTrunk is built in the open with Claude Code — the whole process is documented in the Build in the Open series, and there’s a full learning module on AI-assisted development if you want to try the workflow yourself. This post is the accounting.
In this post
- The census — what is actually in this repository, measured, not estimated.
- The hours — how long a human team would need, split into coding, engineering, and writing.
- The invoice — what those hours cost at real market rates.
- The 17 days — what the calendar says actually happened.
- The real lesson — why “cheaper” is the wrong word, and “viable” is the right one.
The census: what’s actually in the repo
Cost estimates are only as honest as their inputs, so we started by counting
everything (excluding node_modules, .git, and build output):
| What | How much |
|---|---|
| Go source | 370,833 lines across 1,784 files in 178 packages |
| …of which tests | 163,746 lines (~44% of all Go) |
| TypeScript | ~39,200 lines across five separate SPAs |
| SQL / shell / proto / config | ~15,400 lines |
| Documentation & articles | 2,336 markdown pages, ~2.68 million words |
| Changelog + engineering notes | ~80,000 words more |
And it’s not generic CRUD code. The hard core is real-time DSP and protocol work — the kind of software where a single wrong constant costs a week: symbol-timing recovery, blind CMA and trained LMS equalizers, maximal-ratio diversity combining, four trunking protocol families (P25, DMR, NXDN, TETRA including Direct Mode), AMBE/IMBE voice decoders, and a clean-room ACELP vocoder validated bit-identically against the ETSI reference codec. Around that core sit a daemon, gRPC and REST APIs, five web frontends, installers for three platforms, and a documentation site bigger than most publishers’ annual output.
The hours: what a human team would need
We estimated bottom-up, using delivered-lines-per-hour rates appropriate to each layer — slow for DSP and protocol conformance (~10 lines/hour of finished, tested code is normal in that world), faster for infrastructure, APIs, and frontend work.
Coding — ~20,000 hours. DSP/protocol/vocoder core (~80k lines at DSP pace): ~8,000 hours. Daemon, APIs, storage, config, TUI (~127k lines): ~5,000 hours. The test suite — much of it capture-driven regression harnesses, not unit boilerplate: ~5,500 hours. Five SPAs plus glue: ~2,400 hours.
Engineering — ~8,000 hours. The non-typing work this domain demands: reading ETSI and TIA specifications, cross-checking independent reference decoders, root-causing on-air failures from field captures, conformance validation against reference implementations, CI/release/installer engineering, and review. For specialist communications work this reliably runs 35–45% of total technical effort — and GopherTrunk’s own issue tracker, with its multi-week capture-verified investigations, is the evidence.
Writing — ~7,400 hours. 2.68 million words of researched guides and articles at a professional pace of ~400 finished words/hour, plus the technical docs, changelog, and clean-room provenance write-ups at a slower ~250 words/hour.
The invoice: pricing it at market rates
Using fully-loaded US contractor rates — and note that the engineering column commands a premium, because communications-DSP specialists who can take a vocoder through ETSI conformance are genuinely rare:
| Category | Hours | Rate | Cost |
|---|---|---|---|
| Coding (senior Go/TS engineer) | 20,000 | $120/hr | $2,400,000 |
| Engineering (DSP/SDR specialist) | 8,000 | $180/hr | $1,440,000 |
| Writing (content + technical writer) | 7,400 | $60/hr | $444,000 |
| Total | ~35,400 | ~$4.28M |
Two honest caveats. First, productivity heuristics are heuristics — hence the range, not a point. Second, part of the docs site follows repeated templates, so a human content operation with editors might do the writing in ~4,500 hours instead of 6,700; that alone moves the total by ~$130k. Neither caveat changes the order of magnitude.
The 17 days
Here is the number that reframes all the others. The repository’s entire commit history — 273 commits — spans August 5 to August 21, 2026. Seventeen calendar days. Of those commits, 205 were authored by Claude and 68 by human collaborators.
Nobody types 260× faster than a professional team. The compression comes from somewhere else: an AI collaborator that can hold four protocol specifications, a 178-package codebase, and last Tuesday’s field-capture findings in working memory at once — and that never gets tired of writing the regression test.
The real lesson: not cheaper — viable
It’s tempting to read this as a cost-savings story: “$4.3M of work for the price of a Claude subscription.” But that framing quietly assumes the $4.3M version was ever going to happen. It wasn’t.
No company funds a $4.3M, multi-year build for a free, open-source radio scanner. The market wouldn’t return the investment, so the project simply doesn’t get built — not badly, not slowly, not at all. And no solo developer self-funds 17 person-years of nights and weekends; the honest projects in this space that come closest are decade-long labors of love by extraordinary individuals, and they are rare precisely because the cost is so brutal.
What AI changes is the viability threshold. A whole category of software — too niche for venture capital, too large for a hobbyist, too valuable to its small community to stay unbuilt — suddenly becomes something one motivated person can actually ship. GopherTrunk sits squarely in that category: scanner hobbyists, volunteer firefighters, storm chasers, and railfans were never going to be a $4.3M market. They now have a modern, free, cross-platform trunking scanner anyway.
And crucially, the human didn’t leave the loop — the role changed. Every verified fix in this project traces to a human decision: which capture to record, which symptom is real, whether a green test actually proves anything (the project’s own issue-closing policy exists because it once didn’t). The AI wrote most of the lines; the engineering discipline that makes those lines trustworthy is human, and it is the part that doesn’t compress. That division of labor — human judgment, machine leverage — is the whole model, and it’s teachable: the Build in the Open series walks through it from a blank repo.
If you have a project like this — the one you’ve told yourself is too big, too niche, too much — the math just changed. The itch you’ve been ignoring because it would take a decade might now take a season.
FAQ
How were the hour estimates calculated? Bottom-up, from measured line and word counts, using delivered-productivity rates appropriate to each layer: ~10 lines/hour for finished DSP and protocol-conformance code, ~25 for infrastructure, ~30 for tests, ~20 for frontend, and 250–400 finished words/hour for prose. Engineering (specification study, field debugging, conformance validation) is estimated at 35–45% of technical effort, standard for specialist communications software. The ±30% band on the assumptions gives the $3.0M–$5.5M range.
Isn’t AI-generated code lower quality, making the comparison unfair? Judge it by the artifacts: 44% of the Go is tests, fixes land with failing-first regressions, the vocoder is validated bit-for-bit against the ETSI reference codec, and on-air behavior is verified against real captures before an issue closes. Those are stricter standards than most commercial codebases meet. Quality here isn’t a property of who typed the code — it’s a property of the verification discipline around it.
Did AI really do everything? No, and that’s central to the story. Humans chose what to build, recorded the field captures, judged which symptoms were real, and enforced the verification discipline. Roughly three-quarters of commits are AI-authored, but every one of them traces back to a human decision about what mattered. The right mental model is a specialist team of one, with leverage.
What does this mean for my own project idea? That the viability line has moved. Projects that were previously “technically possible but economically absurd” — niche tools, deep rewrites, well-documented open source for small communities — are now within reach of a single motivated person. Start the way any good project starts (a real problem, ruthlessly scoped — see Build in the Open, Part 1), then bring the leverage.