If AI is breaking the knowledge loop, how do we fix it?

In a previous article, I explored whether AI might be disrupting the feedback loop that turns individual problem-solving into shared knowledge.

If AI is shifting knowledge creation away from public spaces—like Stack Overflow, blogs, and forums—into private prompts and private chats, are we slowly depleting the very knowledge base that AI itself depends on to evolve, that humans depend on to evolve?

Assume for a moment that this is a real problem. What, if anything, can be done about it?

To be clear this is not an argument that “AI is bad,” or that people have suddenly become lazy. (Though I’ll admit to the occasional blind copy-paste of AI-generated code, followed by a hopeful run and a silent prayer.) AI is clearly useful. Productivity is rising. The tools are impressive.

The issue is more subtle. AI is changing where problem-solving happens — and in doing so, it may be weakening the mechanism that turns private effort into public knowledge. Historically, knowledge has grown through a reinforcing loop:

1. Humans solve problems
2. They leave traces of that work in public places
3. Others learn from, correct, or extend it
4. Repeat

My concern is that AI may be short-circuiting step 2.

Problems are still being solved—but the solutions increasingly disappear into private conversations with machines. The loop continues, but with thinner and thinner output over time.

Consider a common scenario from a few years ago:

A developer hits an unfamiliar error. They search for it, land on a Stack Overflow thread, read multiple answers, see disagreements, edge cases, and comments explaining why one solution works and another doesn’t. Even if they copy-paste, they absorb context along the way.

Now compare that to today:

The same developer pastes the error into an AI tool. They get a clean, confident answer. The problem is solved—but nothing is published, debated, corrected, or preserved. No future developer stumbles across that explanation. No collective understanding grows. Individually, this is efficient. Systemically, it’s a quiet loss.

This matters most for junior developers—and it’s something I care deeply about.

Junior growth has never come primarily from having answers. It comes from seeing how others think:

• Reading imperfect explanations
• Following comment threads and corrections
• Seeing multiple ways to approach the same problem

Public problem-solving spaces acted as an informal apprenticeship system. When solutions move into private AI interactions, juniors still get answers—but they lose exposure to the reasoning, trade-offs, and historical context that turn answers into understanding. If a junior developer can ship code faster but struggles to explain why it works, or to adapt it when conditions change, that’s not acceleration, that is not growth.

If we accept this diagnosis, the question is no longer whether AI is useful. It clearly is. The real question becomes how do we preserve the conversion of private problem-solving into shared knowledge in a world where AI mediates more and more of that work?

If we get this wrong, we won’t notice immediately. Productivity will rise. Tools will improve. Everything will appear to be working. The cost shows up later:

• Slower innovation
• Thinner public knowledge
• Fewer people who can explain why systems behave the way they do

When fewer people can explain why something works—only that “the AI suggested it”—we should treat that as a warning, not a convenience. If that feels abstract, ask yourself this:

How often has a recent AI-assisted solution resulted in something you could confidently teach to someone else?

So What Might Help?

If shared knowledge matters, we need to reward contribution, not just consumption. That means making contributions visible, valued, and worth effort again.

• Encourage teams to turn solved problems into short public write-ups or internal posts
• Design AI tools that prompt users to externalize explanations, not just accept answers
• Valuing understanding and mentorship as outcomes, not inefficiencies

This isn’t about rolling back AI adoption. It’s about ensuring the knowledge loop remains intact—especially for the next generation of developers.

This article was developed in collaboration with an AI system—not as an authority, but as a tool to stress-test and refine the ideas. The responsibility for the argument remains mine.