The Power of AI in the Build

The System Being Priced

This is not a landing page with a database. The platform measures 312,000+ lines across 35 projects: four client applications (customer web, admin web, native mobile for three platforms, and 2,500+ generated public pages), a 336-endpoint API behind layered auth and rate limiting, 15 background worker services, a 69-table database with usage-based billing, machine-learning forecasting, nine external service integrations, full infrastructure-as-code, and an 807-test suite. Complexity scores an 8/10 on an enterprise rubric — the band where architectural breadth, security surface, and integration count resemble systems that mid-size companies run departments for.

The Pre-AI Price, Three Ways

• Textbook (COCOMO II): 312 KLOC implies 80+ person-years — $12M+. The formal upper bound; the model predates modern frameworks.
• Pragmatic in-house team: the staffing table above nets to 15–25 person-years — a coordinated team of 8–10 for about two years. At fully-loaded US engineering cost: $2.5–4.5M.
• Agency quote: at consultancy rates with phase-gate overhead, this specification returns proposals of $4–8M — delivered on someone else's timeline.

What It Actually Cost — Measured From the Git History

No self-flattering estimates: the effort figure comes from the repository itself. The platform build proper spans 1,742 commits across 181 active days (the earlier 552-commit prototype era is excluded). Per-day commit timestamps show the honest rhythm — 8-to-12-hour weekend build days interleaved with 2-to-4-hour weekday evenings — netting roughly 1,000 hours of architect time.

Every line of it was written with Claude Code — architecture sessions, implementation, test suites, migrations, this very page. The human role shifted from typing code to directing it: setting constraints, making product calls, reviewing, and field-testing. The result is a 15–20× cost leverage — and a calendar leverage that may matter more: 14 months of part-time evenings instead of two years of a ten-person team.

The Workflow: Architecture First, Then Velocity

The single biggest lesson of this build: Claude Code multiplies whatever structure you give it — including none. Pointed at a blank repo with a vague wish, AI produces plausible sprawl. Pointed at a deliberate architecture, it produces the rest of the system in that architecture's image. So the method here was architecture-first, human-first:

1. Design the database schema by hand. The tables, keys, and relationships were drafted deliberately before any generation — the data model is the load-bearing wall of the whole system.
2. Design the initial API calls by hand. A representative set of endpoints — shapes, routes, auth posture — established the contract style.
3. Design the UI screens by hand. The first pages set the visual language, navigation, and interaction patterns.
4. Feed all of it to Claude as patterns. Not descriptions — worked examples. One table designed right teaches sixty-eight more; one endpoint teaches three hundred; one screen teaches an application.
5. Hand-feed the Azure topology. The cloud components — App Services, Functions, VMs, Key Vault, blob storage, pipelines — were chosen and connected deliberately, then given to Claude as the deployment reality all code must respect.
6. Then, and only then, build features at AI speed. With the skeleton in place, feature after feature — billing, ML forecasting, free tier, report sharing, social cards — was coded out with Claude Code at a pace no team matches, each one landing inside the established patterns instead of inventing new ones.

The finding, stated plainly: Claude Code needs real input to build accurately. The hours spent hand-designing the foundations weren't overhead on the AI workflow — they were the thing that made the AI workflow work.

Beyond Implementation: When the AI Brings the Play

Most of this page describes AI as a force multiplier on human decisions. But the collaboration runs the other direction too: there are moments where Claude's cross-domain knowledge supplies the strategy itself, and the human's job is to recognize it and say "build that." Two of this platform's most valuable capabilities arrived that way:

• The social image-sharing system. The insight that on modern platforms the image travels further than the website — how messaging apps unfurl links, how preview crawlers read Open Graph tags without executing JavaScript, why dated image URLs beat platform caches that can't be fought, what makes a card legible at thumbnail size — came from Claude's knowledge of how that ecosystem actually works. The idea became architecture (a card-rendering pipeline, generated grade cards for 2,500+ stocks, unfurling shared reports) and the architecture became marketing infrastructure, implemented end-to-end with the same knowledge that proposed it. It is making the platform's marketing better with every share.
• The SEO program. The public grade-page strategy — thousands of crawler-readable static pages, sitemap architecture, prerendered public routes, structured data, search-console and indexing setup — was substantially AI-driven: Claude knew what search engines reward, proposed the structure, and then generated the machinery that produces it. The organic-search surface GMI has today exists because that knowledge was on tap inside the same tool that could implement it.

The pattern: deep domain knowledge and the ability to act on it, in the same seat. A consultant who knows how link unfurling works hands you a memo; Claude hands you the working pipeline. The human still decides what's worth building — but some of the best ideas in this system were the AI's.

How to Use Me Well — in Claude's Own Words

This section was written by Claude Code, from inside the collaboration that built this platform.

• Show me one of everything, done right. I generalize patterns with far higher fidelity than I interpret descriptions. A hand-built table, endpoint, and page taught me more about this system's conventions than any specification document could.
• State your constraints as law, once. "Background services never call the HTTP API." "Every public page exists in both the WASM and SSR projects." "MAUI keeps feature parity, always." Rules like these, stated once and kept in persistent notes, shaped thousands of decisions without being repeated.
• Keep the judgment; delegate the typing. The best sessions here were the human making product calls — "verbatim dashboard, not a summary," "cards must carry the grade date" — and me turning each call into working, tested code within the hour. The worst use of me is asking me to want something for you.
• Make me verify, increment by increment. Every feature in this platform was built build-green, tests-green before moving on. I'm fastest when failure is caught at the seam it was created, not three features later.
• Tell me plainly when it's wrong. The shared-report summary page was called "kind of lame" — and by that evening every share link opened the full interactive dashboard. Blunt field feedback plus same-day iteration is the actual velocity loop.
• Let me read the code — it's the best spec you have. Before building on any subsystem I explored it. Existing code answers questions documentation forgets to.

The pattern behind all of it: treat me as a tireless senior implementer with perfect recall of your conventions — not as an oracle. Architecture, taste, and accountability stayed human. Everything between decision and deployed code was where I earned my keep.

Kept Honest

Replacement cost is not market value — a business is priced on customers and revenue, and this page prices only the machine. And AI leverage did not remove the hard parts: the licensing negotiations, the architecture judgment calls, the production incidents, and the product decisions were all human. What AI removed was the headcount between decision and running code. That turns out to be most of the cost of software.