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

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