You Had Better Catch Up. Fast.

Next, exclusively on Substack: We are going inside the new generation of compilers to show what they can actually do, how much more of a program’s meaning they can understand, and how they can help fix the mistakes today’s AI coders still make.

The interesting part is what happens when you put both technologies together. AI coders still have to guess a lot of things. Compilers with explicit semantics can take much of that guesswork out of the process.

The result could be a way to turn semi-formal prompts into safe, reliable code, and even work backwards to decompile complex software and figure out what is going on under the hood.

For now, here are two animations to give you a taste of what is coming, with several more in the full article.

Both examples focus on the latest advances in C++ compilers, but there is a lot more to cover. And of course, we will go well beyond C++.

Let us start with two basic animations to give you a glimpse of what is coming in the full article, arriving in just a few days

1. Sets, mappings, and nested contexts. How context narrows the meaning of words and concepts, and how that meaning can be carried safely from an entire project down to a single C++ function.

   

2. How XS compilers are quietly taking on AI coders. A closer look at GCC 16.1 and C++26, and the new mechanisms that allow compilers to understand things AI coders still struggle with.

   

Want to go deeper and learn some seriously useful techniques you simply will not find anywhere else? This is just the beginning. Dozens more articles are on the way, packed with practical examples, real-world applications, and fresh insights into some of the most important areas of technology and AI.

If you are NOT a paid subscriber yet, check out the note below.

And if you already are, congratulations! The full article will land in your inbox in just a few days, exclusively for paid subscribers.

A Note for Free Subscribers ONLY:

The full version of this article is for paid subscribers only. We are going hands-on with XS compilers and AI coders, showing how to put them to work together to turn semi-formal prompts into reliable code and decompile complex software.

Less hype, more actual engineering. Practical examples, real code, and a look at what these new compilers can do that AI coders still cannot.

Coming in the next few days. Upgrade now and get the full article as soon as it drops.

Subscribe now

The Tech War: Compilers vs AI Coding

A new battle has begun in programming, and very few people seem to have noticed how much it could reshape the future of AI coding.

Keep reading, and you will not be one of them for long.

AI coding systems and compilers are moving toward the same territory from opposite directions.

They are still working with the same programming languages. An AI coder can generate, for example, C++26 features such as contracts, concepts, reflection code, or annotations just as a human developer can. But the compiler is the one that actually knows what those things mean, how they fit together, and when the code is simply wrong.

Side note: C++ is not the only language doing this. Rust, Swift, and Zig are playing their own versions of the same game: give the compiler more of the stuff programmers used to keep in comments, conventions, documentation, or, worst of all, their heads. Different languages, different tricks, same idea: if the compiler can see it, you no longer have to remember the damn thing yourself.

What matters is not that the AI can write those features, but what the compiler can do with them afterward.

C++ is getting richer, sure. But the interesting part is that the compiler can now do more with what the programmer tells it, instead of leaving all that detail to comments, conventions, and human memory.

In that sense, the compiler itself is starting to move into territory that, until recently, we mostly associated with humans or AI coding assistants.

But don’t get confused here: the compiler is not turning into an AI. It just has more of the program’s meaning in front of it, so it can catch things that used to depend on the programmer remembering every little detail.

At first, AI seems to have the advantage. You can drop an unfamiliar codebase in front of a model and ask what a function does, where a bug comes from, why a type is exploding, or whether a missing part can be generated. Sometimes it does a disturbingly good job.

Good enough that you start thinking: well, maybe the AI coder really does understand the code.

So be careful now, because here comes one of the most important distinctions in the whole story: despite all these more AI-ish features creeping into programming languages, AI still faces two very different problems:

inspecting code that already exists and generating code that does not. The second is harder for AI coders. For the compiler, things are much simpler because it is not guessing what the program means; it is applying the language rules to code that is already there.

The animation below shows a few code examples that make those differences easier to see.

Now you have seen it clearly in the animation: when AI inspects code, there is already a concrete piece of code to analyze, even if it is incomplete, buggy, or does not compile. Its identifiers, expressions, APIs, types, control structure, and at least some ownership or lifetime choices are already present.

The AI can still get some of that structure wrong, but at least it has something concrete to work from. With code generation, much more still has to be figured out from scratch.

Inspection — existing code → recover semantic facts —  is still difficult because languages like C++ and Rust hide a lot of meaning behind the visible text. The model can misread overloads, templates, traits, conversions, lifetimes, borrowing, or control flow, to name just some of the more obvious trouble spots. But it is still working from a structure that already exists.

With code generation, however, we enter a different world. Consider:

Read more

LLMers Are BSing You

If you follow AI news even casually, you are constantly bombarded with headlines about how close we supposedly are to AGI, usually announced by AI CEOs competing to sound one step ahead of everyone else.

OpenAI’s Sam Altman says we are now confident we know how to build AGI. Google DeepMind’s Demis Hassabis puts it a few years out. And Anthropic’s Dario Amodei, the most aggressive of the lot, has pushed the scaling bet into outright overclaiming, arguing that powerful AI could be just one or two years away.

From Silicon Valley to Shenzhen, LLMers seem to be in a competition over who can make the wildest claim first. Bigger models will become AGI. AGI will become superintelligence. Superintelligence may wipe us out.

As a side note, the genuinely dangerous part has very little to do with some godlike machine intelligence suddenly deciding to destroy humanity, and much more to do with something far more ordinary.

Behind all this futuristic drama, though, most LLMers are making essentially the same bet: that getting from today’s AI to increasingly powerful machine intelligence, and eventually to AGI, is mainly a matter of scaling.

You know the fancy tale by now: more compute, more data, larger models, longer inference, denser GPUs and… voilà: AGI at the end of the assembly line.

There is just one problem, though…

The mathematics does not show that this assembly line leads to AGI.

Why Math Doesn’t Back Them Up

You know something is rotten in the kingdom of AI when brilliant people start waving scaling curves around as if extrapolation had suddenly become a theory of intelligence.

Sam Altman claims that model intelligence scales roughly with the logarithm of the resources used to train and run it. Well, a scaling law can tell you how the curve rises. It cannot tell you when the curve turns into a mind.

Dario Amodei’s argument is even simpler. Skip the formula, add more compute, watch LLMs acquire a broad range of cognitive capabilities, keep scaling and, somewhere up the graph, voilà: extraordinarily powerful, beyond-human systems.

At that point, the mathematics has left the room. What remains is a story about where AI might go, not a prediction of where the mathematics says it will go.

Strip away the glittering façade of GPUs, trillion-dollar infrastructure plans, benchmark curves, and promises of approaching machine intelligence, and what remains is brutally simple: the mathematics underneath does not lead to the destination they are selling, as the animation below conveniently shows.

Now let’s translate the LLMers’ grand claim into plain mathematics and see what is actually hiding underneath all the LLM hype. The recipe goes something like this: take C, the computational resources we keep pouring into the machine, and…

Read more

The wrong question

These are the days of AI’s black legend, and the AI doomers own the headlines. What matters is this: they may be right about the danger. But they may be right the way a stopped clock is right twice a day: by accident, and for none of the reasons written on its dial.

The doom scenario is real enough to take seriously, and sooner rather than later. But the reasons we are told it could happen are fatally wrong.

This story explains why, down to the math, while staying accessible to readers without a technical background, with animations and plots doing the heavy lifting where needed.

The AI Doom Debate by Tribes

Before we talk about boxes, contexts, or escape probabilities, you need to know the battlefield.

The AI doom debate has split into four recognizable tribes. Three think the machine may eventually kill us. One thinks the others need to calm down.

They disagree about timelines, probabilities, motives, and how seriously to take the whole thing. But almost all of them are still staring at the same variable: How powerful will the AI become?

That is where the argument has been stuck. And you will see that it is the wrong question altogether.

Now let’s meet the tribes.

The Rapture Bros

Eliezer Yudkowsky and Nate Soares — whose book is literally titled If Anyone Builds It, Everyone Dies — together with figures such as Dan Hendrycks and Andrew Critch, are among the most visible voices warning that advanced AI could pose an existential danger. Yudkowsky in particular has argued for extremely high probabilities of catastrophe from sufficiently advanced AI, while Hendrycks has pushed for AI extinction risk to be treated as a global priority.

Position, at the most extreme end of this camp: build sufficiently advanced AI without solving control first, and catastrophe may become overwhelmingly likely. p(doom): very high, with Yudkowsky near the extreme end.

They set the date for the end of the world, then asked you to preorder the book about it.

The Nervous Godfathers

Geoffrey Hinton and Yoshua Bengio are not exactly two random guys who discovered ChatGPT a few months ago and immediately started preparing the bunker. They are recipients of the 2018 Turing Award of the 2018 Turing Award, basically the Nobel Prize of computing, and Hinton later received the real thing, the Nobel Prize in Physics, for breakthroughs that made modern deep learning possible.

So after spending decades building the thing, making it better, and collecting some of science’s biggest prizes along the way, they suddenly looked at what they had created and thought: Hang on. How exactly are we supposed to stop this thing?

Position: they built the foundations of modern AI, and now they are warning everyone not to be too confident about where the building goes next. The danger is not certain, but it is serious enough that keep scaling and hope is not a strategy.

They built the fire, won the medals for combustion, and now show up at midnight asking whether anyone remembered to install the sprinklers.

The 25-Percenters

Read more

The Semantic Context Curse of Current AI

If you have spent enough time with C++, you already know the uncomfortable part: code that looks simple is often carrying far more meaning than it shows.

A logger is a perfect example. On the surface, it sounds trivial. Write a message. Add a timestamp. Send it somewhere. Done.

Except it is not.

Very quickly you are dealing with ownership, lifetimes, thread safety, formatting, templates, overloads, build settings, project conventions, and assumptions that live somewhere else in the codebase. Suddenly those five harmless-looking lines are dragging half the project behind them.

And this is exactly where current AI starts getting into trouble.

The problem is not simply that an LLM can forget something. The nastier problem is that one missed piece of meaning can infect everything that comes after it.

Change one innocent-looking line and you can introduce a dependency whose real meaning only becomes visible three calls later, in another file, or several generations down the road. If the model gets that first dependency wrong, the next piece of code can be built on the wrong assumption. Then the next one inherits it. And the next.

Now you do not have one bad line. You have a family tree of bad lines.

Recent repository-level studies describe this kind of downstream propagation as cascade errors.

Math can compress the whole problem into something deceptively simple.

Once one hidden dependency enters the chain, every later step can inherit it. That is the context curse: one piece of hidden meaning becomes part of the context for the next piece, then the next, and so on.

If you are a developer, think of each c as a piece of context. c1 kicks off the chain, and every later c can inherit meaning from what came before.

So the dependencies start nesting.

Miss c1, and you are not just wrong once. You may be building c2, c3, and everything after them on top of the wrong semantic foundation.

That is how one innocent-looking mistake can turn into a whole family of bad decisions downstream.

And this is exactly where LLMs can fail so badly: they are not dealing with isolated lines anymore, but with a growing chain of meaning where every new step depends on what came before.

Seeing the Tokens Is Not the Same as Seeing the Meaning

Read more

Generating Code Is Not the Same Problem as Inspecting Code

Few people realize how brutally complicated programming has become.

Software used to feel almost like a box: write the code, run it, fix the bugs.

That world is mostly gone.

Today, serious software lives inside huge interconnected systems spread across APIs, cloud services, databases, queues, regions, security boundaries, regulations, and third-party software.

A fintech platform may serve banks, currencies, jurisdictions, regulators, institutional clients, and risk models at the same time.

A hospital platform may span hospitals, countries, privacy rules, insurers, devices, workflows, and legacy systems.

And once software reaches this level of interconnected complexity, one old truth becomes impossible to ignore:

Generating code is not the same problem as inspecting code.

Writing something correctly in the first place and finding what went wrong afterward are fundamentally different tasks. But the explosion of AI coders has almost erased that distinction.

We have started confusing:

The AI can find the error after we give it feedback.

with:

The AI understood enough of the problem to generate the right code from the start, given the right prompt.

That is not the same capability. And in real-world software, confusing the two can get expensive fast.

The rest of this article is about why that happens and how we can use today’s Transformative AI with a Transportive mindset while we work toward systems capable of carrying nested semantic context correctly from the start.

You Are Coding Through a Minefield With No Warnings

Read more

Not All Programming Languages Are Created Equal

The key to using AI productively in coding is knowing exactly where the contextual minefields are hidden before your AI coder blows up the entire project.

Of all the myths around AI and coding automation, this may be the most damaging:

AI will soon make developers unnecessary.

The logic sounds obvious. All programming languages collapse into one common abstraction, the LLM learns it, and humans get pushed out of the loop.

AI is already very good at writing the visible code, but it still sucks when it has to deal with what actually makes a real-world project work: the hidden structure of the programming language.

If you thought programming languages were just different syntaxes for the same thing, sorry, but you are wrong. Not all programming languages are created equal. Some hide layers of context, ownership, state, order and semantic rules that all have to remain correct at once.

Or, in plain words: the different contexts that even one simple line of code can carry with it make the myth completely false and the developer in the loop more necessary than ever… depending on the programming language. And once you see it, you will know exactly which group you are in.

Case in point: The C++ Nemesis

That AI can write C++ does not mean that it can build a reliable C++ project.

It can generate templates, write RAII, produce concepts, iterators, lambdas, move constructors, forwarding wrappers, allocators and concurrency code that looks frighteningly competent. Fine.

Yeah, we agree with the fearmongers here. Much of that visible code production is already being automated.

But don’t pop the AI champagne yet.

Because C++ has a nasty property that languages such as Go expose much less aggressively: the meaning of a line can depend on several interacting semantic contexts that are not visible in the line itself.

A piece of C++ can compile cleanly, pass superficial tests and still be wrong because correctness depends on something living several semantic layers away: name lookup, ADL, template dependence, overload resolution, concepts, value categories, object lifetime, ownership, concurrency, you name it.

And this is exactly where AI can screw up your entire project.

The problem is not that it cannot produce the syntax. The problem is that C++ can require something closer to

(code, nested contexts) → meaning

rather than simply

code → meaning.

Now you know where current AI sucks most: nested contexts, whether in C++ or in any other programming language that relies heavily on them.

And if you have read my articles before, this is another smoking gun for why we need a completely different kind of AI, built on a different mathematical foundation from the one we use today.

So the important point is simple:

The line of code is only the visible surface. The real semantics live underneath. And that is exactly where current AI sucks.

Why AI cannot understand what an average developer does without effort

This is the question that really matters to any developer, not just C++ developers, who feels threatened by automation.

An average developer, let alone a senior one, can look at a line of code and immediately recover much of the context surrounding it.

So what is so difficult for an AI about something you do almost routinely?

The animation below will look as familiar to you as the ABC of C++, but the same idea applies to any language with several nested contexts hiding behind even a single line of code.

This simple fact kills any AI coder. This is not a matter of more or less human supervision. The problem is that AI is blind to many of those nested contexts, as you will see in the examples coming next.

Read more

We are surrounded by myths all the time. Yes, even in science and technology.

By the time scientific results reach the public, they have often passed through expectations, money, marketing, and a lot of storytelling. The mathematical details that spoil a good headline rarely survive the trip intact.

AI is the extreme case

We have built an astonishingly powerful machine, but also an increasingly complicated one. When something breaks, the instinct is often to scale the machinery instead of questioning the mathematics underneath it.

But what if scale is not the problem at all? What if better mathematics can eliminate the problem before brute force even begins?

A small group of researchers is already exploring exactly that through geometry and symmetry, equivariance, topology, curved and hyperbolic representations, and related mathematics.

Most of this work still barely reaches the mainstream AI conversation.

That is where this story begins.

We are going to take some of the most familiar beliefs about AI and expose their weaknesses, and in some cases their outright falsehoods, using the mathematics that a more structurally sound AI could be built on.

You will see it for yourself through original animations that make these geometric and topological ideas almost impossible to miss: the real problem with AI may not be that our models are too small, but that we built them in the wrong mathematical space.

Don’t believe me?

Keep reading. By the end, your view of AI will be completely turned upside down.

Most of the AI World Still Isn’t Having This Conversation in Public

This is not another debate about consciousness, AGI, or whether AI will take your job.

I am talking about the mathematics underneath the models. As mentioned before, a small group of researchers is already working on geometry, equivariance, hyperbolic representations, symmetry, topology, and related ideas. But most of that work is still scattered across papers and small technical communities.

Meanwhile, if you are working on AI models or simply using them, you are probably getting tired of the same recipes for the shortcomings of current AI:

Bad representation? Add dimensions.
Weak understanding? Add examples.
Poor memory? Add context.
Weak performance? Train more.
Not enough capability? Give the model more freedom.

Sometimes that works, though with sloppy mathematics.

Often, it just gives you a bigger version of the same problem.

Which leaves a much more interesting question:

How much of what we force AI to learn by brute force is really a consequence of choosing the wrong mathematics in the first place?

That is the question behind everything that follows.

Five Dangerous Beliefs Killing AI, and the Mathematics That Fix Them

OK, you have already seen the problems and the false solutions the AI industry keeps repeating to deal with them.

Now comes the meat of the story.

In this section, you are going to see, as clearly as possible, how some of the myths and bad assumptions slowing AI down look very different once you take geometry and topology seriously and apply them directly to the problem.

Myth #1: More Examples Mean More Knowledge

Start with something embarrassingly simple. Something a current AI model can handle extremely well. For example:

The cat chased the mouse. The mouse was chased by the cat.

The words and the order changed, but they are still describing the same thing.

Now take something many of you have probably run into with AI: ask the model to deal with the same object rotated through dozens of different angles.

The pixels change every time, but the object is still the same object.

If the rotation does not matter to the task, treating every angle as a completely new case is just mathematically wasteful.

Geometry has a very simple way to handle this. Take one object and apply all the transformations that should leave its identity unchanged. The whole family of versions you get is what mathematicians call an orbit.

If those differences do not matter for the task, you can treat that entire orbit as one case instead of hundreds. The resulting space is called a quotient space.

That is the important part: orbits tell you which examples are really versions of the same thing. Quotients let you stop treating those versions as separate problems.

And yet many AI systems still pay for that redundancy through extra data, augmentation, and brute-force fitting.

The animation below makes the difference almost embarrassingly clear.

The system on the right does not magically know more. It simply knows one structural rule that saves it from relearning the same thing hundreds of times.

I call the cost of ignoring that invariance debt: every transformed copy learned separately is another payment.

The theorem underneath is simple. When the symmetry is real, an invariant function factors through the quotient.

In plain English:

Learn what actually changes. Stop relearning what should not matter.

Myth #2: The More of Your Conversation AI Can See, the Better It Remembers

This one will feel familiar to many.

Every few months, the industry announces a bigger context window, meaning the model can keep more of the conversation, documents, and previous instructions in front of it at once.

And from there comes the almost automatic conclusion:

more context = better memory.

But that quietly mixes up two very different things.

Having more of the past available to read is not the same as having a better memory of how that past should affect what happens next.

Imagine you go to dinner with someone who tells you right at the start:

“I hate mushrooms.”

An hour later, after talking about work, holidays, ex-partners, inflation, and why the waiter has vanished for twenty minutes, you order pizza for both of you.

With mushrooms.

The information was there. The problem was what happened to it along the way.

Geometry has a surprisingly useful language for exactly this distinction.

A connection is a rule for how something changes while it moves through a space.

And parallel transport describes how you carry a state along a path.

Now replace physical movement with context.

Instead of thinking of a conversation as a giant pile of old tokens sitting behind the current prompt, think of it as a journey during which the internal representation is continuously transformed.

In geometry, something quite strange can happen: you can travel around a closed path, return to exactly where you started, and still find that your state has changed because of the route you took.

Remember the pizza?

Your friend said, “I hate mushrooms.” An hour later, after the conversation wandered everywhere, you ordered mushrooms anyway.

A bigger context window can keep that sentence visible. Holonomy asks what the journey through the conversation actually left behind in the state.

That is what the animation below shows: on one side, the loop leaves nothing. On the other, the path itself leaves a measurable trace.

And that is the difference between remembering the sentence and remembering the journey.

In mathematics, that leftover change has a name: holonomy.

Myth #3: The Order of Your Prompt Does Not Change the Answer

Anyone who has spent enough time with an LLM knows how ridiculous this can get.

Give the model the same background text, the same question, and the same answer choices.

Now move the background text from before the question to after it.

Nothing else changed. Yet the answer can.

Modern models are sequence models, so of course order matters. The real problem is that we usually notice how much it mattered only after the output goes sideways.

Geometry gives us another way to look at that: one candidate is torsion.

No, prompt sensitivity is not torsion. Torsion is more specific: in the right geometry, it measures one particular failure of local transport to close as expected.

So the useful question is:

Can some prompt-order effects be described by a geometric quantity instead of remaining just another surprise in the output?

That is what the animation below shows.

If that idea works, we stop merely noticing that order changed the answer and start measuring the effect itself.

Much better than memorizing another prompt trick.

Myth #4: More Dimensions Mean a Better Representation

You have probably seen what happens when an AI conversation gets too large. After enough questions, exceptions, side branches, and corrections, the model starts mixing things that were supposed to stay separate.

The problem is not just memory. It is structure.

A lot of what we give an LLM is naturally hierarchical: a plan has subplans, code has dependencies, an argument has branches, a category has subcategories, and one condition may apply only inside one particular branch.

Most LLMs still have to represent all of that inside high-dimensional vector spaces.

So the usual instinct is obvious: when the representation starts struggling, make the model bigger. Add dimensions. Add parameters. Give it more capacity.

But there is another possibility. Maybe the space has the wrong geometry.

Think about a tree. Every time you move one level deeper, the number of branches can multiply. Keep going and the amount of structure grows exponentially.

Ordinary Euclidean space does not grow that way. In a fixed number of dimensions, the amount of room available as you move outward grows only polynomially.

Hyperbolic space behaves very differently. Its available space grows exponentially too.

That makes it unusually well suited to genuinely tree-like structures, because the space expands at the same broad exponential rate as the hierarchy you are trying to fit inside it.

Flat space makes the hierarchy fight for room. Hyperbolic space grows with it.

That is the intuition behind the animation below, showing that hyperbolic geometry can make life much easier when the structure you are trying to represent is genuinely tree-like.

Not because curved space looks cooler. Because the geometry itself grows the way the hierarchy grows.

And this is another good reason to stop treating curvature as some exotic mathematical decoration.

For hierarchical structure, the geometry itself can do part of the work that we otherwise keep trying to recover with longer vectors, more parameters, and more engineering.

So instead of automatically asking, “How many more dimensions do we need?”, sometimes the better question is much simpler:

Why are we still expanding a flat space when changing the curvature fits the structure better?

That is the shift, the right intuition.

Myth #5: If AI Hasn’t Seen It Before, It Can’t Know It

Show an AI the same 3D object from a new angle and one thing has not changed: it is still the same object.

You can teach that by showing the model angle after angle, or you can give it the rule for rotation.

In 3D, those rotations have a precise mathematical structure: SO(3). Quaternions are one elegant way to represent them.

So instead of asking:

Have I seen this angle before?

the model can work with:

I know what rotation does.

It still has to learn the object. It just does not have to relearn rotation every time.

For a rotation-invariant task, the idea is simply: f(gx)=f(x). So you can rotate the input as many times as you want, and the answer must remain the same.

The animation below shows the same idea with Coxeter geometry. One region plus the reflection rules can generate the others. That is the point: you do not need more examples. You need the rule that connects them.

On one side, the system learns the symmetry example by example. On the other, the transformation law is already part of the geometry, so one case can determine the related ones.

That gives us three very different strategies:

sample the symmetry → encode the symmetry → discover the symmetry

The first keeps feeding the model examples. The second builds in the rule itself. In the case of SO(3), that rule simply describes all possible rotations of a 3D object.

And the third goes one step further: AI discovers that kind of rule by itself.

That is the real jump we are waiting for in the next generation of AI.

TL;DR — What You’re About to Learn

This crash course is for AI engineers, investors, and advanced users who want to know how you can actually prove that an AI model deserves to be trusted when it makes predictive or otherwise falsifiable statements.

We will look at why benchmarks so often give the wrong impression, why genuinely unseen data changes the game, and how tools such as Monte Carlo simulation, Kupiec tests, Christoffersen tests, Bayesian monitoring, etc. can turn vague claims about AI reliability into something you can actually measure, test, and certify.

The central idea is simple: do not grade the AI. Grade the task. Then keep testing that grade as reality keeps producing new evidence.

That is what this crash course is about—and I will take the math seriously.

The Most Expensive Technology in History Still Comes With “Don’t Trust Me”

No exaggeration here: the most brutal thing we find in today’s AI industry is the wild contrast between its extraordinary ability to transform $1 trillion into powerful hardware and AI models and the obvious, frustrating impotence of those same models when they fail miserably at handling real-world tasks with consistent reliability.

Even more frustrating is how their CEOs, despite selling this frail technology, constantly remind us that we should let these systems replace humans by automating entire sectors of the economy, writing production software, diagnosing diseases, managing companies …  you name it.

Crazy, isn’t it?

However, you hear exactly the opposite whenever the industry is challenged to show measurable proof behind its revolutionary marketing claims:

Of course we can back our claims. Look at our benchmarks. What else do you need? AI sellers keep telling us, over and over again — despite including a small-print footnote in every chatbot: You cannot trust our AI.

Well, that is exactly the problem. Benchmarks are far away to be a good standard for objectively measuring the reliability, reproducibility, and predictive power of an AI model.

Benchmarks can be perfectly useful for assessing the merits of hardware, programming languages, and even toasters.

But when it comes to systems that must distinguish signals in an ocean of noise, where many real-world decisions ultimately reduce to true positives, true negatives, false positives, and false negatives — a benchmark score can look magnificent on a leaderboard… and collapse the moment it meets reality.

In fact, as we are about to see, the benchmark itself has recently become part of the problem.

Let’s see this in its most brutal form.

If the Student Knows the Exam Beforehand, What Exactly Are You Grading?

Read more

The biggest misconception about AI

Few people realize that much of our technological civilization, including advanced AI, rests on something that sounds almost impossible:

printing chips with light. But not with ordinary light.

Visible light is far too blunt to print the smallest structures demanded by today’s most advanced processors.

Because the process required to do it is so absurd that it sounds like the opening scene of a science-fiction movie.

The adventure, however, begins humbly, with one of the most ordinary elements in the periodic table:

Yep. Not some exotic substance harvested from a meteorite. Not a rare element available only to governments.

Nope.

Just a common, inexpensive metal, melted into a droplet barely a third the width of a human hair.

Then the real madness begins. Good luck with that. Twice.

First, you need a laser pulse to strike a single tin droplet and flatten it into a tiny disk.

Then, a fraction of a microsecond later, you must strike that same microscopic droplet with a second, vastly more powerful pulse.

Before a single second has passed, tens of thousands of droplets have already met the same fate. Droplet after droplet, the swarm ignites, each tiny sphere erupting into incandescent plasma at around 220 thousand °C, nearly forty times hotter than the surface of the Sun.

For one fleeting instant, you have created a tiny artificial star inside a laboratory. And from that star comes the prize you were searching for:

extreme-ultraviolet light EUV

The light capable of printing the smallest structures inside the most advanced chips on Earth.

There is only one problem.

The moment EUV light touches almost anything, it disappears.

Air absorbs it. Glass absorbs it. Ordinary lenses are useless.

So, if you want to use that light to print the most advanced AI chips on Earth, you must guide it with mirrors polished to a level of perfection almost impossible to comprehend.

Here is one way to picture it:

If one of those mirrors were enlarged to the size of Germany, its tallest imperfection would still be less than a millimetre high.

But even those mirrors cannot save all of it.

Every reflection steals part of the beam. Bounce after bounce, most of the light vanishes.

So how the hell do you carry what remains through the machine and deliver it onto the silicon wafer where the world’s most advanced AI chips will be printed?

There is only one possible route.

The entire journey must take place inside a vacuum, using that sequence of unimaginable precision polished mirrors. What little survives is finally focused onto a silicon wafer moving at extraordinary speed, where it prints patterns only a few nanometres wide.

And somehow, this entire chain of events must repeat fifty thousand times every second. Hour after hour. Day after day. Without drifting, missing, or breaking.

By now, disbelief is a perfectly reasonable reaction. But you are not reading a science-fiction tale. Such a machine exists.

So I am not going to ask you to imagine the rest. I am going to take you inside the real machine.

The latest High-NA EUV systems are designed to print features at a resolution of roughly eight nanometres in a single exposure. But that creates a serious problem, the kind engineers call a single point of failure: only one company on Earth can build them.

And that company is neither American nor Chinese.

In the animations ahead, you will watch the tin droplet, the laser pulses, the birth of the plasma, the impossible journey of the EUV light, and its final arrival at the silicon wafer, all unfolding inside a machine almost harder to believe than the science fiction it resembles.

Perhaps the strangest part is that this machine is controlled by neither the United States nor China.

At least, not yet.

You Were Told the Wrong Story About the AI War

You were told the AI race would be won with better models.

That is only half true. Models require chips. And the most advanced chips require factories. So the conclusion seems obvious: the factories are the prize.

Forget Silicon Valley for a moment. It is not the main character in this part of the story.

Move instead to Taiwan, the small island where many of the world’s most advanced processors are manufactured. And now the question becomes unavoidable:

Because factories this delicate cannot simply be conquered. They depend on skilled engineers, uninterrupted supplies, specialized software, spare parts, and machines that cannot be replaced overnight.

Break that chain, and the factory stops being a prize. It becomes an empty shell with a Chinese flag hanging over it.

But there is a deeper problem.

Even Taiwan’s most advanced fabs cannot build the future alone. Their survival depends on a technological frontier that keeps moving, and on machines they do not manufacture themselves.

One machine in particular. A machine so extraordinarily difficult to build that, despite decades of effort, only one company on Earth has mastered it.

Control that machine, and you gain leverage over every frontier model, every advanced GPU, every cutting-edge processor, and every company trying to build the next generation of intelligence.

But neither Washington nor Beijing fully controls it.

Both depend on a machine built in a small European country that many people would struggle to locate on a blank world map.

And that is where our story becomes a tech thriller.

One Machine to Rule Them All

How special can one machine really be?

Look around. The world is already drowning in silicon.

Every day, factories pour out millions of processors, memory chips, GPUs, smartphones, laptops and servers. An endless metallic bloodstream feeding modern civilization.

So it is easy to assume that these factories are where the real power lies. They are not. They are the stage.

The machine you are about to meet is the hidden mechanism beneath it.

For that, the entire industry depends on one machine that makes the making of chips possible.

That distinction is where the story changes.

Because once you understand what happens inside it, the rest of the AI race begins to look almost secondary.

And the crucial thing is not any one component. You have already met many of them in the opening of this article: the lasers, the molten tin, the vacuum, the mirrors, the wafer racing beneath the light.

Each is only one piece of the puzzle. The underlying principles are known, and many of the parts come from specialist suppliers.

The real miracle is not any single component. It is the choreography.

Every laser pulse, every mirror, every moving stage, every sensor and every control system must perform its part at precisely the right moment.

A mistimed pulse, a tiny thermal expansion, a vibration only a few nanometres wide, or a sub-nanometre misalignment can spoil the pattern being printed.

They must all enter at the right moment, hand the process to the next system, and never break the chain.

But the real challenge is not merely making today’s machine work.

It is leaving enough room for tomorrow’s machine to go even further.

Every new generation must print structures even smaller than the last, squeezing more transistors into the same piece of silicon, continuing the decades-long trend known as Moore’s law.

And sometimes, after decades spent mastering lasers, materials and the physical limits of lithography, the breakthrough arrives in a form that sounds almost absurdly modest: not as a new light source, a new substance or a new law of nature, but simply as a slightly wider cone of light.

That tiny change is enough to carve dramatically smaller structures into silicon, allowing billions more transistors to occupy the same space

And there it is.

The machine that makes everything you have seen so far possible.

It carries the cold, almost deliberately unremarkable name ASML TWINSCAN EXE:5200B — a label that gives no hint of the extraordinary role it plays in the technological life of our civilization.

And from the outside, the deception continues.

The magic is hidden inside, where all those components finally become one system.

That is the achievement nobody else has reproduced. Not the laser alone. Not the mirrors. Not the vacuum. Not the moving stage. The real wonder is how one Dutch company, ASML, has made them all work together continuously, reliably, and at the limits of physics.

So let us step inside.

By now, you already know the light. You have watched it emerge from tin plasma and survive its journey through the mirrors.

Now it reaches the moving wafer.

Pattern by pattern, layer by layer, a microscopic city begins to rise from the silicon. What eventually emerges is a finished chip: a nano-city printed with light, ready to become the next frontier AI processor

And all of this wonder unfolds inside the womb of the machine: a miniature universe sealed from the outside world, filled with ultra-high vacuum and kept around a thousand times cleaner than an operating room. In that isolated world, where even a single speck of dust becomes an enemy, the future of advanced AI is printed with light.

Ecce machina!

This is the narrowest bottleneck in the entire AI economy.

If OpenAI disappeared tomorrow, another company would eventually replace it.

If Nvidia disappeared tomorrow, AMD, Google, Amazon, or dozens of startups would race to fill the gap.

Even if one of the world’s largest chip manufacturers vanished, others could slowly absorb its production.

But remove this machine…

…and the entire frontier of artificial intelligence stops moving forward.

References and Further Reading

1. ASML. TWINSCAN EXE:5200B: High-NA EUV Lithography. Official specifications for ASML’s second-generation 0.55-NA system, including its 8-nanometre resolution, higher imaging contrast and intended use in sub-2-nanometre logic production.
   ASML: TWINSCAN EXE:5200B

2. ASML. Light and Lasers: Lithography Principles. Explanation of the molten-tin droplets, dual laser pulses, plasma formation and the generation of EUV light, with the process repeated 50,000 times per second.
   ASML: Light and Lasers

3. ASML. 2025 Annual Report.ASML’s latest annual account of its High-NA EUV programme, commercial progress, technology roadmap, supply network and delivery of the full-specification EXE:5200B.
   ASML 2025 Annual Report

4. Intel. High-NA EUV at Intel. Intel’s overview of its High-NA installation, including the comparison with a double-decker bus and blue whale, and the tin plasma temperature of nearly 220 thousand °C.
   Intel: High-NA EUV Press Kit

5. Imec. Imec Receives the World’s Most Advanced High-NA EUV System. 18 March 2026. Covers the installation of an EXE:5200 system and its role in developing future generations of advanced memory and computing chips.
   imec: EXE:5200 High-NA EUV Installation

6. ASML. Five Things You Should Know About High-NA EUV Lithography. 25 January 2024. An accessible explanation of the 0.55 numerical aperture, anamorphic optics, improved resolution and engineering challenges behind the EXE platform.
   ASML: Five Things About High-NA EUV

7. ZEISS Semiconductor Manufacturing Technology. EUV Lithography and Technology. Describes why EUV requires a vacuum and reflective optics, how the projection system works, and why the mirrors rank among the most precise objects ever manufactured.
   ZEISS: EUV Lithography and Technology

The AI industry will confidently promise to reinvent education, medicine, science, dating, warfare, and lately even your mortality.

But ask what its coding models can already do, and everyone suddenly turns into a nervous, defensive salesperson.

Well, it depends.

The model may produce incorrect results.

Human supervision is still recommended.

No kidding. Human supervision is also recommended when humans write software. That is why we have code reviews, tests, staging environments, debuggers, incident reports, and senior developers staring at broken deployments late into the night.

The strange thing is that AI coding is being judged by standards that human programmers have never met. One camp shows an agent building a tiny web app and announces that software engineers are finished. The other watches the same agent misspell a variable and announces that machines cannot reason.

Both conclusions are ridiculous, and both come from the same statistical mistake.

Everyone stares at the numerator: how many coding tasks did the AI solve?

Almost nobody checks the denominator: what kind of tasks were they?

And that denominator contains nearly the whole story:

Was the model asked to write a ten-line utility function or repair a payment system spread across forty services?
Did it receive the whole repository or three disconnected files?
Could it run the tests?
Were the tests any good?
Did the documentation match the code?
What kind of task was the model actually given?

So here’s the first hint: whenever you analyse an AI coder, inspect its soft underbelly — the denominator: a ten-line function is not a forty-service payment system. A full repository is not three pasted files. A model with tests, logs, tools, and retries is not the same machine as a chatbot forced to guess from a vague prompt.

AI coding ability does not come from a clever little homunculus — a tiny programmer hiding inside the model and doing all the thinking.

It comes from the whole setup:

model + context + tools + feedback + human judgment

Change the setup, and the same AI can look brilliant, useless, or confidently break a system it never understood.

And this is where both camps rig the experiment.

The optimists show the cleanest run. The pessimists remove half the context, tie one hand behind the agent’s back, and present the crash as scientific proof.

Neither tells you when the machine is actually useful.

That is the skill worth learning: knowing whether the agent simply needs more context, has made a bad guess, has written code that only looks correct, or has wandered so far from the architecture that you need to drag it back by the collar.

Learn to spot the difference, and AI coding becomes less of a dark art — and more of a practical defensive skill.

SOFTWARE FOLKLORE IS LYING TO YOU

Let’s start with the myths that keep us from understanding AI coders — and from using them properly.

Look at the table below. These are the stories about AI that, if you’re a developer, you’re probably tired of hearing from other developers — even though, as you’ll see, the evidence points the other way.

Software engineering is not uniquely irrational, of course. Every field has its favorite myths. But ours are especially bizarre because developers love talking about evidence … right up until AI coding comes up.

So let’s put those beliefs on trial and see which side the evidence actually favors: the techno-optimists or the techno-pessimists.

Spoiler: neither.

Myth One: The Parrot Alibi

AI coding only works because the model has already memorised the answer.

Read more

Welcome to the First TechUnderWorld Skool Crash Course

This is the first course in a series designed to prepare you for the next generation of AI—far beyond the usual tutorials, headlines, and recycled explanations.

We will not only examine what is broken in today’s AI.

We will explore the most serious mathematical and engineering ideas being developed to fix it: the same problems currently keeping the major AI labs busy.

But you do not have to wait for those labs to package the next generation into a product.

Here, you will learn how to recognize what is coming before it reaches the mainstream.

What is the trick?

The right mathematical and engineering mindset.

We will move through research papers, patents, emerging architectures, and recent mathematical developments to build a precise map of what is happening—both from above and deep inside the machinery.

You will learn which technologies could shape AI over the coming months and years, why they matter, and how to evaluate them for yourself.

That last part is the most important.

The goal is not merely to give you information.

It is to help you develop the skills and instincts to navigate the next AI wave independently.

TechUnderWorld Skool delivers hard facts, real mathematics, and serious engineering in simple language—told as an immersive, almost cinematic story.

Enjoy the course.

Prepare for a Semantic Machine, Not a Token Parrot

We talk to language models in messy human language: incomplete, ambiguous, and packed with assumptions we never bother to state.

And you already know the price. The same damn ritual: prompt. Correction. Clarification. Another correction. Five more messages…

Eventually, the machine produces something close to what we wanted in the first place… or not.

Human language is much more than words. Most of the time, another person can understand what we mean from a few words, a gesture, or even a look.

Try that with a machine, and things can become complicated — or completely nonsensical — very quickly.

That brings us to the second reason: context.

Humans are remarkably good at separating the different, sometimes completely contradictory, meanings of the same word, gesture, or idea.

We do it almost effortlessly.

The same sentence can sound serious, sarcastic, affectionate, threatening, or absurd depending on who says it, when they say it, and what happened five minutes earlier.

Now imagine that same situation inside a transformer — the token-processing engine at the core of today’s LLM chatbots.

LLM Chatbots Are Sticky Tokenizers

Some of you may argue that self-attention does not keep every token locked inside its own little box.

And yep, you are right.

Each attention head updates a token by mixing information from the tokens around it, giving more weight to whatever the model considers most relevant. So there you have it: context is being handled. What is the problem?

The problem lies in what can happen when that mixing is repeated across layer after layer.

Think of making a salad. At the beginning, every ingredient is easy to distinguish. You can clearly see the tomato, the lettuce, the onion, and the cucumber. Then you add oil and vinegar and start tossing everything together. The ingredients are still there, but their flavours begin to mix, and the boundaries between them become less sharp.

Self-attention can do something similar with token representations.

It mixes and averages information again and again, so distinctions between words, meanings, and their roles in the surrounding context can gradually become blurred inside the model.

LLMs learn contextual regularities from enormous collections of token sequences. They are extremely good when a new situation resembles combinations encountered during training.

But context is combinatorial.

Suppose meaning depends on ten contextual variables, each with ten possible states.

That already gives:

possible combinations.

No training set can explicitly cover them all.

Of course, the machine does not need to memorize every combination if it learns reusable concepts and rules for recombining them.

That is the whole trick.

Current LLMs do not always learn those clean factors. Sometimes they learn shortcuts, statistical habits, and correlations that work beautifully, until familiar pieces appear in an unfamiliar arrangement…

Take two apparently simple concepts:

justice and law.

Their relationship is not fixed.

It changes with the jurisdiction, the institution, the historical period, the type of offense, and the moral framework being applied.

We should really write:

In one context, legality and justice may largely coincide.

In another, something can be perfectly legal and still widely considered unjust.

Even within the same legal system, their relationship may change between contract law, criminal law, military law, or politically regulated conduct.

The words remain the same, but the relationship between them changes.

This remains difficult for current LLMs because, despite what many introductory AI explanations may suggest, processing context does not guarantee that a model will represent different contexts as clean, explicit, and separable structures.

In many real-world cases, legal, cultural, and religious assumptions remain implicit and entangled inside the model’s learned representations, as the animation above illustrates conceptually.

So how does the industry try to solve it?

By throwing more data, more parameters, longer context windows, and more corrective training at the problem.

And yes, the results improve, but only by throwing exponentially more compute at the problem, with energy consumption rising sharply alongside it.

Worse, getting more answers right does not mean the machine has understood why they are right. It may simply have learned better shortcuts through familiar patterns.

The next machine will need something more explicit.

Not merely tokens mixed with context.

A representation in which concepts, relationships, assumptions, and constraints can be inspected, recombined, challenged, and changed independently: a truly semantic machine.

THE CONTEXT CURSE OF TODAY’S AI

Read more

Whether you are an AI newbie or a senior AI engineer, you may be risking your future by using the wrong AI mindset.

Let me explain.

Most of us have been taught two fatal fallacies about AI.

The first is that today’s transformative generative AI is somehow the only possible form of machine intelligence — and that the road to AGI is simply to give it more speed, more memory, more data, and more compute.

The second follows directly from the first: that the mathematics and programming you need to learn are basically linear algebra and GPU programming. Forget geometry, topology and category theory. Forget Bayesian reasoning and probability distributions. Just multiply bigger matrices on bigger clusters and wait for intelligence to emerge.

But there is a problem, one the AI industry rarely puts center stage.

While the public is being sold an endlessly optimistic future of faster GPUs and ever-larger LLMs, the numbers are beginning to tell an uncomfortable story.

Today’s AI may already be approaching the end of its reign as the uncontested paradigm. You do not believe me?

Then look at the relationship between performance, computational cost, and marginal returns.

As computation, memory, parameter counts, and training resources increase, marginal returns do not rise proportionally. They begin to flatten. You spend vastly more to extract increasingly smaller improvements.

That means every new generation of frontier LLMs risks becoming dramatically more expensive — not merely in money, but in energy, chips, infrastructure, and computational complexity — while the gains become harder and harder to extract.

So the numbers leave us facing an inescapable conclusion.

Either a new breed of machine intelligence, built on new mathematics and new technology, takes over and resets this insane trajectory of escalating energy and computational cost…

or we may be heading toward a third AI winter.

And that new machine may look very little like the AI you know today.

Okay, I can already hear you saying: Sure, current AI has its flaws, but isn’t it still better to keep improving LLMs and building new frameworks around them than to bet on a completely different kind of AI that does not even exist yet and sounds like science fiction?

Not so fast, dear reader.

This new AI is not merely mathematics confined to books or technology still waiting for a blueprint. Startups and established companies are already building the technology, testing prototypes, and turning parts of it into real products.

Most of these systems are not mainstream yet. Some are still early. But the results suggest that they could move from the lab into wider use — and begin taking serious market share — over the next few years.

The New Frankenstein Factories Are Already Here

The next thinking machine is not emerging from a single laboratory.

It will emerge from an ecosystem.

And the right mindset now begins with understanding how that ecosystem actually works.

One company builds the nervous system.

Another develops the body.

Another specializes in memory.

Another teaches the machine to interact with the physical world.

Another models biology itself.

Even Google DeepMind, the company that currently comes closest to integrating many of these ideas under one roof, is better understood as the center of a much larger Alphabet ecosystem than as a completely self-contained AI factory.

Around it, Alphabet has built specialized organizations such as Isomorphic Labs, dedicated to AI-first biology and drug discovery, and Intrinsic, focused on intelligent robotics and physical AI. These companies operate independently, but collaborate with Google DeepMind wherever their technologies overlap.

That is the first sign that the future of AI is already changing before our eyes.

Until now, the standard model was simple: a startup grows around one star product — usually an LLM chatbot built on generative transformer AI.

Those days may be coming to an end.

Instead of one promising rookie startup, or one already consolidated giant laboratory trying to solve everything, we are beginning to see an AI industry organized around networks of specialized suppliers and cognitive supply chains.

And yes, Frankenstein is the perfect metaphor for what is happening.

Different companies are developing different parts of the same emerging system: better neurons, more capable bodies, richer world models, biological reasoning, and machines that improve through experience.

No single company has assembled the complete monster.

But the factory chain producing its organs is already running.

And here are the companies currently running the show — some old, some rookies, but all converging toward a new mode of AI production.

The consequence may be enormous: the LLM-based AI we have seen so far could end up looking like a mere cognitive toy beside what is coming over the next few years

The Organs

Victor Frankenstein would feel strangely at home in the current evolution of AI.

The difference is that, instead of collecting a few dead organs, stitching them together, adding electricity and — well, you already know the rest — he would become an AI engineer and assemble something far more abstract.

Not biological organs. Mathematical organs disguised as technology.

Read more

Yes, you read that correctly… the title says lack of innovation.

Absurd, right?

NVIDIA is worth trillions. OpenAI owns the headlines. Jensen Huang is treated like a technological prophet, while Sam Altman is crowned someone like the Steve Jobs of intelligence. These are supposed to be the hottest, smartest, most innovative companies on Earth, the places everyone wants to work for and every investor wants to own.

Their genius appears beyond question.

But let’s step away from the marketing stage and go backstage, where the bolts, code, and machinery actually live.

There, a more dangerous question appears: What if the companies leading AI are not building the future, but blocking it?

Because the next breakthrough may not need a larger model, another generation of GPUs, or one more trillion parameters.

It may require abandoning the foundations NVIDIA and OpenAI have turned into dogma: flat statistics, fake neurons, and brute-force computation.

And that is where the masks come off — where we see the real face of these companies, and how the architecture that made them powerful may now be standing in the way of real AI.

A better path already exists. But AI must first escape the architecture that made today’s giants rich — and the technology dangerously fragile.

The current situation of NVIDIA and OpenAI

NVIDIA has two faces, like Janus.

The first is the face of marketing: the triumphant story Jensen Huang tells whenever he walks onto a stage carrying another GPU

The second face is backstage, where the reality is far less glamorous.

Strip away the theater and one uncomfortable question remains: why are the descendants of hardware built to render graphics and animate video games now sitting at the center of the so-called AI revolution?

For most of NVIDIA’s history, gaming was not some side business. It was the business. Some veteran gamers will remember that, as late as 2014, demand for high-end GeForce cards still drove much of NVIDIA’s GPU revenue.

Of course, we have all heard the GPU evangelists preach the gospel: billions of operations, massive parallelism, oceans of computational power.

But once the spectacle is gone, the miracle looks much simpler.

A GPU is an extraordinarily fast machine for multiplying and adding numbers across enormous matrices. A glorified mathematical coprocessor: brutally efficient at arithmetic, yet showing no trace of the intelligence celebrated so triumphantly on NVIDIA’s stages.

Fine. Then perhaps the real secret is not the chip, but CUDA, NVIDIA’s distinctive software platform. Surely this is where raw hardware becomes programmable intelligence. Is CUDA the missing bridge between matrix computation and cognition?

Unfortunately, CUDA is a venerable platform introduced in 2006. Over the past two decades, it has accumulated new libraries, tools, memory systems, language features, and AI-specific optimizations. But beneath all those additions, its basic computational worldview has changed surprisingly little.

And CUDA deserves credit. It took the parallel power of graphics processors beyond graphics and opened it to general-purpose computing. At the time, the idea was revolutionary: launch thousands of threads, divide the work into blocks and grids, and make the GPU process enormous quantities of numbers at once.

But two decades later, a geological era in technology, CUDA still rests on essentially the same idea: break a numerical problem into even more parallel operations and run them even faster.

That is the whole trick.

A remarkable engine for accelerated computation. But still no bridge from arithmetic to cognition. Nope.

The Case of OpenAI

Read more

A Mind-Blowingly Realistic World Built Without Modern AI

Let me start with what GTA 6 is not, because almost everyone online right now is about to sell you the wrong idea without bothering to check whether their claims are credible.

One thing already seems clear: if you are waiting for NPCs with a next-generation brain, forget it. The people walking through Vice City will still be stereotypes with scripts. They will talk, panic, drive, fight, flee, and forget you five seconds later. They will not become tiny conscious agents living inside your console.

And that is not a failure. It may be the smartest thing Rockstar has done.

And the machinery behind that illusion is not magic. It is the old recipe that has always worked: mathematics, geometry, graphs, manifolds, hierarchies, control systems, and classical programming, meaning algorithms and data structures, all shaped by clear goals and better design.

I can heard you already… How can you be so damn sure when the game hasn’t even been released yet? Is this just cheap advertising disguised behind a clickbait title?

Fair question. And yes, you are right to ask it.

What I can say with confidence about GTA 6 is not based only on Rockstar’s marketing campaign. It is based mainly on what its own patent filings quietly reveal about essential features and technical innovations, and on the mathematics behind those features.

That is the material I am using here: public footage, public patents, and the mathematical constraints any world like Leonida must obey.

Transparent, genuine, and readable for anyone willing to look at the evidence instead of the hype.

And before we dive into the nuts and bolts behind Leonida, let me say one more thing clearly: GTA 6 may become the reference point for the entire industry for years to come, and it does not need the other great hype of our age: transformer AI stuffed into everything and sold as the future of everything.

Because the real miracle of GTA 6 is hidden somewhere else.

In its structure. You will see it for yourself. Enjoy

GTA 6 Is Not Just Bigger. It Is a Bigger Mathematical Problem

Rockstar’s Leonida is its Florida: Vice City, the Keys, wetlands, highways, small towns, rural regions, beaches, interiors, traffic, water, bodies, reflections, light, and thousands of objects that all need to appear continuous.

And this is where the problem becomes more interesting than the marketing.

Because bigger worlds already exist. Of course they do. Daggerfall is often cited with its 160K-plus square kilometers of procedural sprawl. Starfield gives you more than a thousand algorithmic planets. No Man’s Sky went completely cosmic with eighteen quintillion worlds. But that kind of scale is bought through generation, not authorship.

Denser worlds exist too, but they usually shrink the map to make density possible. Cyberpunk 2077’s Night City is one of the great modern density machines, a city where the open-world formula is compressed so hard that the wilderness almost disappears.

And hand-authored worlds of huge ambition exist as well, but they often solve the problem by division: different regions, separate maps, stitched continents, repeated activities, controlled transitions. The Witcher 3 gives you Velen, Novigrad, Skellige, and Toussaint. Assassin’s Creed gives you enormous historical playgrounds, but often through repetition, segmentation, and scale tricks.

So no, if Rockstar delivers what the trailers, patents, mapping evidence, and its own marketing imply, GTA 6 will not be the largest world ever made. That is not the interesting claim.

The interesting claim is harder. Leonida may be one continuous world large enough to read as geography, dense enough to behave like a city, and simulated deeply enough to feel alive at that scale.

That is the rare combination: not a world that is merely big, or merely dense, or merely beautiful…

But a continuous, authored, dense, physically convincing space, built to make the hours you spend inside it feel less like playing through a map and more like inhabiting a living world.

And that is where Leonida stops being only a map and becomes a mathematical problem.

Because once you compare it with GTA 5’s San Andreas, the real difficulty appears.

A larger map is not just extra land. It means every system is under pressure at once: space, traffic, interiors, physics, lighting, reflections, water, pedestrians, vehicles, and the invisible streaming machinery that keeps the illusion from falling apart.

So here is the first real question behind GTA 6:

How can a console stitch together patches of geography without gaps, misplacements, trembling edges, broken roads, or objects popping out of existence, when there is no single global map sitting in memory?

That question sounds technical.

It is actually the doorway into the whole miracle.

The answer is not simply more storage. The answer is representation

Read more

Software Development Is Already on AI Life Support

Many of us saw the writing on the wall the moment the COVID pandemic lifted and the new generation of transformer chatbots arrived.

First, they gutted Stack Overflow.

Now they are coming for entire professions, and software development is the first white-collar field where the damage is impossible to ignore.

Junior and mid-level positions are shrinking at a pace the industry has never seen before, and the squeeze is now reaching senior roles too.

On the other side of the coin, for now, the view looks better.

AI engineers, and everyone whose output has been multiplied by an AI assistant, seem to be thriving.

But are they actually safe?

You Need an AI Workflow. And Now It Is Almost Too Late.

The first brutal lesson from the wreckage of tech jobs is simple:

This is no longer a matter of choice.

If you work in tech, you either build your own workflow of AI assistants now, or you start looking for a skilled trade outside the blast radius.

Yes, humans are still needed in the loop. Yes, today’s flat AI is still far from replacing a serious developer end to end. And yes, if you ship production code, you still supervise everything the assistant hands you.

But none of that is an argument against using AI.

It is an argument against using it badly.

And the worst way to use AI is to lean on a single assistant as if it were a magic black box.

Claude, Cursor, ChatGPT, Copilot, whatever name you prefer, none of them should be trusted alone.

Some of you already know this. Unfortunately, many still do not: one AI code assistant is not a workflow. It can miss the context, misunderstand the problem, and dress a bad fix in clean code.

So if your whole setup is one assistant and blind trust, you are not engineering with AI. You are working with a chimera: part autocomplete, part sycophantic parrot.

And because today’s AI still lacks real Bayesian judgment, you have to do something the model will not reliably do for you: read the confusion matrix.

Read more

We are living through a brutal artificial-cognitive age.

At first glance, the latest US government move against Anthropic’s Fable 5 looks like paranoid overreaction: Washington treating a frontier model as if it were the first child of Skynet, and the jokes write themselves. You know the continuation of the story: a coding assistant was suddenly handled like fissile material, and consequently access vanished worldwide.

Before we join in the mockery, we should take a closer look at the case.

Fable 5’s defining strength is simple: it is the most capable AI software engineer released so far, beating every competitor outright. It can tackle and solve real-world problems, both at the surface level and deep within software systems. This alone puts Fable 5 at the limit of what LLMs have been able to achieve so far

You want examples?

Stripe, the payments company, pointed Fable 5 at Stripe’s own fifty-million-line Ruby codebase and asked it to perform a single migration across the entire system in a day — work the company estimated would have taken a team of engineers more than two months. Stripe described the result as compressing months of engineering into days.

Read that slowly.

Because the impressive part is not the line count. It is the deep semantic coherence.

That is not autocomplete at scale. It is engineering.

The benchmarks in the table above only confirm the example and show us how brutal the emerging pattern is.

Fable 5 dominates the coding stack, where that dominance makes the human software engineer without AI a real piece of archaeology: real software tasks, hard agentic execution, code quality, long-horizon work, and tool-driven autonomy.

And now I can already hear some critics — critics I can even agree with: benchmarks are not always a reliable way to prove the effectiveness of a modern AI, because those separate traits should be tested together in realistic scenarios.

Fine.

Fable 5 seems to have taken the challenge personally: it completed Pokémon FireRed from start to finish using only raw screen screenshots, with no maps, no navigation aids, and no hidden game-state information. Earlier Claude models needed a complex helper harness just to play Pokémon at all.

Why does that matter?

Because Pokémon sounds like a joke only until you remember what the game actually demands.

The model has to see through pixels, remember where it has been, navigate towns, caves, battles, menus, dead ends, you name it… recover when it gets lost, and keep going after thousands of small decisions.

That is not a toy skill. That is what we can call continuity.

And continuity is exactly what separates answering a question from actually getting something done.

Is Fable 5 Really That Good — And That Dangerous?

Now comes the surprise: how can a technology this excellent be treated, at the same time, as dangerous?

Paradoxical? Not after you have read this section.

Washington may have misread the mechanism, but it did not hallucinate the danger. The danger is real, though we can agree it is not where they think it is.

That contrasts brutally with Anthropic’s public position, which is straightforward: Fable 5 was built with heavy safeguards to prevent misuse in malware development, cyber abuse, and other high-risk domains.

But reality has derailed Fable 5 from that ideal safety track: it may be the best AI software engineer we have ever seen, yet it still struggles at the exact border where the same repair operation can mean fixing legitimate code in one context and enabling malware by repairing the wrong code in another.

That is the danger. Not that Fable 5 is evil, but that it cannot reliably know what the repair is for. As happens with the whole family of transformer LLMs, they do not cleanly separate context from concept, because context and concept are folded into the same token representation, not carried in two different lanes. Do you remember the distinction between functor and profunctor?

So why the heck does the blunder happen precisely in the feature Anthropic has been selling as Fable 5’s killer capability?

Pay attention to this, because here the paradox snaps into focus: the same thing that makes Fable 5 the best AI software developer is also what makes it dangerous.

Look at the animation below and the trick becomes obvious.

Read more

Mathematician Lurking in the Tech Underworld is no longer just publishing articles.

It is building a survival map for the age of artificial cognition.

If you want to thrive in this new world (not just professionally, but personally and intellectually) you cannot live from headlines, hype, and recycled tech noise.

You need to see the monster from inside its own machinery, with the right tools and the right mindset.

That is why MLITU now opens two new streams: Behind Tech Matrix and RedSoma…the new age has already begun.

What was once reserved for the tech elite is now within your reach.

It cuts through the surface with technical X-rays, connecting AI, markets, mathematics, models, systems, and human impact into one sharp picture.

Not simplified into noise, not diluted for comfort, and not dressed up as entertainment for technological tourists.

Precise. Brutal. Useful.

Welcome to the new MLITU age. Get your ticket now

Bitcoin is sleeping. Not dead. Not finished. But the real story is happening somewhere else, and as I wrote here months ago, that story is AI.

AI infrastructure is quietly eating the rails Bitcoin was built on: the global transaction network, the plumbing of payments, settlement, credit, you name it. The new flavor of AI, with several agents working inside flexible workflows, is now challenging what once looked like Bitcoin’s indisputable future: not only as the enemy of traditional banks, but as the digital currency protocol of the internet itself.

But here comes the irony of destiny.

It has to be precisely Bitcoin that exposes one of AI’s biggest weaknesses.

Because when you throw AI into hypervolatile markets like BTC, AI fails miserably.

And of course you can ask: so what? What is the problem if AI is not useful in hypervolatile markets?

The problem is simple. Hypervolatile markets are among the most profitable markets of all. More risk, more potential profit.

But there is a deeper point beyond the market itself: the inability of today’s monstrously expensive AI to cope with the kind of variable real-world problems it was sold as being able to solve.

So is there an alternative? Yes.

And it is cheaper, colder, and far more dangerous to the AI hype machine than many people would like.

And AI is not built for that. It is not built to cope with a world that changes under its feet while it is still calculating.

BTC Is Exposing One of AI’s Biggest Pending Blunders

The weakness, as you have probably already realized, does not stop at Bitcoin.

You can generalize it to most real-world problems, because this is exactly what reality does every day: it changes the conditions while we are still trying to react

Read more

Nvida and OpenAI are still playing a lost game

Nvidia and OpenAI have overextended their bets on old AI so badly that their only move left looks like a flight forward.

Yes, I know the obvious reaction… because anyone looking at their market value, their charts, and the ocean of money around them will think the same thing: This guy must be out of reality.

But that is exactly how bubbles speak before they crack.

The same market that inflated Nvidia’s value at insane speed can also punish it at insane speed once investors understand the forbidden sentence of this AI cycle: More computation does not mean AI stops hallucinating.

It means marginal improvements bought at exponential cost.

By ignoring the writing on the wall, Nvidia doubles down on computation: more power, more heat, more money poured into flat-AI GPUs.

OpenAI doubles down on chatbots that do not truly transport thoughts. On the contrary, they blend them into comic misfigurations. And then, again… you guessed right… into hallucinations.

This failure is not diffuse. It does not require mystical interpretation or overcooked nerd analysis. It is visible in the math.

Read more