Building velocity
Building is the easy part now, fast and cheap. The hard part is what it always was: why to build a thing, what to build, and how. That judgment is the real work, and it is deliberately not on this page.
Why the framework works is in the before and after. Insttantt I built the old way, no framework, no AI: a team, over years. The companies I build now, on SliceOps and with AI, take hours. That gap is the whole point.
What is here is only the building, measured straight from the git history. Worked hours, not calendar days, and complexity scored honestly so a site is never read as a platform. None of it counts thinking time, which is extensive and where the creation actually happens.
The old way, no framework, no AI
Insttantt
19/24 complexity
The before: a T3 platform built the old way, no framework and no AI, across dozens of repos over years. An approximate sum; its decisions live outside git.
The new way, framework and AI
Matched against the old platform on the left: the same class of complexity, built in hours instead of thousands. Every figure here is measured from the repo, not claimed.
How complexity is scored
Complexity is scored, not guessed from size. A million generated lines can score low; a small piece of stateful, concurrent, regulated logic scores high. It is a profile across six axes, each scored 0 to 4 against a fixed rubric of countable criteria (entity counts, integration counts, named standards implemented to specification), so the same repo gets the same score twice. Six axes at 4 points each, so 24 is the ceiling.
- State
- data model, persistence, and the consistency it has to hold
- Concurrency
- async, queues, distribution, partial failure
- Integrations
- external systems, each one a contract and a failure mode
- Trust
- auth, PII, payments, a regulated domain
- Intelligence
- AI and agents, non-deterministic by nature
- Domain
- how exacting the problem is: standards, protocols, specifications that must be met
Complexity against time
Every measured build: complexity up, worked hours across (a log scale, the old way and the new way are orders of magnitude apart). The shaded corner is the goal, and it is drawn from the baseline itself: the old platform's complexity or near it, in under a tenth of its hours. It is no longer empty. RootBlocks and Datta both sit inside it, and Datta now scores above the platform a team spent years on.
Datta
in progress
15 repos: a data-ownership platform where the vault holds identity, financial and cognitive records behind a transactional outbox and a hash-chained audit trail, with a Flutter app, a console, workers, an agent gateway and a process engine around it. The most complex thing on this page, still in progress.
RootBlocks
live
11 repos: a governed rail for AI coding agents, with a multi-tenant control plane, an append-only receipts ledger under a transparency log, a real-time collaborative console and a multi-model agent harness. It reaches past Insttantt's complexity, built on the framework with AI. An approximate sum; the platform is largely still in progress, the website is live.
Resolvi
in progress
3 repos: customer service driven by the structured context of the company and the customer. Still in progress; complexity is a provisional score.
ApiFusion
in progress
2 repos: an integration gateway normalizing dozens of providers behind one API. Integrations-heavy, still in progress; complexity is a provisional score.
SliceOps
live
One product across spec, toolkit, website and its own corpus; complexity is the max of each axis across them. The toolkit's code is real (lizard CCN ~7.3, a quarter of its functions over 10); the website carries three live integrations and email PII. Worked hours are an approximate sum.
andres.co
live
This site. First commit to a live, governed v1 the same day.
Method: worked hours are person-hours. Commits are grouped by the person who wrote them, each person's timestamps are clustered into sessions (a gap over two hours starts a new session) across all of a venture's repos at once, and the per-person totals are added up, plus 45 minutes per session for work before its first commit. Doing it any other way is wrong in one direction or the other: clustering one merged stream counts a day on which five people worked as one day, and clustering each repo separately then adding them charges that 45-minute block once per repo touched. The before (Insttantt) is 33 people across 36 repos, and its decisions live outside git; every build beside it is one or two people, the corpus where its decisions are written included. Complexity is a six-axis profile (0 to 4 each) read from the repo, each axis taking the highest score it reaches in any one repo. The sixth axis is Domain: how exacting the problem is, anchored from business rules at 1 up to several formal standards implemented to specification at 4, where getting the spec wrong is a security or a legal failure. It replaced a cyclomatic-complexity axis that measured how branch-dense the code was, and so scored a 500-line method with 146 paths through it above the same logic factored into small functions. That is a maintenance-risk metric, not a difficulty one, and rewarding it had the sign backwards. “Faster” measures worked hours against the old way: Insttantt's ~1,047 hours per complexity point over this build's. At matched complexity, like RootBlocks and Insttantt, it is essentially the ratio of hours; for simpler builds it is the same rate per point, so read it as efficiency against the old way, not a literal estimate. The composite is an equal-weighted index of the six axes, not a single fundamental measurement.
Back home