Every AI product of the last few years is shaped like a chat window. That's an accident.

Language models got good at text first, so text became the interface for everything. When software needed a yes or a no, it got a paragraph instead, and had to dig the yes out of it and hope.

Software doesn't want prose. It wants a typed answer: yes or no, one option from a list, a number.

A model that won't talk

On 15 September, TypeSafe AI released Jev. You give it some data and a list of possible answers, and it gives back one of them, with a probability for each and a confidence score. It can't write a sentence. That's the point.

They claim it answers in under half a second, and they don't charge for output at all. Nobody outside the company has checked those numbers yet, so hold them loosely.

I don't much care whether Jev itself wins. I care about what it's pointing at.

Two kinds of thinking

TypeSafe calls it a "System One" model, after Kahneman: fast, intuitive, automatic. A language model writing out its reasoning before it answers is System 2.

You run mostly on System 1. You don't deliberate about catching a ball or reading a word. Deliberation is expensive, so you save it for the few things that need it.

AI has been built backwards. We run System 2 on everything — we use a frontier model and a paragraph of instructions just to decide whether an email is spam.

The stack I think we end up with looks like a brain: a thin layer of slow, expensive thinking on top, and an enormous layer of cheap reflexes underneath doing almost all the work.

The if statement learns to read

Here's what changes when a decision gets cheap enough.

Jev's Doom demo makes about ten decisions a second for about $7 an hour. That's 36,000 decisions for $7 — two hundredths of a cent each.

At that price you stop asking whether a step is worth an AI call. It stops being a feature and becomes a primitive: an if whose condition is "does this look like fraud" or "is this player about to flank me", with a probability attached.

Programming just got a new kind of branch. That's a bigger deal than any chatbot.

The model is named after William Stanley Jevons. His paradox: make something more efficient and people use more of it, not less. Better engines made Britain burn more coal. Cheaper decisions will mean billions more of them, in places nobody would have spent a model call before.

The job changes shape

If the model is a function, the hard part moves to whoever designs the function.

What are the options? What does the model need to see, and what should be filtered out before it looks? What confidence is enough to act on, and what happens below the line — a slower model, a person, nothing? How do you know the line is in the right place? An eval.

That isn't prompt engineering. It's plain engineering: types, thresholds, fallbacks. The skills that looked old-fashioned for a few years are coming back.

And the most important property of a model stops being how smart it is. It's whether it knows when it doesn't know. In a system, a model that's right 80% of the time and can tell you which 80% beats one that's right 90% of the time and sounds equally sure about all of it.

The part I don't like

Jev is closed. No weights, no paper, an API behind a waitlist.

A reflex shouldn't need an internet connection. If the future is a cheap decision in every loop of every program — every game, every robot — then those decisions have to run where the program runs. A reflex that takes a round trip to someone else's datacenter, and stops working when their pricing or their policy changes, isn't a reflex. It's a dependency.

The idea is right. I'd just want to own it and run it on my own machine.

Or the big models just win

The strongest argument against all of this is that general models just get fast and cheap enough, and a special kind of decision model stops mattering. That's usually how it goes: the general method wins.

Maybe. Even then, the interface lesson holds. A program shouldn't have to read a paragraph to find out what the model decided. Typed answers and honest confidence are how software wants to talk to intelligence, whoever ends up providing it.

The chat window was the demo. This is what it looks like when AI becomes part of the program.

Sources

• Introducing System One Models & Jev — TypeSafe AI
• TypeSafe AI debuts model for machines that plays Doom — The Register
• Jev (AI model) — Wikipedia

In ten years, intelligence will be priced like electricity. You'll pay for it by the unit, it'll be cheap, and it'll be boring.

The interesting question isn't whether AI gets smarter. It will. The question is who owns it.

The price only goes one way

Every year, the same level of capability costs about a tenth of what it did the year before. A task that once needed the biggest model in a datacenter moves to a smaller model on rented hardware, and eventually to one small enough to run on your laptop.

Open weights trail the best closed models by months, not years. Whatever the best models can do today, you'll be able to download and run yourself not long after.

When something gets that cheap that fast, it stops being a product and becomes a commodity. Nobody brags about their electricity.

The model isn't the moat

If models commoditise, what's left?

• Compute. Intelligence is FLOPS turned into answers. Whoever has the cheapest FLOPS has the cheapest intelligence.
• Data. The kind you can't scrape: from your own users, your own sensors, your own mistakes.
• Taste. Knowing which of a thousand generated answers to keep.

A company whose only edge is a slightly better model is on a deadline: its lead lasts until an open model catches up. Unless catching up becomes illegal.

Doom sells

In May 2023, the heads of OpenAI, Google DeepMind and Anthropic signed a one-sentence statement: the risk of extinction from AI should be a global priority, alongside pandemics and nuclear war. The same month, OpenAI's CEO told the US Senate that models above a certain level of capability should need a government licence.

Then they all went back to building them.

Maybe they mean it. It doesn't matter. Look at what the fear buys.

It sells the product. Nobody pays a premium for a commodity, but a model that might end the world is the most important thing you could ever invest in. Doom is how you keep AI from being boring.

And it writes the rules. If AI is a weapon, only licensed labs should be allowed to build it, and the labs asking for licences are the ones who'd get them. Open weights become the dangerous thing, and the deadline goes away.

George Hotz made the opposite case when he debated Eliezer Yudkowsky in 2023. The defence against powerful AI isn't keeping it in a few hands. It's putting it in everyone's.

What I actually worry about

It isn't a model waking up with its own plans. It's that the few companies with the most compute end up running the thinking for everyone else, and everyone else rents it.

When you rent your thinking, someone else decides what it's allowed to think about, what it costs next year, and whether you get to keep using it. That's a lot of power in very few places, and nothing from science fiction has to happen for it to go badly.

The answer to that isn't rules that lock the current leaders in. It's making sure anyone can own and run their own models.

Own your compute

This is already more possible than people think. A laptop can transcribe a lecture and run a useful language model today. The speed limit is set by memory bandwidth, and bandwidth per dollar only goes up.

Every year, bigger models fit on your own machine. The future I want is one where that keeps happening until you don't need anyone else's.

Renting will stay cheaper. A datacenter reads the weights once and uses them for hundreds of people at the same time. Your laptop reads them for you alone. Power from the grid is cheaper than running your own generator, too.

That's fine. You don't have to run your own. You have to be able to. The option to leave is what keeps the rent fair.

If you can't run it, you don't own it.

What that means for me

If every layer of AI turns into a commodity, the people who matter are the ones who understand all of them — from the matrix multiply at the bottom to the product someone uses at the top.

So that's what I'm trying to learn. Not one framework. The whole stack, down far enough that when the tools change, I don't have to start over.

I might be wrong

Maybe the biggest models win outright and stay so far ahead that nothing you can own ever catches up. Then the future is a few enormous datacenters, and the rest of us are customers.

I don't think so. Every computing wave so far started centralised and ended up in your pocket. I'd bet on this one doing the same.

A boring future: intelligence as cheap as electricity, and a generator in every house.

Sources

• Statement on AI Risk (Center for AI Safety, May 2023)
• OpenAI CEO Sam Altman Agrees AI Must Be Regulated (TIME, May 2023)
• George Hotz vs Eliezer Yudkowsky AI Safety Debate (Dwarkesh Patel, August 2023)

I hate flat interfaces. Grey rectangles, one accent colour, thin icons, and every app looks like a settings page. Software used to feel like objects. Now it feels like forms.

Everyone says flat won because it was better. I think it won because it was cheaper.

Flat won on price

In 2013 Apple shipped iOS 7 and threw out the leather, the felt and the wood. Microsoft had already gone flat with Metro. Google followed with Material Design in 2014. The story was honesty: a screen is a screen, so stop pretending it's a notebook.

Here's the part the story leaves out. Every texture in the old style was painted by hand in Photoshop, exported again for every screen density, then wired in by an engineer. Every new device meant doing it again. That look took teams of designers and engineers years to build and keep alive. A flat rectangle is one line of CSS, and it scales to any screen for free.

Flat wasn't a philosophy. It was a budget, and the philosophy was written afterwards.

What we lost

The leather was bad. Nobody misses the stitching.

What we lost was information. A raised button told you it could be pressed. A shadow told you what was on top. Light came from somewhere, so your eye knew which way was up. Flat design threw out the information together with the decoration.

Now you hover over things to find out whether they're clickable. That's a step backwards, and we called it minimalism.

Detail just got cheap

The cost that killed skeuomorphism is going to zero.

A model can write the shader for a material, the lighting for a scene, and the CSS for a surface that catches the light. It renders at any size, so there's nothing to export. An image model paints a texture in seconds. The slow, expensive part of the old style is now the fast, cheap part.

What used to take a team of designers and engineers months now takes one person and a model.

When detail costs nothing, flat loses its only real argument.

Even Apple is moving back. In 2025 it introduced Liquid Glass: refraction, highlights, depth. Big companies don't change their whole design language for fun.

The catch

Ask a model for an interface today and you get flat, because it learned from ten years of flat. AI makes depth cheap, but it won't choose it for you. That part is still taste.

And skeuomorphism done cheaply is worse than flat. Fake glass on everything, gradients with no light source, shadows pointing in three directions. At that point you'd miss the grey rectangles.

The point was never decoration. It's physics. Things that look pressable are pressable. Materials behave like materials. Light comes from one place. If you can't say where the light comes from, don't add the shadow.

This site

This site has a folder that opens, a badge that hangs on a strap, and a pile of posts you deal out with a click. None of it is necessary. All of it is the point: you can tell what something is, and what it does, just by looking at it.

A few years ago, that much detail would have been months of work for a team. Building with AI is what made it possible for one person.

Or flat wins again

Maybe flat wins again, for the same reason it won the first time: it's easy to keep consistent. Fifty people shipping one product can all draw a grey rectangle the same way. Depth needs someone who owns the light.

But "easy to keep consistent" is not a good enough reason for software to have no soul.

The excuse was cost. The cost is gone.

Every local-model benchmark you've seen was capped by one division.

To write one token, a model reads every weight it has. All of them, once per token. An 8-billion-parameter model reads 8 billion numbers to produce one piece of a word, then does it again for the next.

The arithmetic on each weight is tiny. Moving it from memory to the chip is not. So the speed limit isn't how fast your chip computes. It's how fast it can read.

tokens per second ≤ memory bandwidth ÷ model size in bytes

Do the division

My laptop is an M1 Pro from 2021. Apple quotes 200 GB/s of memory bandwidth.

An 8B model quantised to 4 bits uses half a byte per parameter, so it's about 4 GB, a little more in practice.

200 ÷ 4 = 50 tokens a second. That's the ceiling. Real runs land below it, because nothing is perfectly efficient. They don't land above it.

Here's the same division for a few machines, with 4-bit weights. A dash means the model doesn't fit in memory at all.

The bandwidths are 200, 170, 614 and 1,792 GB/s. Everything else is division.

Notice the last row. The 5090 is about nine times faster than my laptop, and it can't run the model at all. Speed doesn't help if the model doesn't fit, and on graphics cards, memory is the expensive part.

Newer isn't faster

Look at the M6 column. It's Apple's newest chip, released in September 2026, and it reads memory at 170 GB/s. My five-year-old M1 Pro does 200. For running models, the new chip is slower.

The generation number barely matters here. The tier does. Pro and Max chips have wider memory buses, and that's the whole game: an M5 Pro reads at 307 GB/s, an M5 Max at 614. If you're buying a Mac to run models, pay for memory bandwidth, not for the newest chip name.

What falls out of this

Quantisation is a speed trick, not just a memory trick. Going from 16 bits to 4 makes the model a quarter of the size, so the ceiling goes up four times. That's why everyone runs 4-bit locally.

Your chip is mostly waiting. When you generate text for one person, the compute units sit idle between reads. That's also why a datacenter is cheaper per token than your laptop: it reads the weights once and uses them for hundreds of people at the same time. You're reading them for one.

Mixture-of-experts changes the maths. An MoE model only reads the experts each token is routed to, so its speed is set by the active parameters, not the total. You still need the memory for all of them.

Long context slows you down. Every new token also reads the attention cache for everything before it. At the start of a conversation that's nothing. Thirty thousand tokens in, it isn't.

Reading the prompt is a different problem. The prompt is processed in parallel, so that part is limited by compute, not bandwidth — and compute is the thing a laptop is actually short of. That's why pasting a long document feels slower than getting the answer.

I checked

I ran Qwen3 8B on my M1 Pro through Ollama. At 4 bits it's 5.2 GB, so the division says 200 ÷ 5.2 = 38 tokens a second, at most.

It did 22. Three runs: 22.1, 21.9 and 22.0.

That's 58% of the ceiling. Below it, never above it, exactly where the maths said it would be. I didn't need the benchmark to know roughly what it would say. I just needed a division.