From a Few Prompts to Two Billion Rows
The tools that exist because something broke.
Before — glorified autocomplete
I'd been using AI tools since before they could really build anything — diffusion models in 2023, code assistants in early 2024, TabNine and early Copilot in their pro versions when "AI coding" meant autocomplete that could occasionally manage a function or a class. Useful. Not transformative. I kept using them anyway, because the trajectory was obvious even when the capability wasn't.
March 2025 — Tank Battle
The first complete application I built with AI. A few prompts, a prototype of a process guide I'd written, and out came a small browser game. It's fun. It works. And it's a few hundred lines of what came next.
I keep it public because it's the "before" picture.
Tank Battle | ai-project-guide
Spring 2025 — The first time I thought I was obsolete
Cursor and Windsurf shipped built-in planning and prompting. I assumed my process guide was dead on arrival.
I was half right. It wasn't good enough — but neither was theirs. Nobody's survived past toy scale.
I've had that "this makes me obsolete" moment several times across two decades-plus of building. Eventually I learned the test: go look at the new wave, push what they built until it breaks, and see where it breaks. It keeps breaking in the same place — the moment the work gets scalable, maintainable, hard. That place kept being unclaimed. So I claimed it.
Summer 2025 — Context Forge, first form
Started as an Electron app for context engineering. Useful, but it had a fatal flaw I didn't name until later: an AI couldn't use it. I pushed the buttons. I did the copying. The tool assumed a human operator in a world where the operator was increasingly not human.
That realization drove every design decision since: everything discoverable, everything structured, everything a machine can find and act on without me in the loop.
Late 2025 – early 2026 — The rebuild
Six weeks without writing code. Agents were everywhere, everyone was saying "orchestration," and my Electron experiment felt quaint. So I ran the test again: audited the agentic systems, looked for anything built for hard problems at scale.
Same finding as before. So I rebuilt.
Context Forge absorbed the process guide and became what it is now: a deterministic, configurable state machine around a highly structured development process. CLI-first and git-shaped, because that's the substrate humans and AIs already share. It knows what phase a project is in, builds precise context for the current work (cf build), and knows what comes next (cf next). Review gates are configurable per phase — and when a gate is unmet, CF warns but doesn't refuse. The machine tracks state deterministically; judgment stays human. It ships an MCP server, slash-command surfaces for Claude Code and Copilot, JSON everywhere — the "AI couldn't use it" flaw, inverted into the design principle. Context Visualizer, an MCP client against CF's own server, renders project state and artifacts visually — the tooling uses itself.
Squadron emerged from the orchestration experiments and found its first real value in reviews: multi-model evaluation with structured findings a downstream process can route on. Then it grew into the thing I use hardest: pipeline automation — multi-step workflows defined in YAML, any step to any model across providers (Anthropic, OpenAI, OpenRouter), configurable model pools, loops and fan-out/fan-in, human checkpoints that trigger on findings (checkpoint: on-concerns) and persist as state rather than blocking calls. Context lifetime is managed, not hoped about: summarize, hand off between environments, restore, continue. It's the class of capability you'd otherwise adopt a framework like LangGraph to get — except it runs a structured process, not a graph of vibes, and it's in daily use.
These aren't demos. CF and Squadron are in daily commercial use — my own projects and current client engagements, including brownfield work: analyzing an existing production mobile codebase and delivering a working port to a second platform, in a domain the toolchain had never seen.
Context Forge | Squadron | Context Visualizer
2026 — The failure ceiling, on purpose
My first attempt at a trading data platform (Q3 2025) bogged down — async code fighting synchronous packages, mess everywhere. The tools weren't ready. Neither was I, working the way I was working.
So instead of grinding at it, I built a system designed to break my toolchain in a controlled setting: Migratory, a GPU-accelerated flocking simulation. It started as a Claude artifact simple enough to run in a chat window. Eight major iterations later it ran 25,000 entities at 90 ticks per second — and getting there forced the hard architecture: decoupled event loops connected by queues to prevent starvation, CUDA kernels, Numba JIT kernels, a binary websocket protocol, and a Three.js client rendering it all at 120fps.
Every one of those was a failure I induced deliberately, then built the constraint that survives it.
Then I went back to trading data with the hardened tools and rebuilt it from concept: a TimescaleDB platform with ~2 billion rows, continuous aggregation across 8 timeframes, survivorship-bias handling, gap-aware data (it knows where the holes are and why), point-in-time universe queries — the market as it existed then, not as survivor lists remember it — and an API serving all of it.
It was still hard. It still required real human judgment at real checkpoints. That's the honest part: the tools don't remove the hard parts. They make the hard parts the only parts you touch.
Migratory | Migratory Viewer | trading-data
Both Migratory and trading-data ship their complete process records — every slice, task, review, and finding — in project-documents/. The receipts are in the repos.
Now — removing myself from the non-critical path
Current work is Amoeba: a deterministic runner that drives CF and Squadron through a full project lifecycle, spawning model judgment only at the named points where judgment is the actual work — and escalating to a human only where it matters. Not an agent improvising with tools; a state machine that deploys intelligence. The goal isn't taking the human out of the loop. It's taking the human out of the parts that were never the human's job.
The method
Every tool above exists because I pushed AI past where it works, watched the specific way it broke, and built the constraint that survives that break.
The generalized version: deterministic control flow around bounded nondeterministic subroutines. Intelligence — human or artificial — goes only where judgment is the actual work. Everywhere else, it's removed. This isn't a preference; it's what survived contact with two billion rows.
March 2025: a tank game from a few prompts. July 2026: production data infrastructure, built with tooling that exists because the tank game's methods couldn't.
The distance between those two points is the product.