Artificial Intelligence is BLIND as a BAT

The Most Powerful Artificial Intelligence Ever Built Is BLIND AS A BAT!!!

Yes, you read that correctly. The same AI that can write a program for you in ten seconds, translate into forty languages, and spit out an analysis before you have even finished asking the question has one tiny flaw that nobody at conferences seems brave enough to mention:

It cannot see.

It does not know whether the code it has just written actually works or whether it has just burned everything to the ground. It answers with the same triumphant confidence whether it is right or has just produced a monumental piece of nonsense.

It is a genius working blindfolded — and either you remove the blindfold, or it stays there.

Ever since AI entered our everyday working lives, I keep hearing the same question:

“Which model do you use? What is the magic prompt?”

That is the wrong question.

And I say this after spending months making AI agents work on real-world tasks, not polished stage demos.

There is only one truly decisive trick: give the agent a way to check for itself whether it has done the job correctly.

Automated tests. Checks. A tool that can tell it, without ambiguity:

“This works.”

“You broke this.”

A closed feedback loop focused on correctness.

Not the perfect prompt. Not the model with the highest number of parameters. Not the latest release announced with fireworks and fanfare.

The difference between an agent that converges towards the right solution and one that keeps piling up errors with increasing confidence comes down to one thing:

Can it see the result of what it is doing, or is it working in the dark?

When it works in the dark, it produces confident garbage.

And it produces it faster than a human being — which is the dangerous part.

There is an Anthropic experiment that perfectly illustrates the point: an agent is placed inside a container, with no internet access, and asked to write a C compiler in Rust.

Among the things the agent “discovers” by itself in order to complete the task is precisely this: it needs to build a system that allows it to observe its own work and detect regressions.

Stop for a moment and think about that.

When the machine is given a genuinely difficult task, it reaches the same conclusion that every good engineer reached long before AI existed:

Without a way to measure correctness, you are going nowhere.

So why am I telling you this, when most of you are not writing compilers?

Because this principle is not limited to code.

It applies to anyone trying to integrate AI into their work.

AI without a way to check itself is a brilliant, incredibly fast collaborator with absolutely no critical awareness of its own output.

It will write your email, your analysis, your report, your strategy — using exactly the same confident tone whether it got everything right or said something completely ridiculous.

The real value, therefore, is not in “asking the right way.”

It lies in building the structure around AI that allows its mistakes to become visible: real data to compare against, clear criteria defining what “done well” actually means, and a point at which someone or something can say:

“No. This does not add up.”

Those who skip this step — and most people do, because it is the boring part — get exactly what they deserve:

Faster mistakes, not better results.

The market sells you the model.

It sells you the prompt.

It sells you the tool with the shiniest interface.

The truth is far more inconvenient and much harder to sell: serious work with AI happens inside the invisible infrastructure surrounding it.

Inside the feedback loop.

Inside the verification process.

Inside the discipline required not to trust an answer simply because it sounds confident.

If you are introducing artificial intelligence into your processes and focusing on which tool to use rather than on how its work will be checked, you are looking at the finger instead of the moon.

What about you?

Are you building a verification loop, or are you simply making mistakes faster?

Tell me in the comments.

Ho reso “cieca come una talpa” con “blind as a bat”, che è l’espressione idiomatica inglese più naturale e incisiva.