Build with a genius.
Ship a machine.

There are two very different ways to put artificial intelligence into an app. The obvious one is to call a large language model every single time the app runs — the pattern behind most "AI apps" you've met. The other is quieter, and often far better: use the AI while you build, and ship something that doesn't need it at all.

Two places an AI can live

Where you put the intelligence changes everything about the product that comes out the other end. It can sit at runtime, thinking on every use — or at development time, doing its thinking once, in the workshop, so the shipped app never has to.

CricCuts is built entirely the second way. The intelligence went into building the tools — not into running them.

The kind of app that used to be too hard to build

Some apps are, underneath, a big pile of judgement — "is this the moment that matters?" You can't capture that in one clean rule. It's dozens of interacting signals and thresholds, each nudging the others, all of them needing to be tuned against messy, real-world data that never behaves like the demo.

Historically, that made this whole class of app brutal to build. You needed rare expertise — signal processing, audio, computer vision — and then a punishing loop: run on real footage, stare at every false alarm and every miss, form a theory, nudge a parameter, re-run, and pray you didn't quietly break three other things. Each turn of that loop could eat a day. The space of possible settings is combinatorial; a small team could ever only explore a sliver of it. So these apps were the preserve of big, well-funded teams — or they simply never got made.

The hard part was never having the idea. It was the ten thousand tiny, tedious, interacting adjustments between the idea and something that actually works.

What changed: an agent in the loop

Agentic development flips the economics of that loop. An AI agent can hold the whole pipeline in its head at once — every signal, every threshold, every place a change ripples outward — and reason about a tweak the way a veteran engineer would. Crucially, it also builds the measuring instruments: evaluation harnesses, scoreboards against a human-labelled "golden" set, side-by-side A/B runs, contact sheets of every mistake it made. Then it proposes a change, runs the experiment, reads the results, and goes again — dozens of times over, tirelessly, in the time a person would manage a single pass.

The upshot is that one person can now develop, test and iterate software that used to demand a room full of specialists. Not by making the app cleverer at runtime — by making the building of it dramatically faster, cheaper and more rigorous.

The loop, one turn at a time

Strip away the jargon and each turn of the loop is four honest steps:

1. Run it on real footage. The deterministic tools make their pass over genuine recordings — the messy, real-world kind, not a tidy demo clip.
2. Score it against human truth. Every result is checked against a hand-labelled "golden" set of what a person would actually pick. Two numbers matter: what it missed, and what it flagged by mistake.
3. Let the agent find the why. It reads the whole pipeline, forms a hypothesis about the cause of a miss or a false alarm, and writes the experiment that will test it.
4. Refine, re-run, keep what wins. The change goes in, the full benchmark re-runs, and it survives only if it genuinely improves the score without quietly breaking something else. Then the loop turns again.

Nothing here is magic, and nothing here hallucinates — every step is checked against reality. Over hundreds of turns, that discipline compounds into an engine that's genuinely good at a very hard, very specific job.

Why ship determinism at all?

Because once the hard thinking is done, a deterministic engine quietly wins on everything that matters to the person actually using the app:

An LLM-at-runtime app struggles to promise any of these. Agentic development gets you the sophistication of modern AI baked into the artefact, without carrying the cost, latency, privacy and reliability liabilities of running a giant model on every single use.

The opportunity: a whole class of apps just opened up

This isn't only about cricket. The same recipe — an agent in the workshop, a cheap deterministic core in the product — unlocks a category of software that used to be uneconomical for small teams to even attempt:

• On-device understanding of audio, video and sensor streams — finding the moment that matters inside a long, noisy recording.
• Accuracy-critical automation where a confident hallucination is unacceptable — anywhere "sounds right" isn't good enough.
• High-volume processing where paying a large model per item would never add up.
• Anything that must run privately, offline, or on modest hardware — where the cloud simply isn't an option.

In each case the durable advantage isn't a model you rent by the token — it's the accumulated judgement, encoded in deterministic tools, tests and benchmarks that cost almost nothing to run and can't be reproduced by prompting a chatbot. The AI helped build it; the moat is what got built.

CricCuts is our proof that this works in the wild — a genuinely hard video-understanding problem, solved on a phone, for free, built by one person with an agent in the loop. The genius did its work in the workshop. What you hold is the machine it made.

Related reading: the companion piece — the idea the AI missed, on the one breakthrough no model suggested — plus why the future of AI is small models on the edge and why it might be many small models working together. For the plain-English walkthrough of what the engine actually does, see how a phone watches cricket and cuts the highlights itself. More on the CricCuts blog.