Marked Safe From the Latest Model

In September 2024, I set out to build my first startup, Lira.

On the surface it was a self-help learning network for schools, universities, and businesses. Underneath, it was meant to be three things at once: a place students actually learn, a talent engine that spots ability early and routes it to employers, and, further down, a cognitive signal clean enough to inform how institutions and even policymakers make decisions. A very early solution to the Olodo Uprising.

An AI that learns with you, meets you where you are, and understands a student more deeply than an underpaid teacher with an overfilled classroom ever could. The profile it built would follow you into the workforce, giving employers a truer picture than a résumé ever gives.

LinkedIn essentially, rebuilt from the ground up. Which felt fitting, since my own LinkedIn account had been deleted three times by then, with just automated responses about how I had violated the terms of service. Terms which, when I finally got through to human staff, could not be named.

I'd convinced myself the whole hiring system was broken anyways. Too static, too much friction, a black box where most applications seemed to vanish. So I decided someone should replace it, and that someone might as well be me.

At the time, it seemed wildly overambitious. Building three coordinated products was years of work and a team I didn't have, so for a while it looked like I was in over my head with this idea. Most of the skepticism was directed at the build: technical complexity, cost and time.

The same constraint that has been predictably dissolved with every new release of a frontier model. I know, because I've since built Paylo, a two-sided commerce platform with fairly grand ambitions, largely alone, on the other side of that shift.

What looked like overreach in 2024 is a weekend's scaffolding now.

Should I have stuck with it?

No, but not for that reason. "Overambitious" was a critique about the build, but that was about to get cheap. Models were going to get better, quickly, and the cost of writing software was going to fall with them. Time to iterate would be significantly shorter. Barely an inconvenience.

Most people making that critique didn't have that information, so answering it would have meant answering the wrong question. The only sensible option was to reject the frame. You don't need permission to build on what you know. Whatever killed Lira was going to have to be something else.

So if the build wasn't the problem, what was?

This is how Lira was supposed to work. Schools and universities adopt it as the default system for handing out assignments. Every student needs to study, so it becomes the place they study. Study tools on one side, a growing cognitive profile on the other, and the profile is the real product.

But I soon came to discover that universities had their own ecosystems. Their own hierarchies, their own politics, their own reasons things were done the way they were done. It stopped being a question of whether the software was good, or whether it could even be built. There was a deeper problem sitting behind all of it, and the software couldn't touch it. Who decides. Who has to change how they work. Who loses something if this gets adopted, and most importantly, who do you know that can get this to the decision maker, if they'd care at all?

Besides that, digital solutions like this fail more often than not in Nigeria, for reasons that have nothing to do with the code: unreliable power, patchy connectivity, how few people can afford the device in the first place, and the sheer weight of adaptation it would take to reach the ones who can't.

It just wasn't worth the effort. So I made the hard call and killed the project.

Back to present day. GPT-6 Astra shipped on Thursday. The kill lists went up on schedule, and every few months the cycle repeats: a batch of real teams with impressive traction wake up to find their whole value proposition shipped as a feature by a company with a bigger model and better distribution. Then the posts go up. ChatGPT killed my startup. OpenAI killed my startup.

Some are jokes, some are obituaries, and it's sad to watch. But none of it was a surprise. The models are a tide, and tides come with a table. OpenAI published the scaling laws in 2020: capability rises with compute and data, on a curve you can plot. Every release since is a reading off that curve. A lab shipping a model is announcing that the water reached the mark they said it would.

So every company caught by a release was simply standing below a published waterline.

Lira wasn't. If a frontier model had been my only problem, I'd have pressed on, because a better model only improves my output without replacing my reason to exist. It died on the human factor. Relationships, hierarchies, who has the final say, whether anyone would change their behaviour to adopt it.

That's what I want to talk about:

What, exactly, can these companies not kill?

Start from the money

The funding and research going into AI are not what you spend to get a better autocomplete. At that scale the only coherent goal is capability over anything that can be expressed in code. Framing it as profit or as mission doesn't change the implication: if the goal is reached, everything that lives as code, which is most of the digital infrastructure of the world, ends up within reach of three or four companies.

What they're building toward

There are two ways to own everything that runs on code.

One is to be the store: where intelligence gets bought and the place startups become apps. The GPT store and the connector directories are early sketches of this, and MCP is the plumbing under them, where every tool becomes a plug-in for the platform that calls it.

The other is to be the chip: sitting silently under everyone, the way Intel and Nvidia and Qualcomm do, and taking a cut of everything without needing to be seen.

I don't think they'll choose.

Apple built both.

The store decides what gets distribution, the backend collects on everything else, and a company that holds both has no reason to leave anything on the table. Startups on that platform will do what apps did on phones: be tolerated until the feature ships in the OS.

That being the case, what matters now is what stays outside the model's reach even at much higher capability, and why.

Three reasons something stays outside

1. It's private: the model can't see it.
2. It's not allowed: the model can't act on it.
3. It's structural: it exists because of how people, law, and physical systems are arranged, and no amount of intelligence changes the arrangement.

While AI can help you cover these gaps faster than before, it can't make them disappear. If they ever do disappear, it will be because the internet's basic design changed, not because a model got smarter.

The wash

I came up with a basic vulnerability scan. Four questions, asked of any product or company. A "yes" on the first three means exposed; a "yes" on the fourth means covered. Three yeses and a no, and you're a feature that will be automated away. With a yes on the fourth, you have a moat, though you still have to watch operational inefficiency and capital requirements, because a moat doesn't run the business for you.

1. Is it built on something already in the global dataset, and only on that? Then it can be killed now. The model has read what you read.

2. Does it run on code? If it isn't dead yet, it will be within a few years. Code is what they're spending the money to own.

3. Does it depend on fully understanding a digital system, a non-human one? Then it will be killed. Digital systems are legible to models in a way people are not.

4. Does it depend on something society is built on, rather than something built on society? Privacy. Trust. Guardianship. Responsibility. Regulation. Someone's personal stake in an outcome.

   These aren't in the dataset and can't be put there, because they are relationships between people, or rules people made about each other, not descriptions of them. For the foreseeable future, these are marked safe from every release. This category is what killed Lira. Now it protects everything I've built since.

Everything that doesn't sit on that top step is likely to wash away.

Black, white, and a lot of grey

At one end, the things that wash. Anything that is stored and retrieved rather than worked out fresh. Facts, figures, constants, definitions, the solved problem, the reference text. Much of what we drilled into schoolrooms to build the world we have now lives here, and models already do it well. Recall is close to solved.

If your job is remembering the answer, the model has remembered it too.

Reasoning is not recall, though. Novel mathematics, unsolved physics, a derivation nobody has done yet, these are not stored answers, and models are visibly worse at them than at retrieval. The moment you perturb a problem so the memorised version doesn't fit, performance drops. That is neither the safe zone nor the washed zone.

It is the contested middle, which is exactly where the money is being spent. So don't file the frontier under "already lost."

At the other end, the things that hold. Morals, ethics, faith, emotion, trust. While a model can endlessly produce sentences about them, they aren't facts to retrieve. They are relationships between people and the commitments people make to each other. You cannot put a commitment in a dataset. You can only describe one.

And then the wide grey band between, which is where the real argument of the next few years will be.

Take the law. A model reading every statute and reciting the relevant clause is recall. AI is assisting, and that's fine. That's the washed part doing useful work. But a model interpreting the law, deciding what it means for you with your history, experience and personal circumstances, is a different act entirely. At that point the AI is no longer retrieving data. It's assuming a role that carried authority because a person was accountable for it. The danger was never the model knowing the text. It's the model being handed the interpretation, because interpretation is where the human relationship lived, and the model can only perform the words of it without holding any of the responsibility.

Everything in the grey sits there because it cuts both ways. Most of the discourse ahead won't be about capability. It will be about this sorting: what's black, what's white, and who gets to draw the line through the grey.

I've never spent time on anything a model just couldn't do yet. That's a bet against the curve, and the curve doesn't lose. Paylo sits on the other side of the line, where the model makes me faster but can't replace the reason a buyer and seller who've never met trust the same transaction.

Code is no longer the value

When I pitched at the Breet Builders Grant in June, I said the code is just a harness. At the time, I thought nothing of it. But writing now I realize that probably needed some more context.

A complex system used to cost you a team. Two engineers for six months was somewhere between $120,000 and $200,000 in salaries before a single customer showed up, and that was the lean version. So code was what you raised money to build, and because it was the expensive part it became the protected part.

Today the repo is nearly free. What costs money is the thing that writes it, and that belongs to three or four companies who meter it by the token.

Code is still proprietary. It just isn't yours alone. The value is in what it holds in place, how it's deployed, and the terrain it's deployed into.

Redrawing the line

Every step down in cost raises the water, and the free models should match Astra within weeks. The top step stays dry for the reasons above, while everything below it gets wetter.

The things I've built on sit on that step, but the code I use to serve them doesn't. It sits right at the edge. Which means at this speed, the line crosses something of mine every quarter, and I have to redraw it.

That's just basic maintenance.