Think Like A Tester

A few days ago, I bought a book - The Thinking Machine by Stephen Witt - about Nvidia and its founder, Jensen Huang. Among the thousand anecdotes in the book (I am still halfway through), there is a fascinating one regarding Nvidia's survival in the nineties. The market was crowded with Silicon Valley companies fighting to dominate the PC gaming graphics segment. Today's strategy experts would call it a Red Ocean.

In a landscape littered with casualties, one of the defining clashes was between 3dfx and Nvidia. The two companies had diametrically opposite approaches to engineering. On one side stood 3dfx: highly refined programmers focused on sustainable hardware life cycles. On the other stood programmers forced into shortcuts by breakneck product cycles - creating software we’d likely call "slop" today.

In the end, as we know, Nvidia prevailed. But what is most interesting is that in the "Deathmatch" chapter, the author interviews the protagonists from both sides. A former 3dfx programmer, hired by Nvidia immediately after his company went bankrupt, recalls seeing Nvidia's source code for the first time and describing it as "a cancer." Yet, while acknowledging that

the time we spent keeping the code clean [at 3dfx], we went out of business,

his perspective today is profound. Even though Nvidia carried lethal technical debt, he notes:

Tech debts are the battle scars of the survivors.

Now, I don't want to say that Nvidia won because of its slop code. Nvidia won because when its very existence was at stake, it didn't stop to clean up. Taking shortcuts paid off, leaving behind a tech debt that was settled years later, with calm and resources. That's the lesson from the nineties.

But today, we are in a completely different position. We have AI agents writing code for us at speeds that were unthinkable even a few years ago. And yet, the dominant conversation in the software world is still the same: clean code, self-documenting logic, ultimate readability. But readable by whom?

If code is increasingly co-produced with machines, the criterion must shift. Not lower the bar - move it. Many argue that in this new era, we need to think like architects: define the structure and let the agents implement. I agree, up to a point. But I'd push the emphasis further: we need to think like testers. Architecture tells the agent what to build. Testing tells the agent how to know it works.

This means anticipating edge cases before they happen, building mocks that simulate real conditions, and defining precise criteria for success and failure. It means giving the agent a clear target. And this exercise - imagining everything that can go wrong before it goes wrong - is anything but trivial. It is structured thinking applied to code.

Recently, even Uncle Bob Martin - arguably the father of the clean code philosophy - wrote something pointing exactly in this direction:

Assemblers were faster than humans at writing binary, compilers were faster than humans at writing assembly, and now AIs are faster than humans at writing compiled languages. Deal with it. There's still plenty left for you to do.

I believe one of the most important things left to do is precisely this: not writing the code, but defining the conditions under which the code can be trusted.

So: stop being software aristocrats. Yes, coding is cheap and software is expensive. But that's exactly the point. If coding is cheap, stop obsessing over the syntax. Focus on the test strategies, define the boundaries, and let your favorite agent write the actual scripts. Let the AI write comments that provide context. Run experiments, verify in the field, and if the code doesn't hold up - throw it away and regenerate it. Today, making mistakes costs less. And it is far easier to verify if a rapid solution is wrong than to spend twelve months in workshops trying to design the perfect one.

That is all for today. Maybe too much.

P.S. Buy the book The Thinking Machine by Stephen Witt. It is very well written and incredibly interesting.

P.P.S. Originally written in Italian (I am more intelligent in my mother tongue), translated into English by an LLM. I claim every hyphen in this text as my own. I have always used hyphens in my writing and I will not change them now because they give an LLM-style feeling. A bit like comments in the code. :P