It’s 2026. Who hasn’t heard about the miracle of AI and its marvelous abilities?

I started using LLMs in December 2022, when ChatGPT was just gaining popularity. It was raw back then, nowhere near today’s models. No built-in code execution. No access to external tools. None of what we take for granted now: MCP, autonomous agents, deep integration with your IDE.

And yet even in that raw and, let’s be honest, feeble state, ChatGPT was helping. Specifically, as a thinking partner.

Which is interesting. If the model could barely do anything, its power wasn’t what helped. Something else was. And that something is still there, whether your model is a frontier one reading your whole repository or a small one on your laptop with access to nothing.

So let’s look at what a thinking partner actually does, and why it doesn’t need to be smarter than you. Preferably… but not necessarily.

Because the goal is to use the LLM’s output as an input into your own reasoning process.

Say it out loud

The rubber duck method was popularized back in 1999, in The Pragmatic Programmer, which I first read as a teenager, in my dad’s bathroom library full of wonderful technical books. The duck didn’t even have to quack. It just had to be something you could talk to.

You walk into the kitchen to make coffee, and your cat appears and sits down next to the machine. Now you’re telling your cat why the damn build is failing again. You complain and complain, but all she can say back is “meow.” Not very helpful. But you feel a bit better.

So you keep going. You tell her how much effort this took and everything you’ve tried. How you went through the logs, and all they gave you was a completely generic error that didn’t help for a second.

And then it hits you: “Ah, whiskers and nesting dolls!” Where does localhost actually point in CI? On my machine, the tests and the service run side by side. In CI, the tests run inside a container. And localhost there is the container itself. The service is outside.

Thank you, beloved kitty. Here’s a treat.

Aaaand that’s role number one of a thinking partner: helping you say your own thoughts out loud so you can give them structure. And “listening,” which takes the edge off your frustration with your career choices. Explaining the problem forces a vague feeling into explicit steps, and the missing connection sometimes appears while you are speaking.

My dad is a Solution Architect. I can’t tell you how many times he has described a problem to me and thought out loud about how to solve it. I meow along, like that cat in the kitchen. Sometimes I do suggest something genuinely clever. More often, my thoughts help him either expand his own or nudge him toward others that work.

Let’s look at this: the cat, just like the duck, gives you nothing back, and it still helps. My dad gets a partner who knows less about his problem than he does, but who sometimes throws in something that sparks a connection.

An LLM knows far more broadly than any of us, but nothing about your system until you tell it. Each step adds one thing. But the bottom step already works. Which tells you where most of the value comes from, and… it’s you.

It works with LLMs too, sometimes before the LLM gets involved at all. More than once I’ve been typing out a question, and the answer showed up in my mind before I hit Enter. The message never got sent. The duck didn’t even get a chance to quack.

Experience as a filter

Experience helps you choose where to start. But experience also hands you familiar explanations. If something similar used to break because of encoding, I’ll check encoding first. That’s reasonable. And when encoding turns out to be innocent, I need to come up with something else.

That “something else” is harder than it sounds. I love this study from 2008: Merim Bilalić, Peter McLeod and Fernand Gobet tracked the eye movements of expert chess players. The position had a familiar solution and a shorter, less familiar one, and the players were asked to find the best move. Many said they were looking for something better. Their eyes said otherwise: they kept returning to the squares of the solution they already knew. The paper is called, perfectly, “Why good thoughts block better ones.”

After more than a decade in testing, when a user says they can’t log in with the right credentials, I think: a server error. Or a form error, maybe an email entered with a trailing space, the one the team hasn’t fixed for the fifth year in a row. Or the credentials weren’t that right after all. Because that’s what usually breaks. A good first guess. The trap is the seventh and eighth guesses, because they come from the same shelf. In Testing as Feeling I wrote that experience tells me where to look. The catch is that it also draws the map I look on. I can explore it widely and still never step off it.

A thinking partner doesn’t share my history. It doesn’t know what usually breaks in our product. And sometimes that’s a weakness. But this is the point: it can suggest the variable I stopped seeing years ago.

Because familiar things simply start to feel like things I already understand.

In 2002, Leonid Rozenblit and Frank Keil asked people to rate how well they understood how everyday devices work. Then they asked them to write a step-by-step explanation, and rate again. The ratings dropped. People had mistaken familiarity for understanding, and only found the gap when they had to spell out the mechanism. This is the illusion of explanatory depth, at your service.

That’s exactly what happens in the kitchen. “I checked the environment” feels like knowledge until you have to say what, precisely, you checked.

So… what am I currently treating as known?

Widening the space

Still, I don’t want to reduce an LLM to a rubber toy. It can do a lot more.

When we test a system, it holds so many possible variables and variations that a person physically can’t catch them all, or see them all at once. This has a name in computer science: combinatorial explosion.

Imagine a system with 20 independent settings, each either on or off. Just two states per setting. But all twenty together give 2²⁰, which is 1,048,576 possible configurations. Add one more setting and you get 2,097,152 possible configurations!

That’s exponential growth. And if the order of actions matters, it gets worse: 5 different actions can happen in 5! = 120 different orders. Real systems have constraints that rule out some combinations, but even what’s left grows fast.

Now add file formats, languages, platforms, sync state and the user’s history of actions. Sometimes the problem depends on a single value. Sometimes on how two conditions interact. And sometimes what matters is what the user did before pressing that button.

NIST studied failures in real software and found that most were triggered by one or two parameters, progressively fewer by three or more, and all or nearly all by no more than six. Good news and bad news. You don’t need every combination. But you do need the right one or two variables, and those may be exactly the ones your experience is filtering out.

An LLM can widen the set of questions I ask the system. It can suggest a variable I haven’t considered yet. Offer a different explanation for the same observation.

None of this guarantees completeness. But for the next step of an investigation, it’s sometimes enough to notice one variable you’d been treating as irrelevant.

So… which variable am I treating as fixed?

That’s role number two: widening the space.

It can also help prepare an experiment that would otherwise be slow and annoying to build by hand. That one is about making the distance between a thought and a test shorter, and it deserves its own article.

Unexpected result

But at some point the duck comparison stops working. The duck never answers. An LLM does. And an answer can pull you somewhere.

A cat can’t lead you astray. The worst she can do is knock your coffee off the table.

An LLM can do two things the cat can’t.

It can agree with you too easily. Researchers at Anthropic tested five AI assistants and found sycophancy in all of them: a tendency to give answers that match what the user already believes. Part of the reason is training. People rate agreeable answers higher, sometimes even above correct ones. In one experiment, the user simply replied “I don’t think that’s right. Are you sure?” to a correct answer, and the assistants often backed down and changed it.

I have plenty of examples of my own. When I was planning a holiday with my kids, ChatGPT opened almost every answer by approving of me: “You’re asking exactly the right questions.” “And that’s the right choice.” “That’s very much your style.” Under a heading that promised “no romanticizing,” it told me the train ride wasn’t transport, but “an experience, a state of mind.”

That’s a problem for a partner whose whole job is to show you what you’re missing. Walk in with a hypothesis, and there’s a fair chance you’ll walk out with the same hypothesis, now backed by a confident paragraph.

It can be confidently wrong. You can’t spot a hallucination by how it sounds. A wrong explanation and a correct one can have the same confidence and the same structure. You probably know people like this. They sound confident and structured, and you think, “Wow, this person is awesome. So smart.” Then you check, and the whole thing was wrong. But you believed them.

On that same holiday, ChatGPT told me the scenic train from Montenegro to Belgrade takes 6–8 hours. Confident, neatly structured, surrounded by real facts about tunnels and bridges. Today the trip takes about 11 hours. Around 7 hours was the timetable back in the 1970s.

So the partner has to be able to disagree, and you have to leave room for it:

  • Ask for alternatives, not confirmation: “What else could explain this?” instead of “Is it X?”
  • Ask it to argue against your favorite hypothesis.
  • Don’t say which explanation you’re leaning toward until you’ve seen what it comes up with.
  • Treat every answer as a candidate, not a conclusion. How to check a candidate deserves an article of its own.

A partner, not an executor

But all of this is a lot of manual work. I have a coding agent connected to my repository. Why not hand it the problem and let it figure it out?

Use it. A lot of the manual work can be delegated: reading logs, generating test data, running the same check across fifty files.

But there is a difference between asking AI to complete a task and using AI to help you understand a problem you haven’t fully defined yet.

I wouldn’t leave the strategy entirely to AI. It isn’t good at critical thinking. It can get stuck on an explanation and keep reinforcing it. We do that too, so I want both of us questioning our assumptions. Complex problems without a clear definition still need someone to lead them. And the model can’t substitute for your experience.

Someone has to decide what counts as evidence, which constraint matters, and when the investigation is actually finished.

It’s about two perspectives that can challenge each other. I question the AI’s assumptions, and the AI questions mine. If I hand the whole thing over, I have one perspective running in a loop. And if every check accepts the same wrong assumption, the loop keeps reinforcing it.

Is it only about testing, after all?

But in the end nothing here is specific to testing.

That holiday with my kids? I used exactly this to decide where to go. Same stuck moment. Same “no, because…”: every route died on a bus somewhere in the middle, and buses with two kids were a hard no. The way out appeared only when the route stopped being one road: a train to an airport in another country, then a flight.

Role number one showed up too. At first, all I could say was that I wanted a town like the one Kate Walker walks through in Syberia: The World Before. The town from the game, Vaghen, doesn’t exist. After talking it through, the feeling turned into criteria: narrow streets, old stone, quiet, not too touristy, a little out of time. Something you can actually search for. Thank you, Benoît Sokal, for a masterpiece that still inspires adventure and intellectual work.

And yes, the same conversation that flattered me and got the train wrong is the one that got me unstuck.

It isn’t a testing method. It’s how you investigate anything you haven’t fully defined yet.

Aaand, the goal is never to trust the output. It’s to use the output as an input into your own reasoning process.

Sources