About that 'no AI'...

Wed, 15 Jul 2026 00:00:00 +0000

A couple of weeks back I made a claim I was happy to put my name to: There’s no AI in my photo culler. And I meant it. The first pass that sorts Hailey’s wedding photos into keep, maybe and reject is arithmetic, the sort a patient enough person could do by hand. Blur is the variance of a Laplacian, a duplicate is sixty-four bits that happen to agree, exposure is a histogram. Not a trained weight in sight.

Then I went and put two neural networks in it.

So… about that. When I said “no AI”, what I really meant was “no generative AI”, and the gap between those two has turned out to be the whole point. There’s machine learning in krites now, there’s more on the way, and “AI” has become a word that can’t tell the two apart.

The bit I always said was coming

In that culler post I drew a line. The heavy lifting of the first pass would always be model-free, I said, but some of what a photographer culls on genuinely needs a model: is this person mid-blink, is anyone actually looking at the camera, is the composition any good. Those would be model-backed when they came, and they’d sit outside the deterministic core, behind an interface, opt-in. That was a promissory note. Well, the first of them has come due: the eye-and-blink signal has landed, and it pays out exactly as I said it would.

Spotting a blink genuinely needs a model. To know whether someone’s eyes are open you first have to find the face, then find the eyes on it, and there’s no way to do that with a for loop over pixel brightness. So krites does it with two models, both run through ONNX Runtime: UltraFace to find the faces, and InsightFace’s 106-point landmark model to map the features on each one (the pinned models). Both are neural networks, trained on faces. This is machine learning, the thing the first pass pointedly did without. It’s off by default, it lives in its own package, and it sits behind the same face.Analyzer interface the post promised, so the deterministic engine never imports it (spec 0004).

But look at what it gives back

Here’s why two neural networks still don’t add up to the kind of “AI” everyone pictures now. The models don’t decide anything. They hand back coordinates: a box around each face, and a hundred-odd points marking its features. The blink call is then plain geometry on six of those points per eye, the eye-aspect-ratio, the distance across the eyelids over the distance across the eye, a number that falls towards zero as the lid closes:

// eyeAspectRatio is the Soukupová–Čech eye-aspect-ratio for a 6-point eye
// contour (p0..p5 ordered around the eye, starting at the outer corner):
//
//	EAR = (|p1-p5| + |p2-p4|) / (2 · |p0-p3|)
//
// the two vertical lid distances over twice the horizontal width. Higher means
// more open; a blink collapses the verticals toward zero.

I calibrated the open and closed thresholds against 556 frames from the wedding that started this whole project, actual blinks and actual open eyes, so the numbers mean something for the job (the anchors). And the interface it plugs into doesn’t just hope it behaves itself, it demands it:

// Analyzer finds faces in a frame and reports per-face eye state. Implementations
// are model-backed (pkg/face/onnx) or faked in tests; the engine codes only to
// this interface (0004 R-FACE-3). Analyze MUST be deterministic for a given
// (img, model) and honour ctx cancellation/timeout (0004 R-FACE-4; 0002
// R-GLOBAL-7, R-GLOBAL-8).
type Analyzer interface {
	Analyze(ctx context.Context, img image.Image) (Result, error)
}

Same frame in, same answer out, every time (face.go). That one requirement is the line between this and a chatbot. It’s machine learning that behaves like the arithmetic culler it sits next to: reproducible, debuggable, and tunable by Hailey rather than by me or a vendor. The model finds the eyes; a number she can move decides what counts as shut. And a blink only ever demotes a frame to maybe, it never rejects one on its own, because krites proposes and the human disposes.

The word got narrow

Now the actual argument. Ask most people what “AI” is today and they’ll describe a chat box. You type, it types back; it writes, paints, codes. Generative, conversational, and genuinely astonishing. I use it every day. But it’s one slice of a very large pie, and somewhere in the last three or four years it ate the whole word.

There’s no “versus” in any of this. Generative models and the quiet predictive kind are branches of the same family, and I’m a fan of the lot. The point is only that “AI” used to name the whole field and now names one corner of it. Machine learning is enormous, decades older than the chatbot, and the overwhelming majority of it has nothing to say to you at all. It takes a varied input and returns a consistent, predictable output. It finds a face. It reads a postcode off an envelope. It flags the dodgy transaction. It spots the tumour on the scan. None of it talks, none of it improvises, and almost none of it gets called “AI” any more.

Some of the most formative work of my career, years before GPT was a name anyone outside the field would recognise, was built on exactly this kind of model. A team I was part of was using BERT, a language model, to make sense of messy text, and there was protein folding and sequencing work going on alongside it that was some of the cleverest engineering I’ve stood near. All of it was AI by any textbook definition. None of it had a chat interface. It just did a specific, difficult, useful thing, and did it reliably.

The proof is in her camera bag

The cleanest example isn’t anything I built. It’s already in Hailey’s hands. Her Sony A7 IV does face detection, and eye detection, in the body of the camera, live, as she shoots. It has done for years. It’s so utterly ordinary that nobody thinks twice about it, nobody calls the camera “AI”, and nobody worries about where their face went. It’s a trained model welded into a physical object and taken completely for granted.

The ONNX detector I just put into krites is the same species of thing: a small model that learned what an open eye looks like and gives a direct answer. The only real difference is timing. The camera does it at the instant of the shutter, and krites does it three thousand frames later, for the shots a blink spoiled that nobody caught on the day.

Why the muddle is worth minding

So why does it nag at me, one slice eating the word? Two reasons.

The first is that it follows the money, not the merit. The generative, chat-fronted slice is the one you can put on a slide and demo to a room, so it’s the one that gets the funding, the headlines and the name. The workhorse ML running your camera, your spam filter and your bank’s fraud checks doesn’t make a keynote, so it slides out of view, and “AI” comes to mean only the part someone’s selling. Even the firms surfacing the rest more thoughtfully are still in that lane: Google giving Imagen, Veo and Lyria their own identities is a good instinct, but those are identities for generative tools. The quiet predictive stuff still doesn’t get a logo.

The second reason is closer to home, and it’s about trust. When I tell Hailey that krites uses “a model” to spot blinks, the word “AI” invites her to picture four thousand irreplaceable wedding photos being shovelled into someone’s cloud chatbot. They aren’t. It’s a five-megabyte file that runs on her laptop with no network connection, finds eyes, and returns a number. When the inputs are this irreplaceable, telling those two things apart isn’t pedantry. It’s the difference between a tool she can hand the originals to and one she can’t.

What I should have said

So, to set the record straight. The culler’s first pass is still pure arithmetic, no model, exactly as I said. But krites does machine learning now, and it’ll do more, deliberately, anywhere a learned model earns its place by giving a consistent, inspectable answer that a threshold on its own can’t.

That isn’t me breaking the “no AI” promise. It’s me being precise about a word that’s stopped being precise. When I said no AI, I meant no generative AI. The machine learning was always coming. It was already in the camera that took the photo.