CODE IN TOKYO

“If We Open This Pull Request Now, Testing Will Grind to a Halt!”—The Moment I Had to Stop My AI

My First Stop Whenever I Run Into a Development Problem

Lately, whenever I run into a problem during development, my first move is to ask Fable 5.

It is good at code reviews and fast at drafting specifications. Honestly, when it comes to detailed work, I think it often outperforms humans.

So today, as usual, I asked it for help.

It worked through a possible fix, and eventually the conversation arrived at this conclusion:

“Everything is ready. Let’s open the pull request and send it to testing.”

I almost did exactly that.

But just before pressing the button, I stopped.

“Wait a minute. If we deploy this now, testing will grind to a halt.”

I found myself talking back to the screen.

The AI Already Knew We Were Waiting

This particular fix was not something I could complete on my own.

There was one part I could not change myself. I first had to ask the other party to fix it and wait for them to finish.

In fact, Fable 5 had written that request for me.

In other words, the AI knew that we were waiting for an external fix.

Even so, it then suggested that we open our pull request and hand the work over to the testers.

That would have been a serious mistake.

The Correct Code at the Wrong Time

Our code would work only after the other party completed its fix.

If we put our changes into the test environment first, they would obviously fail. The testers would start investigating without knowing the real cause. Questions would begin flying back and forth. Work across the team would stall.

I could picture the entire scene.

The correct sequence was clear:

This kind of coordination is nothing unusual in a real development environment.

It Understood the Dependency—but Not the Decision

What makes this interesting is that Fable 5 appeared to understand the process itself.

It could write the request. It could explain the dependency. It understood what we were waiting for.

Yet at the very end, it still said, “Let’s open the pull request.”

It understood the situation, but at the same time, it did not.

AI Can Follow Code Dependencies, but Not Always Workplace Dependencies

We often hear that AI is smarter than humans.

For detailed tasks, I think that can be true. The quality of its code, writing, and research can be genuinely impressive.

But this incident reminded me of an important limitation.

AI can trace dependencies in code, but it does not necessarily understand the dependencies that exist across a development team.

“This fix is finished.”

“But we should not release it yet.”

AI can be surprisingly bad at making that second judgment: the decision to wait.

The reason is simple. AI has never brought a test environment to a halt. It has never received a call from a tester asking, “What did you deploy? This was working yesterday.” It has never felt the knot in its stomach when an entire project loses half a day.

That is why an AI can make a logically sound suggestion that is still wrong in practice.

Ultimately, writing the right code and deciding whether now is the right time to release it are two different problems.

I learned something new from this experience. AI is unquestionably an excellent partner. But for now, the job of applying the brakes and saying, “We need to wait here,” still belongs to a human.