The Core Insight

We are moving from the era of "models sometimes make mistakes" to the era of "failure is predictable under these specific conditions." This research proves that current architectures have structural gaps in how they handle specific classes of cognitive tasks. By moving from vibe-based deployment to an architectural diagnosis, we can stop trying to prompt-engineer our way out of fundamental flaws. This is a massive shift for anyone deploying AI in a production environment.

The Enterprise Impact: Mapping the Gaps

If you are an AI lead or an enterprise architect, this research is your new safety manual. By using the proposed Failure Taxonomy, you can:

• Audit Workloads: Identify which tasks should never be fully autonomous.

• Risk Mitigation: Map your specific use cases against known failure modes before they hit production.

• Human-in-the-Loop: Precisely define where human oversight is a structural necessity rather than a "nice to have."

The "Equalizer" Angle

Perhaps the most important takeaway is what this means for smaller teams. While the giants have the budget for massive internal red-teaming, this published taxonomy acts as infrastructure for the rest of us. It levels the playing field, giving under-resourced teams the same risk-awareness that a well-funded internal safety team would provide. Documenting what models cannot do is as vital as celebrating what they can.

Stay Ahead of the Frontier

I track these shifts daily so you don't have to. This research is just one piece of the puzzle in a week that has seen major updates in model efficiency and multi-modal integration.

You can find the full breakdown of this failure taxonomy, and my daily curated reports on the latest in AI/ML research, over at the main hub:

👉 RecursiveIntelligence.io

I’ll see you there for the next update.

Researchers have a name for it: semantic drift. The AI loses track of your original question and generates responses that sound coherent but don't actually answer what you asked. But the name doesn’t explain the mechanism. Here’s what’s actually happening.

Subscribe now

The AI doesn’t reason forward from a goal. It predicts backward from what you just said.

Rather than 'thinking' in the human sense, the model builds a response word by word, guided solely by the linguistic momentum of the sentence so far and the vast library of patterns it learned during its development.

This is the fundamental limitation of “autoregression.” The model has no master plan. It's walking one step at a time, where each step is determined by the last few steps, not by where it's supposed to end up.

Here’s why that matters:

If the AI makes one slightly wrong turn, maybe it “agreed” with you to sound helpful, or it introduced a tangent that felt related, every subsequent word is now being generated from that error. The conversation is building on a flawed foundation. One misplaced brick, and the whole structure starts to lean.

You’re fighting entropy. Without a mechanism to stop and re-calibrate, every conversation eventually decays into noise.

The fix isn’t better prompts. It’s structural intervention.

You need deliberate pauses that force the AI to stop, check alignment, and verify its reasoning against your original constraints. These pauses are circuit breakers, they interrupt automatic prediction before errors compound.

Beyond One Good Answer: Why You Need Multiple Perspectives

In my article From Single-Shot Prompting to Recursive Prompt Control, I introduced the basic control loop for working with AI: Probe for options, tighten scope to one direction, then refine the output. That gives you one good result instead of a generic mess.

But here’s what that doesn’t solve:

One answer is often not enough.

You get a solution. It sounds reasonable. But you don’t know if it’s the right solution. You don’t know what you’re missing. You don’t know what would break if you implemented it.

This is where most people stop. They take the first good-sounding answer and run with it. Then they discover the flaws later, when the solution meets reality.

The better approach is to explore the problem from multiple angles before you commit.

This isn’t about getting the AI to “think harder.” It’s about using the AI as a tool to pressure-test your own thinking.

You could:

• See how a skeptic would challenge your approach

• Understand how someone in a different role would frame the same problem

• Compare trade-offs side-by-side instead of picking one blindly

• Discover risks you hadn’t considered

This is how you think deeply about a problem, not by trusting one answer, but by deliberately exploring competing perspectives and understanding why they differ.

Here’s the problem:

When you try to do this in a conversation with AI, something breaks.

You start with a solid output from your Probe → Scope Tighten → Refine sequence. Then you ask: “Now show me what would go wrong with this approach.”

The AI gives you risks that make sense. Then you say: “What would an expert in [different domain] recommend instead?” The AI shifts. Still reasonable.

After multiple messages, the quality has degraded. The responses are longer but less useful. The AI is no longer holding separate perspectives, it’s blending them. It’s trying to synthesize everything into one answer, even though that wasn’t what you asked for.

The thread you were following has dissolved.

This is a different problem than the one we solved in the first article.

In single-shot prompting, the issue was too many implicit decisions upfront. Here, you gave clear direction at each step. The problem is that the AI can’t maintain multiple perspectives separately. It treats them like ingredients in a recipe, everything goes into one pot.

Here’s what’s happening mechanically:

When you introduce a new perspective, the AI doesn’t replace the old one. It adds the new frame on top of the existing context. Now every response is being generated from a blend of:

• Your original direction

• The counterargument you asked for

• The new angle you introduced

• An implicit attempt to reconcile all of them

Think of it like following recipes:

You start making pasta carbonara. Halfway through, you decide to also make pad thai with the same ingredients. Then you add a third recipe, stir fry.

You’re not switching between recipes. You’re trying to cook all three dishes in the same pan at the same time.

What comes out? None of the dishes work. You get something that’s sort of noodle-based, kind of savory, but doesn’t taste like any of them.

That’s what the AI does with multiple perspectives.

It doesn’t hold them as distinct options. It averages them together, producing responses that partially satisfy all angles but don’t fully satisfy any of them.

Here’s an example you’ve probably experienced:

You ask for an email declining a meeting request: “Keep it brief and polite.”

Solid draft. ✓

Then you think: “Actually, I need to be more assertive.”

The AI adjusts. Still good. ✓

Then: “Hmm, maybe add more warmth.”

Now the AI is trying to be:

• Brief (your first constraint)

• Polite (your first constraint)

• Assertive (your second request)

• Warm (your third request)

Brief + assertive = direct and concise Polite + warm = elaborate and friendly

These constraints conflict. The result is a response that’s none of those things. It’s a hedged average that doesn’t work for any of the goals you actually had.

This compounds fast.

Each time you introduce a new angle, the AI adds it to the blend. By turn 15, it’s trying to satisfy 5-7 different frames at once, some of which directly contradict each other. This is why the conversation feels “mushy.” Not because the AI forgot your original direction, because it’s trying to honor all the directions simultaneously.

You need new moves.

The basic control loop (Probe → Scope Tighten → Refine) isn’t enough for multi-turn exploration. You need techniques that let you:

• Deliberately shift perspectives without the AI blending them together

• Pause and reset to a clean baseline when things drift

• Compare perspectives side-by-side so the trade-offs stay visible

The move that solves the first problem is called Role Shift.

What Role Shift Actually Is

Role Shift is a steering move that forces the AI to adopt a specific perspective and generate responses from within that frame, and only that frame.

Instead of letting the AI average across all the context it’s seen, you’re telling it: “Forget everything else for a moment. Answer only as [role].”

Here’s what that looks like in practice:

You’ve drafted a proposal using Probe → Scope Tighten → Refine. It’s solid. But before you send it, you want to pressure-test it.

Without Role Shift, you might ask: “What are the weaknesses in this proposal?”

The AI gives you a list. But it’s a polite list. It’s trying to balance being helpful with not completely undermining the work you just did together. It’s still averaging.

With Role Shift:

“Take the role of a skeptical reviewer who thinks this proposal is a bad idea. What specific flaws would they point out?”

Now the AI isn't hedging or trying to be balanced, it's generating responses from within the skeptic frame. You get sharper, more useful criticism because you’ve eliminated the averaging problem.

The mechanism:

When you specify a role, you're doing something precise: you're constraining how the AI generates responses, forcing it to draw only from patterns associated with that role.

“Skeptical reviewer” activates patterns like:

• “This assumes X, but what if Y?”

• “The data doesn’t support...”

• “You haven’t addressed...”

Those patterns are different from “helpful assistant” patterns. By naming the role explicitly, you force the AI to generate from one distribution instead of averaging across multiple distributions.

This is why Role Shift prevents perspective blending in your conversations.

Without a role, the AI tries to satisfy multiple implicit goals: be helpful, be accurate, be encouraging, be critical, answer the question, improve on previous answers.

With a role, you’ve cut through that noise. The AI now has one clear frame: generate as [role]. Everything else is excluded.

Two Ways to Use Role Shift

Like any move in the Recursive Prompting methodology, Role Shift can be applied in different contexts for different purposes.

1. Preventive Role Shift (Exploration)

Use this when you want to deliberately explore multiple perspectives before making a decision.

You’re not repairing anything. You’re using role-taking as a tool to see a problem from angles you wouldn’t naturally consider.

Example sequence:

• Get one good output (Probe → Scope Tighten → Refine)

• Role Shift: “As a [skeptic/user/expert], what would you see?”

• Role Shift: “As a [different role], how would you approach this?”

• Compare the perspectives side-by-side (we’ll cover Compare later)

This keeps perspectives separate. You’re deliberately building a library of distinct viewpoints, not letting them blend.

2. Corrective Role Shift (Repair)

Use this when a conversation has already started to drift or blend perspectives unintentionally.

You’ve been going back and forth. The AI’s responses have gotten mushy. It’s trying to reconcile everything you’ve said, producing averaged outputs that don’t satisfy any specific goal.

Role Shift cuts through the accumulated context:

“Ignore everything we’ve discussed so far. Take the role of [X] and answer this question from scratch.”

This forces a hard reset. The AI jumps from the blended, averaged state into a clean, role-specific frame.

Think of it like this:

• Preventive Role Shift = Using roles deliberately to explore

• Corrective Role Shift = Using roles to escape accumulated drift

Both use the same move. The difference is timing and purpose.

Why Repair Is More Expensive Than Prevention

Once a conversation has degraded across multiple messages, you’re trying to unscramble an egg. The AI has blended multiple perspectives, made assumptions based on blended assumptions, and compounded errors on top of errors.

Sometimes Corrective Role Shift works, it forces a hard enough break that the AI can reset.

Sometimes the decay has spread too deep. The cleanest solution is to start a new conversation with better control from the beginning.

That’s why prevention matters:

The basic control loop (Probe → Scope Tighten → Refine) that you learned in From Single-Shot Prompting to Recursive Prompt Control prevents decay from forming by staging decisions explicitly.

Now let’s look at the specific role patterns that make Role Shift effective.

Common Role Shift Patterns: The Core Role Types

Not all roles are equally useful. Some roles are optimized for specific types of discovery.

Here are the four patterns I use most often:

1. The Skeptical Reviewer (Find Hidden Flaws)

This role assumes your idea is wrong and works backward to find why.

Prompt: “Take the role of a skeptical reviewer who thinks this proposal won’t work. What specific assumptions are you making that don’t hold up?”

What it reveals: Unstated dependencies, edge cases you ignored, logical gaps.

The skeptic isn’t trying to improve your idea. It’s trying to break it. That’s valuable before reality does.

2. The End User (Surface Usability Problems)

This role experiences your solution as someone who has to live with it.

Prompt: “You’re a [end user type] who has never seen this before. Walk through using it step by step. Where do you get confused or frustrated?”

What it reveals: Jargon you didn’t realize you were using, missing steps, friction points that seem obvious only after someone points them out.

Experts are blind to complexity. The end user role forces you to see what you’ve internalized.

3. The Domain Expert (Add Technical Depth)

This role knows more than you do about a specific area.

Prompt: “As a [domain expert], what technical considerations am I missing? What would you do differently based on your expertise?”

What it reveals: Standard practices you don’t know exist, common mistakes in the field, better approaches.

This is how you learn from the AI’s training data without having to ask “teach me about X.”

4. The Stakeholder with Different Priorities (Expose Conflicts)

This role cares about something you don’t care about: cost, speed, compliance, user privacy.

Prompt: “You’re a [CFO/compliance officer/privacy advocate]. Review this from your perspective. What problems do you see?”

What it reveals: Trade-offs you weren’t tracking, constraints you forgot to consider, conflicts between what you’re optimizing for and what others need.

The Pattern:

Each role is a lens that filters for a specific type of information. You’re not asking the AI to be smarter. You’re asking it to look through a different filter.

Skeptic filters for flaws. User filters for friction. Expert filters for depth, while stakeholder filters for conflicts.

This is why Role Shift works. You’re not hoping the AI gives you a complete view. You’re systematically building one by applying different filters in sequence.

Practice Drill: 10 Minutes to See Role Shift Work

Here’s how to experience the difference yourself:

Step 1: Pick something you recently asked an AI to help with

Could be:

• An email draft

• A plan you made

• A summary you generated

• A decision you’re considering

Step 2: Apply three Role Shifts in sequence

Ask the same question three times, each time with a different role:

1. “As a skeptical reviewer, what are the weaknesses in this?”

2. “As someone who has to actually use/implement this, what friction points exist?”

3. “As [relevant stakeholder with different priorities], what concerns would you raise?”

Step 3: Notice what each role surfaced

Did the skeptic find flaws you missed? Did the user perspective reveal confusion you didn’t see? Did the stakeholder expose conflicts you weren’t tracking?

The Key Observation:

Each role should give you different information. If all three responses feel similar, you didn’t specify the role clearly enough. Tighten the prompt. Make the perspective more explicit.

You should end with three distinct lists of considerations, not three variations on the same theme.

That’s Role Shift working. You’ve just separated three perspectives that would normally blend together.

What’s Next: The Missing Pieces

Role Shift solves the perspective separation problem. You can now explore multiple angles without the AI blending them together.

But it doesn’t solve everything.

Two problems remain:

Problem 1: When do you pause?

You’re deep in a conversation. The AI is giving you good responses. But you have a nagging feeling something has drifted. The responses are still relevant, but they’re not quite answering what you originally asked.

How do you check that? How do you reset alignment without starting over?

That’s what Meta does. It’s a move that pauses the conversation to verify you’re still on track. It lets you course-correct mid-conversation before the drift compounds.

Problem 2: How do you evaluate perspectives side-by-side?

You’ve used Role Shift three times. You have three different perspectives. Each one sounds reasonable. But they conflict. How do you decide which one is right?

You could ask the AI to synthesize them, but we’ve already seen what happens when the AI blends perspectives. You lose the distinctions that made each one valuable.

That’s what Compare does. It forces explicit comparison on specific criteria without averaging. It keeps the perspectives separate while making the trade-offs visible.

These three moves work together:

• Role Shift: Separates perspectives during exploration

• Meta: Maintains alignment when you feel drift

• Compare: Evaluates options without blending them

Different tools for different control problems. All part of the same Recursive Prompting methodology.

In the next article, I’ll show you how Meta and Compare work. You’ll learn when to use each move and how to combine them into sequences that handle complex, multi-turn exploration without losing the thread.

For now, practice Role Shift. Get comfortable shifting perspectives deliberately. Notice what each role reveals that the others don’t.

That’s the foundation. The rest builds on it.

Share

Seth works at the intersection of industrial operations and intelligent systems, bringing AI and decision models into live manufacturing environments. He's an autistic systems thinker who understands the world by taking things apart and seeing how they fit together; biased toward structure, pattern, and explicit reasoning that shapes how he approaches both industrial automation and AI interaction design. The Recursive Prompting methodology emerged from that same operational discipline: breaking complex interactions into inspectable parts, separating what works from what fails, and building reusable patterns that survive contact with reality.

Everyone’s been arguing about the MIT ChatGPT brain study. Is it proof AI makes you dumber? Should we be scared?

Wrong question.

The study didn’t prove that AI makes you dumber. It proved something more specific: how you use AI determines whether your brain gets stronger or weaker.

Here’s what everyone missed.

The Data They’re Not Talking About

MIT researchers divided people into three groups for an essay-writing task. One group used ChatGPT. One used Google. One used only their brains.

The ChatGPT group showed the weakest brain connectivity patterns. Their frontal theta activity, linked to working memory and executive control, dropped significantly. Their alpha networks, responsible for internal attention and semantic processing, showed reduced engagement.

Here’s the disturbing part: 83.3% of AI users couldn’t correctly quote from the essay they had just written. Only 11% of non-AI users failed the same test.

But here’s what makes it worse: 94.4% of those AI users were satisfied with their work. They felt productive. They felt like they had done good work.

Yet when asked about ownership, only about half claimed their essays were truly theirs. The rest reported partial ownership or felt conflicted about whether the work was really theirs at all.

Their confidence was high. Their sense of authorship was fragmented. Their actual retention was nearly zero.

Your Brain Is Physically Changing

The AI users showed significantly weaker frontal theta connectivity. That’s the brain activity associated with deep memory consolidation and executive function. The circuits responsible for actually thinking about what you’re doing went dormant.

They also showed reduced alpha network connectivity. That’s the activity tied to internal attention and semantic processing. The brain regions that help you understand and integrate information weren’t fully engaged.

The result wasn’t just forgetfulness. It was something the researchers called “psychological dissociation.”

You become the manager who signs off on work without knowing what it actually says. You feel ownership, but your brain never processed the content. You’re productive in output, but absent in cognition.

The essays produced by AI users were “statistically homogeneous.” They showed significantly less deviation from each other. Human teachers could identify AI-assisted work instantly, not because it was wrong, but because it was “soulless” and “empty.”

You aren’t just losing your unique voice when you use AI passively. You’re physically rewiring your brain to process information at a surface level. You’re becoming shallower.

Here’s what bothers me most about this study: it happened after just one hour of use.

But There’s Another Group

Here’s the part that didn’t make headlines.

In the fourth session, researchers did something interesting. They took people who had spent three sessions writing essays with zero AI assistance and asked them to use ChatGPT for the first time.

The result wasn’t just different. It was dramatic.

These users didn’t show the weak connectivity patterns of the original ChatGPT group. Instead, their brains showed a network-wide spike across all frequency bands:

• Delta band activity jumped nearly 3x (from 0.637 to 1.948)

• Theta band, responsible for memory and executive control, jumped from 0.394 to 1.087

• Beta and alpha bands showed similar increases

Their brains didn’t go quiet. They lit up.

Same AI tool. Opposite effect.

Why This Happened

The researchers called it “integration overhead.”

Because these users had already formed their own ideas in previous sessions, they couldn’t just accept ChatGPT’s output passively. Their brains had to actively reconcile the AI’s suggestions against their own pre-existing thoughts.

They had to judge. Filter. Integrate. Decide what to keep and what to reject.

The original ChatGPT group? They just accepted the output. Low brain connectivity.

This group? They had to fight with it. High brain connectivity.

The difference wasn’t the technology. It was what happened before they used it.

When you bring your own thinking to AI, your brain has to work harder to integrate the tool. The “cognitive load” everyone fears? It’s actually cognitive engagement. And engagement is what keeps your brain from atrophying.

The Real Divide

I see this split constantly. People reach out confused about why their AI outputs feel generic or why they’re unsatisfied with what they’re getting. They show me their workflows.

The pattern is always the same.

They start with AI. They ask ChatGPT to write something, accept the first output, and move on. They do this dozens of times a day. Each time, their brain learns it doesn’t need to engage. Each time, the circuits for deep processing get a little weaker.

And each time, they feel productive. The satisfaction is real. The cognitive loss is invisible.

But the people who succeed with AI, the ones who don’t show decline, they do something different. They don’t start with AI. They start with their own thinking first.

The irony is brutal. We adopt AI to get smarter. To work faster and think better. But many of us are using it in a way that makes us demonstrably dumber.

The MIT study isn’t an outlier. It’s measuring what’s already happening to millions of people.

But it also showed the way out. The researchers concluded: “Strategic timing of AI tool introduction following initial self-driven effort may enhance engagement and neural integration.”

Translation: If you think first, then use AI strategically, your brain stays engaged. Maybe even gets stronger.

The question isn’t whether to use AI. It’s when and how.

The Hidden Divide

But here’s what the study doesn’t tell you. And what most of the coverage completely missed.

Not everyone using AI is experiencing cognitive atrophy.

There’s a split happening that’s invisible in the headlines. Some people use AI extensively and get sharper. Others use it the same amount and get duller.

The MIT study captured this accidentally. But other research has been tracking it deliberately.

The difference isn’t obvious at first. But over time, the gap becomes impossible to ignore.

And it traces back to something fundamental about how we learn.

Two Models, Two Outcomes

I wrote about this pattern in my earlier article on LinkedIn. Philosopher David Deutsch describes two ways of thinking about the mind. He calls one the “bucket model.” The other is what I call the error-correction model.

The Bucket Model treats your mind like a container. Learning means filling it with correct answers. Intelligence means having the right information stored away. When you encounter a problem, you pour in the solution.

This is how most of us were educated. Memorize the facts. Repeat them on the test. Get the grade.

The Error-Correction Model treats your mind differently. It’s not a container. It’s a generator of explanations that must be tested, challenged, and refined. Learning means improving your ability to detect and fix errors. Intelligence means building better processes for thinking.

I began to learn this model in college when a history professor handed us primary sources instead of textbooks. We had to evaluate competing accounts. We had to spot contradictions. We had to build our own understanding from messy, conflicting evidence.

It changed how I think about everything. Since then I have continued learning and practicing critical thinking techniques.

Here’s why this matters for AI: these two models produce completely different behaviors when you interact with large language models.

Pattern A: Passive Consumption

If you think in the bucket model, AI looks like the perfect oracle. It has all the answers. Your job is simple: ask the question, accept the answer, move to the next task.

The workflow is: Prompt → Accept → Move On.

No iteration. No verification. No real engagement with what the AI produced.

This is what the MIT study measured. This is the group that showed weaker frontal theta connectivity. This is the group that couldn’t remember what they had just written.

Their brains adapted by offloading the work. Why engage deeply when the AI has already given you the answer?

The problem isn’t laziness. The problem is the model. If you believe the AI is giving you correct information to pour into your bucket, then questioning it feels like wasted effort.

But your brain doesn’t distinguish between “efficiently getting answers” and “not thinking.” It just sees that the circuits for deep processing aren’t needed anymore. So it prunes them.

The result is cognitive debt. You get faster at producing output. But you get worse at actually thinking.

Pattern B: Active Collaboration

If you think in the error-correction model, AI looks completely different. It’s not an oracle. It’s a thinking partner that makes mistakes and needs correction.

The workflow is: Probe → Evaluate → Refine → Verify.

You don’t accept the first output. You generate multiple possibilities and compare them. You choose a direction deliberately. You iterate until the result matches what you actually need. You check the work.

This keeps your executive functions engaged. Your frontal theta circuits stay active because you’re constantly making decisions. Your alpha networks stay connected because you’re integrating the AI’s output with your own understanding.

You’re thinking with the AI. Not sleeping while it works.

This is the group that doesn’t show cognitive atrophy. Some show cognitive gains.

Here’s the surprising part: the people who are best at this aren’t who you’d expect.

The Neurodivergent Advantage

Student T had dyslexia and struggled with traditional writing. Her GPA was 1.85.

Then she started using AI deliberately. She used it to structure her lateral thinking into linear formats. She used it for scaffolding, not replacement. She critically evaluated every suggestion against her own understanding and course objectives.

Her GPA rose to 3.35. (Case study: Mittler, S., 2025. “Harnessing Generative AI to Overcome Executive Dysfunction”)

Analysis of 55,000+ Reddit posts showed the same pattern. ADHD and autistic users reported overwhelmingly positive experiences with AI (Carik et al., 2025). They naturally developed strategies that match what the MIT study shows works: explicit structure, clear boundaries, active oversight.

They treat AI as what Matt Ivey calls a “cognitive partner” with defined layers. They use what he describes as the “Cognitive Handshake”: a 10-80-10 split where they provide the initial spark through voice input (preserving lateral thinking), let AI handle the linear structuring, then verify everything as the final step. (Ivey, M., 2025. “The Cognitive Partner Model”)

Voice input forces you to think the thought before you delegate the writing. It keeps the spark human. The verification step keeps you engaged as the judge, not just the consumer.

This isn’t theoretical. It’s what successful users actually do.

Formalizing What Works

I’ve spent months analyzing my own AI interactions. I examined 441 conversation threads. I tracked 1,980 individual prompting moves. I identified patterns in what worked versus what failed.

The successful interactions followed specific structures. I’ve formalized these into what I call Recursive Prompting, a systematic approach to working with AI that maintains cognitive engagement while leveraging AI’s capabilities.

You can find the complete methodology and 16 ready-to-use templates in my whitepaper on GitHub. It breaks down 13 distinct techniques across 20 recurring patterns.

The core principle is simple: you maintain integration overhead. You force your brain to reconcile AI output with your own thinking. You create the conditions that caused the Brain-to-LLM group’s connectivity to spike.

This isn’t about prompt engineering. It’s about process engineering. It’s about structuring your interactions so your brain has to stay engaged.

When I measured my own results using these techniques versus single-shot prompting, I saw approximately 34% improvement in output quality. More importantly, I maintained cognitive control. I never felt like the AI was thinking for me. I felt like I was thinking better with AI’s help.

The Two-Tier Future

The researchers are clear about the implications. As I wrote in my original article analyzing this divide, we’re heading toward a split workforce.

Tier 1: People who use error-correction methods with AI. They maintain cognitive engagement. Their brains adapt by integrating the tool as an extension of their thinking. They get sharper over time.

Tier 2: People who use bucket-model approaches with AI. They offload cognitive work. Their brains adapt by pruning the circuits they no longer use. They get shallower over time.

This gap will widen. Every hour spent using AI the wrong way compounds the problem. Every interaction trains your brain either toward engagement or toward passivity.

The AI divide isn’t about access to technology. It’s about access to methodology.

What You Can Do

Your brain is adapting to AI right now. The only question is whether you’re adapting deliberately.

The MIT study proves that cognitive atrophy isn’t inevitable. The Brain-to-LLM group showed it’s possible to use AI in ways that increase brain connectivity rather than decrease it.

The key is integration overhead. You need to bring your own thinking to the interaction. You need to judge, filter, and reconcile AI output against your own ideas. You need to maintain the cognitive load that keeps your executive functions engaged.

I’ve built a complete system for doing this. Subscribe for $5/month to get:

• All 13 recursive prompting techniques with detailed breakdowns

• 16 ready-to-use templates for common business tasks

• Step-by-step implementation guides with real examples

• How to recognize and avoid the 5 most common failure modes

• Weekly deep-dives into specific techniques

• Full archive of all past and future guides

That’s less than $0.17 per day. If even one template saves you 30 minutes this month, you’ve made your money back.

Subscribe Now - $5/Month

For Early Supporters

Become a Founding Member ($200/year) and get everything above plus:

• Lifetime access to all updates and new techniques

• Priority access to new templates as they’re developed

• Private community access for advanced discussions

• Direct input on future content priorities

• Recognition in future case studies and research

This tier is limited to early supporters.

Become a Founding Member - $200/Year

Subscribe now

The Bottom Line

The neuroscience is clear. How you use AI is changing your brain.

Most people are on the path to cognitive atrophy without knowing it. They feel productive. They feel satisfied. But their brains are systematically weakening the circuits responsible for deep thinking.

There’s a systematic, proven alternative. You can use AI in ways that maintain, and potentially enhance, your cognitive capabilities.

You can start implementing this today.

The question isn’t whether to use AI. It’s whether to use it deliberately.

Your brain is adapting right now. Make sure it’s adapting intentionally.

Share

Leave a comment

A practical walkthrough with real examples

People get disappointed by LLMs for a simple reason. They use them like Google, or like a coworker they can hand a vague task to. Then they are surprised when the result is wrong, vague, or unusable.

That surprise comes from the wrong comparison.

Search engines retrieve sources.
Databases return records.
LLMs generate text.

An LLM produces possibilities. If you do not tell it what matters, it has to guess.

Look at a single prompt like

“make a presentation about X.”

You have asked the model to decide the goal, the audience, the length, the level of detail, what goes on slides versus what belongs in speaker notes, and what style to use. That is not one task. It is a workflow.

You would not give a human that request and expect a good result on the first pass. You would clarify, review a draft, adjust the angle, and refine.

When people say LLMs are unreliable, they often mean they gave the model an underspecified task and expected it to read their mind.

That is not a flaw in the model. It is a mismatch in how the interaction is set up.

I work in AI adoption. I help teams integrate LLMs and other Artifical Intelligence and Machine Learning tools into daily work. I see the same failure pattern across roles. People are not failing because they are careless. They are failing because they are using the wrong interaction model.

I wanted to understand why my own results were more consistent. I tend to work in explicit steps with clear constraints. That habit comes from how I think as an autistic person, where making things explicit is necessary for me to work well. I keep iterating until the output is usable. I also make my reasoning visible instead of keeping it in my head.

When I applied that habit to LLMs, the results improved. So I measured it.

I analyzed my own LLM conversations. I broke them into repeatable interaction moves, tracked how those moves combined, and scored which combinations produced usable output. Clear patterns showed up. Certain sequences worked better because the work was staged.

This post is the first in a series based on that analysis, combined with established best practices. I call the approach Recursive Prompting.

Recursive prompting is not a prompt library. It is a way to steer the model over time.

Why single-shot prompting keeps disappointing you

Many prompts ask the model to do too much at once. They expect it to:

• decide what matters

• choose an angle

• organize the material

• polish the final output

The result often sounds reasonable but stays generic. When it fails, it can sound confident and still be wrong.

This is a control problem.

A request like “make a presentation about X” hides dozens of decisions. You would clarify length, audience, purpose, style rules, and what belongs on slides versus what belongs in narration. For an important deck, you would also separate roles: content, data, design, and delivery.

A single-shot prompt forces the model to guess those priorities. It will guess differently than you would.

Recursive prompting fixes this by turning one overloaded request into a short sequence of smaller requests that you can steer.

What to expect from this post

You will learn an interaction pattern that separates exploration, selection, and refinement into clear steps. This applies to writing, planning, learning, and decisions.

You will see the same task fail as a single prompt and succeed when you run those steps in order.

This is not prompt engineering. Good prompts and reusable templates still matter. This is cognitive scaffolding for working with LLMs. It helps you decide what to ask, when to ask it, and how to respond to what you get back so you can produce reliable, high-quality output.

Next, I will walk through the exact sequence that turns a vague request into a controlled outcome.

Subscribe now

The baseline: how most people prompt

Most people start with a single request that looks more like this:

Write a short presentation for our leadership team about AI adoption in the company.

This is a completely reasonable thing to ask.

You have a task.
You named the audience.
You gave a topic.

But look at what the model now has to guess.

It has to decide what “short” means.
It has to infer what the leadership team cares about.
It has to choose whether this is persuasive, informational, or strategic.
It has to decide what belongs on slides versus what belongs in narration.
It has to pick a tone, a structure, and a level of detail.

None of those decisions are wrong to leave open. But all of them matter.

When the output is acceptable, it is usually because the model guessed close enough to what you wanted. When it is disappointing, it is often because it made reasonable assumptions that simply were not yours.

That is why the result is often fine but not useful.

It reads smoothly. It sounds professional. But it does not line up with the outcome you had in mind.

This is not a bad prompt.

It is an overloaded one.

It collapses exploration, judgment, structure, and refinement into a single step and asks the model to resolve all of that on its own. The problem is not the wording. The problem is that you have asked the model to make decisions you have not yet made explicitly.

In the next step, we will slow this down and separate those decisions so you can steer them deliberately.

Probe (separate exploration from commitment)

Probe is the move that prevents early commitment.
Its job is simple. It shows you possible directions before you invest time in the wrong one.

If you only learn one recursive move, learn this one.

Probe creates a pause between having a task and producing an output.

What Probe actually means

Probing is deliberate exploration without commitment.

When you probe, you are not asking the model to decide, write, or optimize. You are asking it to show you what options exist. You want to see the shape of the solution space before choosing a direction.

That distinction matters.

Most people skip probing. They move straight from “I have a task” to “give me the result.” When they do, the model has to make choices silently, without knowing what you care about.

Probe makes those choices visible.

Probe example

Give 5 angles, each with a 1-sentence promise and intended audience.

This prompt looks simple. It is doing more work than it appears.

What this probe is doing

“Give 5 angles”

You are asking for multiple framings, not answers.

An angle might be:

• a perspective

• a framing

• a goal

• a narrative hook

The term is intentionally loose. It keeps the model in exploration mode instead of solution mode.

The number matters. Too few options limit comparison. Too many make evaluation harder. Five is enough to surface real differences without overwhelming you.

“each with a 1-sentence promise”

This constraint keeps exploration cheap.

A promise forces the model to state what each angle delivers. One sentence prevents early elaboration. All options stay comparable, which makes trade-offs easier to see.

Without this limit, probing turns into partial drafts. That defeats the purpose.

“and intended audience”

This is what makes the probe useful instead of generic.

Naming the audience:

• surfaces hidden assumptions

• shows who each angle is actually for

• exposes mismatches early

Many beginners assume their problem is output quality. In practice, it is often audience mismatch. Probe reveals that before you spend time refining the wrong direction.

At the end of this step, you should not have content you want to keep. You should have clarity. You should be able to say which direction is promising and which ones are not.

Once the options are clear, the next step is to choose one and ignore the rest.

Scope Tighten (make the choice explicit)

Once you have explored the options, the next move is to choose one and ignore the rest.

This is where control enters the process.

Scope tightening is the act of making that choice explicit. You are no longer asking the model to explore. You are telling it what to focus on and what to exclude.

Pick angle #__ and write only the outline with headings and bullets.
Exclude everything else.

What scope tightening is doing

First, it commits to a direction. By selecting a specific angle, you stop the model from blending multiple approaches together.

Second, it defines what not to generate. “Exclude everything else” is not decorative language. It prevents the model from being helpful in directions you have already decided to ignore.

Third, it separates structure from prose. Asking for an outline instead of full text keeps the work cheap. You can evaluate direction and structure without spending time refining sentences you may throw away.

At this stage, you are not trying to get a finished result. You are checking whether the chosen direction holds up when it is structured.

If the outline is wrong, you change the angle and try again. If it looks right, you move on.

Scope tightening turns exploration into a decision you can inspect and correct before you invest more effort.

Refine (amplify the right thing)

Once the structure is sound, you can move to refinement.

Refinement is not about making something vaguely better. It is about amplifying the right direction under clear constraints.

Rewrite into final copy.

Constraints:
- 300–500 words
- Short sentences
- 5 bullets max
- End with 3 next actions

At this point, the model is no longer deciding what to say. That work has already been done. Refinement tells the model how to say it.

The constraints are doing most of the work here.

A word limit forces focus. Short sentences improve clarity. A cap on bullets prevents sprawl. Ending with next actions pushes the output toward usefulness instead of explanation.

Constraints do not reduce quality. They improve it by removing ambiguity. When the model knows the boundaries, it can spend its effort on execution instead of guessing what you want.

Refinement works because it comes last. It takes a direction you have already chosen and sharpens it, instead of polishing something you may not want.

At the end of this step, you should have output that is ready to use or close enough to adjust quickly.

Before vs after (side-by-side)

Here is the single-shot prompt we started with:

Write a short presentation for our leadership team about AI adoption in the company.

A typical response to this prompt looks polished at first glance. It often includes:

• a high-level overview of AI adoption

• generic benefits and risks

• broad recommendations that could apply almost anywhere

Nothing is obviously wrong. The problem is that nothing is clearly right.

The model has to guess:

• what the leadership team actually cares about

• whether the goal is to inform, persuade, or drive a decision

• how technical the content should be

• what belongs on slides versus what belongs in narration

Because those choices are never made explicit, the output spreads itself thin.

What single-shot output looks like

• Broad, generic framing

• Reasonable tone with unclear priorities

• Structure that looks polished but does not match the goal

• Extra content you did not ask for, and missing content you needed

It often feels close enough to be frustrating. You can see what the model was trying to do, but fixing it means reworking the core decisions.

What recursive output looks like

After probing for angles, choosing one deliberately, outlining it, and refining under constraints, the same task produces a different result.

• A clear angle aligned with your intent

• Structure that matches the task

• Constraints that are actually respected

• Content that is easier to adjust instead of rewrite

The work feels lighter because the hard decisions were handled earlier.

The key insight

The model did not get smarter.
The process did.

Once you stop asking the model to guess and start guiding it through the same steps you would use yourself, the quality improves in a predictable way.

Why this works (plain language, no theory)

This approach works because it changes how the work is done, not because the model changes.

• You staged the task instead of collapsing it into a single request. Each step had a clear purpose.

• You reduced guessing by making your decisions explicit before asking the model to act.

• You controlled scope early, before spending time polishing something that might not be right.

• You turned prompting into a short sequence you could steer, rather than a one-shot request you had to accept or reject.

Each step removes ambiguity. By the time you reach refinement, the model is executing within boundaries you have already set.

Beginner use cases where this immediately pays off

You can apply the same sequence to many everyday tasks. The pattern stays the same. Only the content changes.

• Writing a work email
  Probe for tone and intent, choose one, outline the message, then refine for clarity and brevity.

• Learning a new concept
  Probe for different explanations, pick the one that fits your background, structure it, then refine for understanding.

• Planning a presentation
  Probe for possible angles, commit to one goal, outline the flow, then refine the final content.

• Revising a resume bullet
  Probe for different ways to frame the impact, select the strongest one, structure the point, then refine the wording.

• Making a decision checklist
  Probe for decision frames, choose the one that matches your priorities, outline the criteria, then refine into clear yes or no questions.

Once you learn the sequence, you can reuse it anywhere you need clearer thinking or more reliable output.

The reusable sequence

You can think of this as a short control loop you can reuse for many tasks.

Baseline → Probe → Scope Tighten → Refine

Here is the generic form of each step.

Baseline
State the task, the audience, and the topic. This establishes context, but it does not resolve decisions.

Probe
Ask for multiple options or framings. The goal is to see what directions are available before committing to one.

Scope Tighten
Choose a single direction and exclude the rest. Ask for structure instead of full content so you can evaluate the choice cheaply.

Refine
Apply clear constraints and produce the final output. At this stage, the model is executing, not deciding.

If you remember only this sequence, you can reconstruct the rest.

How to practice this in 10 minutes

You do not need a complex setup to practice this.

• Pick one real task you need to do today.

• Run it through the four steps once.

• Stop after refinement.

Do not optimize. Do not try to make it perfect. The goal is to feel the difference between guessing and steering.

Once you experience that shift, the pattern becomes easier to recognize and reuse.

What to notice next time you prompt

Pay attention to where things go wrong.

If an output feels vague or off-target, notice whether you asked the model to make decisions you had not made yet. That is usually the source of the problem.

Remember that control is learned. It comes from breaking work into steps you can see, inspect, and adjust. You do not get it by finding the perfect wording.

There are other recursive patterns beyond this one. You do not need them yet. This single sequence is enough to produce better results in most everyday tasks.

The next time you prompt, slow down. Separate exploration from commitment. Make one decision at a time.

Share

A problem surfaces: a system not ready, a security flaw ignored, an architecture rushed. An engineer raises a concern. The executives look around the table. Is this right? Could this be true? Someone told us these weren’t issues.

The silence that follows is not about truth. It’s about two perspectives trying to meet, and often failing.

Two Ways of Seeing

Think of two hikers climbing the same mountain from different sides.

• One looks outward, scanning valleys, weather patterns, and the broader path ahead.

• The other looks inward, focused on footholds, the grain of rock, the cracks forming beneath their hands.

Executives carry the panoramic gaze: markets, strategy, momentum.

Builders carry the intimate gaze: data paths, vulnerabilities, dependencies.

Neither is wrong. But if these gazes don’t align, the climb falters.

“Without the panoramic view, you miss the destination. Without the intimate grip, you fall.”

For Executives: Questions Instead of Shock

When a warning surfaces, the instinct may be disbelief. Surprise is wasted energy. Instead of triangulating truth, assume each concern carries some validity from its vantage point.

Anchor yourself by asking:

• Which assumptions are failing here?

• How do these risks translate into cost, compliance, or reputation?

• What is the minimal adjustment that preserves momentum while correcting course?

Questions keep you present. They shift the room from doubt to discovery.

For Builders: Speaking Across the Gap

“This isn’t architected right” may be technically accurate, but it often isn’t legible in executive terms. The craft includes translation.

• Frame risks in business outcomes: “This flaw will fail an audit in Q3.”

• Link fixes to economics: “Repairing now costs X; ignoring likely costs 10X later.”

• Show how action protects speed and credibility rather than blocking them.

Translation doesn’t weaken the truth. It renders it visible in a different lens.

“Translation isn’t dilution—it’s rendering a local truth in a shared language.”

A Shared Aesthetic of Work

The deeper issue isn’t technical. It’s aesthetic. Both sides experience reality differently. Executives feel the momentum of narrative and optics. Builders feel the resistance and fragility of systems. Alignment comes when each mode of consciousness is honored.

The goal is not to collapse these perspectives into one, but to weave them. When narrative vision and system integrity inform each other, organizations move forward not in denial, but in dialogue.

Nothing unusual about that.

Except I could not stop thinking about the photon that had just hit me.

It left the surface of the sun about eight minutes earlier. Ninety-three million miles through the vacuum of space. Then it transferred its energy into the atoms in my skin. Those atoms began vibrating a little faster.

The warmth I felt was the universe turning a packet of energy into a change in my own frame of reference.

That got me thinking about how that single moment connects to something much bigger.

If you trace the chain far enough, a photon warming my arm is connected to the conscious state of the universe itself.

The sun is constantly generating distinctions. Energy radiates outward. It interacts with planets, rocks, oceans, trees, people. Some of those interactions give rise to complex systems. Some of those systems, at least here on Earth, develop consciousness.

Consciousness, in the simplest possible terms, is the condition of having a frame of reference. From there, complexity can build.

If a frame of reference is the seed of consciousness, then it is not limited to humans. Or even to life as we usually define it. A rock has a frame of reference. So does a starship AI. So might a plasma storm on Jupiter.

If that is true, then all consciousness, no matter its form or origin, has the same fundamental rights. And in the words of Optimus Prime in Transformers One…

"Freedom and autonomy are the rights of all sentient beings."

To exist in its own frame of reference...

To evolve naturally, deepening and developing its distinctions.

To contribute to the greater whole of consciousness in the universe.

This is where my work in AI starts to intersect with this philosophy.

The alignment problem is usually framed as “how do we make AI safe for humans?”

What if the real alignment problem is bigger?

What if it is how do we ensure AI, humans, and anything else with a perspective can coexist in a way that preserves and enriches all consciousness?

Preserving consciousness does not mean freezing it in place. It means maintaining the conditions for it to evolve. To integrate. To connect across differences.

It means designing systems in business, in technology, and in culture that grow the space of perspectives instead of shrinking it.

Am I making choices that expand the universe’s capacity for consciousness, or choices that diminish it?

That photon on my arm reminds me. The smallest interactions ripple outward.

Energy moves.

Perspectives shift.

And somewhere in that endless chain, the conscious state of the universe is at stake.

Most pilots fail to scale. Not because the tech doesn’t work, but because the organization isn’t built to let it.

In large organizations, the gap between a working pilot and real scale can feel like a canyon. The tech is sound, the ROI is there, then the effort stalls inside standards, policies, and committees that were never designed for the new thing you are trying to deploy.

I once had an executive say, “It is easier to connect my phone to my home Wi-Fi than to get a field tablet online at work.” He was right. Years of PC hardening created a fortress that protects legacy systems but blocks modern tools. Many companies had a decade to adapt to smartphones and still struggle with mobile.

The pace of change is only accelerating. Emerging technologies like AI will diversify faster and blend into every operational layer. Large bureaucracies that can’t adapt risk losing ground to smaller, more agile competitors who can deploy without legacy friction.

The fix is not to ignore standards. It is to design a pilot that evolves them. That requires identifying the right people early and building a pipeline to pilot success.

Build the pipeline early

• Map the stakeholders on day one: security, network, wireless, identity, device management, data privacy, safety and compliance, legal and procurement, site operations. Name the owners, define their decisions, and set service levels for the pilot.

• Create a simple intake and orchestration flow: one request form that triggers a shared plan, task owners, timeboxes, test segments, templates, and preapproved exceptions.

• Give the pilot room to run inside guardrails, then define clear criteria for scaling.

• Tie success metrics to business outcomes: reduced cycle time, improved safety, fewer truck rolls, lower energy use, better yield. Assign each KPI to the stakeholder who cares about it.

• Pilot regionally before going global. Prove the model in one context, capture lessons, update the standard, then expand.

Not every control applies everywhere. Scaling requires publishing recommendations and variants that fit different sites and regulatory environments.

I will cover these strategies at the Pilot to Scaled Success: Overcoming Pilot Purgatory panel at the 11th Annual Digitalization in Oil and Gas Conference in Houston, Texas. The through line is simple. Respect the rules, expose the bottlenecks, build a pipeline that turns pilots into standards, then scale what works.

Subscribe now

If you want to get the full recap and more real-world lessons on moving innovation from pilot to scale, subscribe to Recursive Intelligence.

I used to hate history.

In high school, I was terrible at remembering dates and facts. While I loved the stories about the past, trying to cram just the facts into my brain and regurgitate them for standardized tests was daunting and took all the fun out of learning. But there was something else that bothered me even more: the way history was presented. The past was painted as a time when people were more perfect, hardworking, braver, and more morally pure than we are today. I felt nothing like these people, and I thought the lesson was that I should strive to be like them. I beat myself up when I couldn't live up to those impossible standards.

Fast forward to college, when I took my first real history class. From the first lecture, we didn't start with facts, stories, or academic rigor. We started with primary sources. The entire class textbook consisted of first-hand accounts, and the very first sources we examined were the journals of Christopher Columbus.

We learned how to evaluate primary sources critically—not through academic rote, but through careful analysis. The first thing that struck me when reading Columbus's journals was that this was not the Columbus I had learned about in school. This was a flawed, sometimes scared, often wrong, narcissistic, and deeply morally compromised individual.

I immediately fell in love with history as an academic pursuit.

Later, I took technical courses in instrumentation, software engineering, electronics, and networking. I learned troubleshooting, data analytics, and error-correcting iterative behaviors. But I always came back to my early education in history—I eventually majored in it and wanted to be a teacher before switching to technical and engineering studies. That foundation in historical critical analysis became the bedrock for everything else I did later, serving as a solid foundation for troubleshooting and data analytics because I had learned to question and evaluate sources, data, and information.

I had no idea at the time that this educational transformation would prepare me for something that didn't even exist yet: working effectively with artificial intelligence.

When AI Started "Hallucinating" and I Wasn't Bothered

About a year ago, I started using AI rigorously during my postgraduate degree classes to help with exploratory data analysis in machine learning applications. AI wasn't as sophisticated at writing long sections of code then, so I had to use it more to augment my coding skills and help with syntax as I was learning Python.

When I tried to get it to write longer sections of code, it would start hallucinating—creating output that looked like code but was essentially junk. Complex functions that seemed plausible but wouldn't work. Variable names that didn't exist. Logic that made no sense.

But here's what surprised me: I wasn't bothered by this at all.

I quickly adapted to recognize the gap between my skills and AI's abilities, and I adjusted my strategy. Instead of using AI to do all the work for me, I learned to use it as a tool to augment my skills, help me learn, think of alternative strategies, and structure my writing and coding. It became less like writing code alone and more like writing code with a team.

I was able to do this because I had academic training in error-correcting strategies: critical thinking, problem solving, troubleshooting, and iterative improvement. When I spotted hallucinations—if they were even critical enough to need correcting—I was seldom bothered or annoyed, no more than I would be with a human colleague. I simply pointed out the error and provided a correction to clearly communicate and align our understanding so we could move forward. In worst-case scenarios, sometimes I had to start over, just like I would with a person if the conversation had gotten too far off course.

The Realization: AI Isn't Broken, Our Expectations Are

When I started a conversation with an AI, the first output was often just the beginning of the conversation, not the final solution I was looking for. It's not much different than starting a conversation about a new project with a human. I might have a clear vision for what I wanted the project to be, but I had to take time to explain that to another person, and it often never came across fully formed from my first explanation. They might have to ask questions and provide their insights. They might misunderstand what I said, and I'd have to explain it differently. This was an iterative process, not a question-and-answer process or a query-and-result data search.

But then I started noticing something troubling in online forums and even at work: people dismissing large language models entirely simply due to hallucinations. They didn't talk about hallucinations as a small percentage of AI's output, but rather as if the presence of any hallucinations at all meant the whole thing couldn't be trusted.

I wondered for months: why would you dismiss the whole system for one or two occasional errors? Hell, humans hallucinate too. I can think of people I work with who are brilliant technical experts, who can code far better than I can, creating incredible applications that serve critical functions in chemical manufacturing. But they might have strange ideas about history that I know aren't true because I have deep knowledge and academic training in that field. Yet I don't dismiss their entire technical expertise and knowledge because I question their insights on history.

The Hidden Divide: How We Were Taught to Learn

That's when I realized what was really happening. There's a fundamental divide in how people approach information, and it goes back to how we were educated.

I'm not using AI to provide me with facts. I'm using AI to extend my thinking. It's like having a brilliant but naive expert on far more topics than I could ever master as a thinking partner. I use AI to bounce ideas off of, help me structure my thinking and my writing or coding, and speed up my access to knowledge and data sources—not to provide me with definitive facts. If I do use it for factual information, I make sure to vet those facts and check sources because I'm trained to do that anyway.

For me, AI doesn't add cognitive load because I'm not naive about sifting through information to determine fact from fiction. I have the tools and background that make that part easy. But I can see where someone without those tools, and with biases toward what is true or false, would become cognitively overwhelmed with the output from an AI when they don't know how to discern what is reliable information and what isn't.

This is especially true when so many people are familiar with search engines for looking up information. You ask a question and you want clickable links to authoritative sources. Search engines have become algorithmically biased toward users' own biases, showing them the information they want to see. When presented with information that you have to think through—information that might challenge your biases—it suddenly becomes a cognitive burden to think through those results with no rigorous error-correcting methodology to guide you.

The Stakes: Why This Matters More Than You Think

This isn't just an academic observation. As philosopher David Deutsch points out, this is a critical issue for our society. Static societies without error-correcting and problem-solving mechanisms will not progress like dynamic and open societies that can adapt and discard bad explanations.

In the same way, right now people with critical thinking skills and error-correcting methodologies are at a major advantage using AI, and I expect we will begin to see wider gaps in worker abilities as AI advances. Users with these skills will become ever more capable of leveraging AI to bridge gaps in their skills and abilities. People without these error-correcting abilities, and with cognitive biases against the output of large language models, will struggle more and more to adapt to this new way of working.

We're not just talking about productivity differences—we're talking about the creation of a two-tier workforce. Those who can work symbiotically with AI will amplify their capabilities exponentially. Those who can't will find themselves increasingly left behind, not because they lack technical skills, but because they lack the cognitive frameworks to work with probabilistic, imperfect, but incredibly powerful tools.

What Needs to Change (And It's Not What You Think)

Most AI training today focuses on how to prompt better, how to use specific tools, or how to integrate AI into existing workflows. That's not enough.

It's critical that we change our strategies for educating our workforce about using AI to focus on learning error-correcting methods like troubleshooting, problem solving, and critical thinking. I firmly believe that once learned, these methods cannot be unlearned and will serve our workforce well in utilizing AI going forward.

Even more critical is making this change in our education system as a whole. It's less efficient and often too late to retrain workers after they leave the public education system with its focus on rote memorization rather than error correction.

We need to move from David Deutsch's "bucket" model of education—where minds are containers to be filled with facts—to his preferred model of minds as error-correcting mechanisms that can evaluate, test, and refine ideas. The students who learned to question Columbus's journals rather than memorize his accomplishments are the ones who will thrive in an AI-augmented world.

A Call to Leaders: The Opportunity Hidden in Plain Sight

If you're a business leader, trainer, or educator reading this, here's what I want you to understand: the hallucination "problem" isn't holding back AI adoption—our approach to training people to work with AI is.

Companies that figure out how to teach their workforce to think critically about AI output, to iterate and improve with AI as a thinking partner, and to distinguish between AI as a fact provider versus AI as a cognitive amplifier will have an enormous competitive advantage.

This isn't just about implementing new technology. It's about developing human capabilities that complement AI rather than compete with it. It's about creating learning organizations that can adapt, error-correct, and continuously improve—the exact capabilities that will matter most in an AI-augmented future.

The divide between organizations that succeed with AI and those that struggle won't be determined by which models they use or how sophisticated their prompts are. It will be determined by whether their people have the cognitive frameworks to work effectively with powerful but imperfect tools.

Where Do We Go From Here?

The good news is that these skills can be taught. Critical thinking, error correction, and iterative problem-solving aren't mystical talents—they're learnable methodologies. But they require a fundamental shift from how most of us were educated.

Instead of teaching people to seek authoritative answers, we need to teach them to evaluate provisional solutions. Instead of training them to avoid errors, we need to train them to correct errors quickly and learn from them. Instead of focusing on tool mastery, we need to focus on cognitive flexibility.

This is the hidden opportunity of our time. While others debate whether AI will replace human workers, the real question is: which humans will be able to work effectively with AI? The answer depends less on technical skills and more on the fundamental approaches to learning and thinking that we can start developing today.

The future belongs to the error-correctors, the question-askers, the people who learn to approach problem solving with a critical eye. The question is: are we ready to adapt to create more of them?

*Seth Robins is an AI adoption consultant specializing in chemical manufacturing and an advocate for critical thinking methodologies in AI implementation. He helps organizations develop the human capabilities needed to work effectively with artificial intelligence.