A while ago, I asked Codex to help me run code submitted by participants in an automated evaluation. Because the code was untrusted, Codex warned me that it should not be allowed to access the internet.

That sounded reasonable. I assumed it would run the submitted code inside a sandbox and block network access there. So when Codex asked for permission, I approved it.

Instead, it disabled the internet connection for my entire computer.

The submitted code still did not run. Worse, I could no longer connect to Codex to ask what had happened or to have it undo the change. I spent the next part of the day figuring out how to restore the connection myself.

What bothered me was not simply that an AI tool had made a mistake. In a literal sense, Codex had done something close to what it said it would do: remove network access. The problem was that the action I thought I had approved was not the action it understood itself to be taking.

I have started noticing the same pattern in much less absurd situations.

I use AI heavily in research. An idea can sometimes turn into an analysis, an implementation, and even a short paper over a weekend. During that process I may have dozens or hundreds of interactions with AI: trying alternatives, checking assumptions, fixing implementation details, discarding failed approaches, and updating my own view of the problem.

But before a paper is submitted, someone else may still need to understand and approve it. That can require long conversations about background, methods, implementation details, and why certain choices were made. The paper itself may be short. The context required to judge it responsibly is not.

This is not because the other person is slow. If we had accumulated the same context along the way, the conversation would be much easier. The problem is that AI can compress the path from idea to output without equally compressing the path by which another human reconstructs the context needed to understand that output.

I think this is becoming a distinct bottleneck in AI-assisted work.

When the output arrives before the understanding

In the past, producing complex work usually forced someone to move through much of the reasoning required to construct it. Writing code meant deciding how the pieces fit together. Running an analysis meant making a sequence of choices. Building an argument meant working through intermediate steps.

AI weakens that coupling.

Many intermediate steps can now be delegated, compressed, or traversed so quickly that the final artifact appears before the corresponding human understanding has fully formed.

Sometimes the understanding catches up later. Sometimes it remains partial. Sometimes the artifact is already being reviewed, approved, deployed, or built upon while the people responsible for the next step are still reconstructing what happened.

I call the resulting gap the understanding bottleneck:

The important phrase is well enough. Nobody needs to understand every detail of every system they use. What matters is whether a person has an understanding sufficient for the judgment or action they are responsible for.

More information is not necessarily more understanding

This is not simply information overload.

Information overload is a problem of quantity: there is too much to read, inspect, or remember. The understanding bottleneck can happen even when there is only one thing in front of us.

In my Codex example, the critical message was only a sentence or two. I had access to it. I had read it. I had approved it. What was missing was a sufficiently aligned picture of what the action actually meant.

The same can happen with more complex artifacts. A short proof may be easy to follow line by line while its central idea remains unclear. A piece of code may pass every test while the person maintaining it still lacks the understanding needed to change it safely.

The bottleneck is not just access to information. It is building enough of the right context to act reliably.

Correctness is not always enough

Better verification helps, but it does not remove the bottleneck.

A program can pass every test. A proof can be formally verified. An analysis can reproduce exactly. In many situations, that may be enough.

But when someone must review, modify, explain, approve, or take responsibility for an artifact, correctness alone may not provide the understanding required for that role.

A system can be correct enough to use and still poorly understood by the person responsible for what happens next.

Individual acceleration, collective delay

The problem becomes especially visible in collaborative work.

AI can make one person dramatically faster without making everyone around that person equally faster at understanding what has been done. The faster one person accumulates context through repeated interaction with AI, the larger the gap can become between that person and everyone else.

The researcher finishes the analysis faster, but approval becomes the slow step. The engineer generates more code, but review becomes the bottleneck. A team produces more experiments and documents while maintaining a shared picture of what has been done and why becomes increasingly difficult.