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, cyclomatic complexity), 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
- Code
- cyclomatic and cognitive complexity of the hand-written code
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). Top-left is the goal, hard things built fast, and it is no longer empty: RootBlocks and Datta reach the old platform's complexity in hundreds of hours, not thousands.
RootBlocks
live
10 repos: a security, identity, and fraud platform plus an agentic build engine. 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.
Datta
in progress
8 repos: a data-ownership platform with a vault, a Flutter app, workers, and an MCP gateway. Insttantt-class complexity, still in progress.
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, and website; complexity is the max of each axis across the three. 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 cluster commits into sessions (a gap over two hours starts a new session), sum the time inside each, plus 45 minutes per session for work before its first commit. SliceOps is one product across its spec, toolkit, and website; its worked hours are an approximate sum. The before (Insttantt) is an approximate sum across 35 repos, and its decisions live outside git. Complexity is a six-axis profile (0 to 4 each) read from the repo. The Code axis (*) is measured with lizard (cyclomatic complexity) where the language allows, and read by hand for JSX/TSX, which lizard undercounts; Insttantt's Code axis is still an estimate pending a per-repo run. “Faster” measures worked hours against the old way: Insttantt's ~1,040 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