Take that advice apart and it says two different things. To someone actually tuning a system, a prompt is an input you revise and a tool is a model you swap. Both are settings, and the claim is that better settings produce better output. Narrowly true, and it tells you nothing about whether you’re thinking well. To everyone else, those same four words say something far larger: that competence ships with the upgrade. That claim is enormous, and it’s false.

Travis LaCroix, Fintan Mallory, and Sasha Luccioni have a name for the mechanism that lets one sentence carry both. Strategic polysemy: a term keeps its narrow technical sense available for specialists while holding the richer common-sense association for everyone else. The speaker collects the force of the large claim and retreats to the small one the moment anyone pushes. That’s advice that can’t be wrong, which is why it gets repeated constantly and tested almost never.

The real trick though is that vocabulary doesn’t stay with specialists. It reaches a provost or a development director through a vendor demo, a policy memo, a conference keynote, a training deck, and almost never through a paper with its qualifications still attached. This isn’t specifically a higher ed problem either; every hop sands down whatever made the original claim narrow and true. What arrives is a statement about capability that nobody in the room is positioned to challenge because it issues from an expert even if its meaning has morphed in the intervening mechanisms of traveling to wider publics. We might not do it here, but one could reasonably argue that the value of a liberal arts education is specifically tuned to generating a capacity to resist strategic polysemy in all its guises. That however, is a topic for another time.

Instead, I want to think about the harder version of strategic polysemy that is emerging right now: when the machine does it too. Generative AI output carries the register of expertise — the confidence, the structure, the borrowed vocabulary — without whatever grounding would license it. Ask a model about something you know well and you can see where the terms are doing decorative work. Ask it about something you don’t, which is the entire reason you asked, and you can’t. It reads as a specialist speaking plainly, when what’s happening is plain speech has started wearing a specialist’s clothes. In short, generative AI tools are masters of strategic polysemy.

How much that costs depends on the job. For a grocery list, little to nothing. For reading technical literature on a subject where the terms are precise and contested and load-bearing, a great deal. The challenge, as is the challenge with almost all strategic polysemy, is that you very rarely see the bill for what this costs.

Now we can come back to that liberal arts education claim that was lurking in the background a few paragraphs ago. If this capacity of generative AI names a real problem, that it really engages in a kind of strategic polysemy, and that we are increasingly facing this problem as generative AI becomes more and more prevalent, then I think that tells us something very important about what we mean by AI literacy. The skill that actually matters right now has nothing to do with getting a smoother, faster, more complete answer out of the machine. AI literacy is not so much concerned with technical use as it is with learning how to get in the way of the polysemy that accompanies all use of generative AI tools. Essentially AI literacy is most critically an investigation into how we teach people to get in the way of the machine and obstruct it.

I mean this very literally; the idea came to me because I find that it is a pretty accurate description of what I do using generative AI; it is not just a figure of speech. The technique I rely on most is The Obstruction Move: a deliberate step that stops the model from handing me something finished. Not because finished output is bad, but because finished output arrives past me. It sails by. I read it, I nod, and some part of the thinking that should have happened in me happened somewhere else instead, and I never noticed the transfer.

The Obstruction Move is how I keep the thinking in the room.

The Arrival Problem

Along with the importance of the obstruction move is something I think people get wrong when they complain about AI output. In general, we tend to diagnose AI problems in terms of a quality failure: it’s generic, it’s bland, it’s got that porridge texture of an overly-wrought freshman trying to sound like Dickens.

Don’t get me wrong, that diagnosis holds up. But, it also aims at the least interesting part of the problem.

So let’s think backwards for a moment. If AI literacy means teaching people to enact the obstruction move, building in deliberate steps that prevent models from handing us finished products, then we can think from this needed outcome back toward the problem it implicitly names. Spoiler alert, it is not primarily naming a problem about the prosaic quality of the output. The real defect being identified has to do with timing. I’ll call it The Arrival Problem: the output reaches you before your own position on the question exists, so you spend the rest of the encounter reacting to an artifact instead of building a view.

We have all had this experience. You ask a question. Four seconds later there’s a complete, well-organized, plausible answer sitting in front of you, and nothing about it invites you to argue with it. Or, at best these days it gives you a multiple choice question about how to clarify the output. No matter what, though, what presents itself to us is The Done Object, and done things don’t ask you for anything.

Ori Freiman has worked out why that presentation is so effective, and the answer runs through a word philosophers use more narrowly than a courtroom does. Testimony, in epistemology, is the ordinary business of knowing something because somebody told you. It’s not a minor channel. Almost everything you know about history, medicine, or what happened in the meeting you missed arrived that way, and you verified none of it.

What makes relying on it rational rather than reckless is a set of conditions attached to the speaker. They meant to tell you something. They can be asked how they know. They can turn out to be wrong and be held to it, and their knowing that is a large part of why they were careful in the first place. Testimony carries standing because somebody is standing behind it.

Freiman’s argument is that this theory is anthropocentric all the way down, built for exactly those speakers, and that a conversational interface reproduces the shape of testimony while meeting none of the conditions. In short, it generates dependence and supplies nothing that would earn it. Thus, the output arrives looking self-authenticating and isn’t. We intuitively know this and nothing I’m saying here is wildly new. Scholars and skeptics have been making this claim about generative AI since it emerged. But, the framing is still important. When the interface borrows the authority of a trusted speaker and takes on none of the risk, this is strategic polysemy again, running across a whole answer instead of just a single phrase.

That mismatch is what makes a fluent answer feel settled when nothing about it has been settled.

Compare that to what happens when a colleague sends you a messy half-draft with three competing ideas and a note that says “not sure which of these is right.” You don’t evaluate that. You enter it. The incompleteness is an invitation, and you accept it without deciding to.

The fluency of AI output does more than decorate it. Fluency is the thing that closes the door, and the closing is fast. In fact, it is faster than your own thinking on most topics, which means the machine’s version of the idea gets there before yours does. None of this indicates that the answer from the machine is bad. In fact, we haven’t talked much about the quality of the answer at all or dealt with specific types of AI outputs in any way. All we have been dealing with is how the answer itself functions as a communicative and rational act. And in that more limited scope, we can claims pretty specific that that left to its own devices, the answers generative AI provides always arrive early.

So the technique we need for AI literacy, to make it a better communication partner, is to make the output arrive in a form that can’t be finished, and can’t be handed to anyone else until you’ve done work on it.

The Unforwardable File

If we take that approach to AI literacy there are some specific things we can teach people! We can teach people specific ways to obstruct AI and prevent the closure the Arrival Problem presents us.

In noparticular order, what follows are key ways that I actually obstruct my generative AI answers on a regular basis. But, if the argument holds then these are the types of technical skills on which real AI Literacy would be built.

The first obstruction is asking for output as a technical file. Most often I’ll ask for JSON, which, if you haven’t run into it, is a structured data format that writes information as labeled nested lists rather than as prose. It shows up as brackets, quoted labels, and indentation. It is aggressively not an essay.

It works because it produces The Unforwardable File. You can’t send a raw JSON payload to a colleague with a note saying “thoughts?” You can’t skim a wall of key-value pairs and walk away feeling informed. To get anything out of it you have to parse the structure: read what got filed under which label, notice what’s sitting in a field where it doesn’t belong, and reassemble the whole thing into meaning in your own head. That reassembly is the thinking. And the output never gets to pretend it’s done, because it visibly isn’t.

There’s a secondary effect I like even more. Forcing a structured format makes the model commit to categories. Prose can hedge its way through a soft distinction; a labeled field can’t. When I find something filed under a heading where it clearly doesn’t belong, I’ve learned something about the shape of the problem that fluid prose would have smoothed over.

The same architecture is turning up in serious institutional design. Systems built to interrupt algorithmic compliance present a prediction next to its confidence, the variables driving it, and the alternative readings, and they reserve the final normative judgment for the person sitting there. Asking for an unforwardable file is that design improvised at one desk, with no budget and no procurement cycle.

The Irreconcilable Brief

The second obstruction works on structure rather than format. Here the goal is not to produce a complicated prompt, but a contradictory one. I’ll give the model several things I want that can’t all be satisfied at once. Be comprehensive and stay under a page. Honor this framework and account for the case that breaks it. Write for the skeptic and the enthusiast simultaneously. That’s The Irreconcilable Brief.

The model can’t resolve it. Nothing can resolve it; that’s the design. For the philosophers out there we use something like an irresolvable Kierkegaardian Paradox to confuse the machine (just like we do with students when we are teaching them). So instead of one smooth answer, what comes back lands in one of three states. It picks a lane and shows what the other lanes cost. It tries to serve everything and produces something visibly wobbly. Or it surfaces the tension explicitly and asks me which way to go.

All three are useful, because all three hand the arbitration back to us. John D. Lee and Katrina A. See set the standard for this in 2004, in a review that gathered trust research from organizational, sociological, psychological, and neurological work into a single account. Their definition is deliberately unromantic. Trust is the attitude that an agent will help you achieve your goals in a situation marked by uncertainty and vulnerability, and both of those conditions have to hold. Where nothing is uncertain and nothing is at stake, trust isn’t doing any work.

Their sharper move is to separate trust from reliance. Trust is an attitude you hold; reliance is what you actually do. The two come apart constantly, and the gap between them is where the trouble lives. You can rely on a system you would describe to a colleague as one you’re skeptical of, and the skepticism costs that system nothing so long as your behavior keeps deferring to it.

What they ask for is calibration, an attitude sized to what the system can actually do. Calibration by itself is coarse, though, so they add resolution: trust has to be able to differentiate, both across tasks, since competence at one thing is not competence at the next, and across time, since last month’s reliability says nothing about this morning’s. That is exactly what a single smooth answer refuses to give you. It arrives as one undifferentiated block with no seams to calibrate against. Three different textures of strain give you the seams. Calibration isn’t a posture you adopt in the abstract. You can only perform it on a specific decision you’re holding, and most AI encounters never produce one. The Irreconcilable Brief manufactures the decision.

The argument in front of you came out of exactly this. The brief behind it carried goals that couldn’t all be met: conceptual density without abstraction, institutional stakes without leaving the first person, a defense of friction that couldn’t itself be tedious. The thesis emerged from the collision rather than from a request for a thesis. Which is either good evidence for the method or an elaborate case of me marking my own homework, and I’d like to think it’s the first one.

Cognitive Forcing Has a Literature

In 2021, Zana Buçinca, Maja Barbara Malaya, and Krzysztof Z. Gajos went looking for something that would stop people from accepting AI recommendations without thinking. The standard remedy at the time was explanation: give people a richer, clearer account of how the system reached its answer and they’ll evaluate it properly. The researchers tested that remedy against a different class of intervention, one that left the system alone and changed the workflow around it. They called these cognitive forcing functions. Some required the person to commit to their own judgment before the system’s answer was shown. Others delayed the reveal, interrupting the reflex of immediate uptake.

Explanation was the weaker instrument. The interventions that changed the shape of the encounter reduced overreliance more effectively than the interventions that improved the machine’s account of itself. People also gave their least favorable ratings to the designs that reduced overreliance the most.

That result relocates the whole problem and elucidates a key tension. The lever in AI-assisted work is the structure of the encounter, not the system’s apparent intelligence and not the explanation layer bolted onto it, which makes it a workflow decision any one person can make this afternoon without waiting for a better model or a vendor release. And, you probably will feel a lot less satisfied using AI this way.

Both of my obstructions presented above are cognitive forcing functions improvised by a user instead of installed by a designer. The Unforwardable File is a reveal delay: it withholds a consumable answer until I’ve parsed the structure myself. The Irreconcilable Brief is a prior-commitment device: it makes me define the criteria before I can judge how the machine handled them.

That last finding is worth sitting with, because it breaks the instrument most of us use to judge our own AI habits. If the designs that worked best were the ones people liked least, then feeling dissatisfied with a session is not evidence that you did it wrong. It is closer to evidence that you did it right.

Which would be a tidy conclusion if it were the whole story. It isn’t, because feeling dissatisfied is also exactly what it feels like to have wasted an afternoon. Raja Parasuraman and Victor Riley named the two ways a person can get an automated system wrong back in 1997, and they are still the only two on offer. Misuse is over-trusting a system and taking what it hands you. Disuse is refusing a system that would have helped, or making a task hard that had no business being hard. Obstruction is aimed squarely at misuse. Pushed far enough on the wrong task, it turns into disuse.

Which leaves the signal unusable. The friction of a session that genuinely sharpened my thinking and the friction of one where I manufactured difficulty over a task that deserved a straight answer feel identical while I’m inside them. Neither one announces itself. I can’t ask whether the work felt good, because the answer is no either way. And I can’t ask whether it felt bad for the right reasons, because that is precisely the question I was trying to answer. Despite friction being the idea du jour of those working with AI and education, we are smuggling in context whenever we make this a “usable” signal.

The Authorship-Expansion Test

Here’s how I know whether a piece of AI-assisted work actually went well. I call it The Authorship-Expansion Test, and both halves have to pass.

Can I name what I would have done on my own? And can I name what became possible that wasn’t possible before?

If I can’t answer the first one, I didn’t have a position to begin with. I committed the cardinal sin of generative AI use: I outsourced the thinking, and I’m now the proud owner of a conclusion I don’t understand. If I can’t answer the second one, I didn’t need the tool at all really; I made a familiar task marginally faster and told myself that was transformation. I’ve failed this test plenty of times (I mean almost everyday something I do will fail this test), usually on the second half, using a frontier model as expensive autocomplete and pretending otherwise.

The first failure has been measured in workplaces, not only felt at desks. Research on algorithmic management in IT services by Liu and colleagues found that overreliance on algorithmic guidance reduces improvisational capability and creative performance by constraining discretion. Workers offload the prediction and the decision, and what thins out is the ability to handle the case the system never anticipated. The authorship half fails at organizational size, and there it comes with a cost line attached.

What I like about my little test though is that it can be failed. “Use AI responsibly” can’t be. I think this is also where obstruction really earns its keep: if the output arrives finished and fluent, my own position never had to exist, so I can’t name it afterward. If I had to reassemble a structured file or arbitrate between goals that wouldn’t reconcile, I have a position by necessity. I had to build one to do the reassembling.

The Gravity of the Middle

Let’s not get ahead of ourselves, though. The test settles a session. It does not settle the disposition.

Run it afterward and it will tell you whether one piece of work went well. What it will not tell you is how hard to push before you begin, or whether a standing habit of obstruction is calibrated to anything or is just a preference for doing things the hard way. That question stays open, and it deserves its strongest form. This sounds like self-imposed friction as a kind of performance. Grinding your own coffee beans with a burr grinder by hand. Doing it the hard way so you can feel like a craftsman about it.

I’ve looked for the line where obstruction turns indulgent, and I haven’t found it. Not because I have superhuman judgment about when to stop, and not because the risk of tipping into disuse was imaginary. Because of something structural in how these systems work.

Emily M. Bender, Timnit Gebru, Angelina McMillan-Major, and Shmargaret Shmitchell described the mechanism in 2021: these models generate by predicting the most probable continuation from a training distribution, with no communicative intent and no model of the world behind it. That is The Gravity of the Middle. Pulling toward the center of the distribution is what the architecture does when nothing interferes. The generic isn’t a bug in the output; unless something pushes, the generic is the output.

This means there’s always something to push against. The friction is a corrective for a real force in the system, not a manufactured one. Every time I’ve pressed the machine off its first answer and gotten something better, it wasn’t because I was clever. The first answer was the middle, and the middle was never going to be interesting.

There’s a second move available here, and I think it matters more than the defense. The question “isn’t this just making your life harder?” arrives pre-loaded. Sociologists of valuation describe competing registers of worth, and systems built in the Industry and Market registers — the ones that prize efficiency, throughput, and frictionlessness — structurally classify anyone who asks for deliberation as irrational. That register is what’s asking the question. Answer it on its own terms and you’ve conceded the argument before it starts.

An obstructionist approach also isn’t something a model will propose to you on its own. It runs against its own grain. You have to shape and press for it, which is a small recursive proof of the whole argument: the technique that makes the tool most valuable is precisely the one the tool won’t suggest.

Then Do the Part That’s Yours

My problem with “better prompt, better tool” has nothing to do with whether it works. It assumes the goal is to get the machine to do more of the work, and that was never the goal.

The cost of never obstructing has a name in the workplace literature: anticipatory compliance. People preemptively adjust their own behavior to satisfy an algorithm and minimize what it will penalize, internalizing its preferences until the adjustment stops registering as one (I may have a lot more to say about that in the coming months). Move that from performance metrics to thinking and you have the whole risk in a phrase. You stop arguing with the output because you’ve started producing questions it answers well.

An accountability cost runs alongside it, and it doesn’t yield to expertise. Dawson Petersen and Amit Almor ran an experiment in 2025 that changed nothing about an AI system except the grammar used to describe it. Participants read a vignette in which a medical AI gave dangerous advice. In one version the machine held the subject position of the sentence: Dr. A.I. made an error. In the other, the company acted and the system was the means. Readers with less AI experience blamed the machine more when it was the grammatical subject, and experienced readers did not, which is the reassuring half of the result and the half most people stop at. The other half is worse. Everyone assigned less responsibility to the company under the agentive framing, and that effect was stronger among the experienced readers, not weaker.

Knowing how these systems work protected people from over-crediting the machine. It did not protect them from absolving the people who built it. That is what makes this structural rather than a training gap, and the ground underneath it is moving. The industry now ships products called agents. Agentive grammar has stopped being a choice some marketing team makes and become the name of the category, present in nearly every sentence written about the thing. The polysemy this essay opened with is now the default register of an entire industry, and a machine credited as an author leaves nobody holding the work.

But, the institutional literature draws a line that also holds just as well at one desk. Pragmatic execution can be delegated. A great deal of epistemic work can be delegated. Normative delegation, deciding what any of it means and what should follow from it, is reserved. That’s the part that’s yours.

The goal is for the thing to become a development partner, something that extends what you can think rather than substituting for it. And extension requires that you still be thinking. A partner who finishes your sentences before you’ve thought of them isn’t extending you. They’re replacing you, politely, at a speed you’ll probably mistake for helpfulness.

So: get in the way. Ask for the file, not the essay. Give it goals it can’t reconcile. Make it hand you something you’d be embarrassed to forward to anyone.

Then do the part that’s yours.

Everything breaks. Everything you thought you had right goes wrong. If it could go wrong, it will go wrong. Wrong, wrong-wrong, and more wrong.

The prototype worked. You tested it. You showed it to people. It did the thing, and you felt the particular satisfaction of having built something that functions, the moment the gap closes between what you imagined and what exists. Then you tried to make it real, for real users, under conditions you did not design for, and the thing handed you back every assumption you made while building it.

I have had this happen with a script I was proud of. It ran for months on my machine, doing exactly what I built it to do. The first time someone else ran it, it failed in under ten seconds, on a detail so small I had never once thought about it.

For those of us who are building objects for people but weren’t trained formally to do that building (i.e. you’re the person on your team who got excited about AI, de facto became the person everyone asks for help, and now suddenly are “in charge” of AI development without any background on paper that would give you the “expertise” to be leading such an initiative), it is really hard not to get discouraged byt he movement from “Brilliant!” to “Everything is wrong all the time!” It feels like failure. So let me state this baldly: this is not a failure. It is implementation. It is what happens when a system designed under controlled conditions meets the uncontrolled world. Every prototype is a hypothesis. Implementation is the test. Saying that doesn’t necessarily hlep with the feelings of inadequacy and failure that well up in us nonetheless.

I recently wrote The Builder’s Progression as a way of thinking about getting a better perspective on the terrain. Understanding where we stand in our capacities and techniques in relationship to what generative AI might do for us. This essay is about a boundary running sideways across every one of those stages. Call it the Works-For-Me Line.

Most people are not prepared for how different the test feels from the hypothesis, and the unpreparedness is structural rather than personal.

That structure is worth naming, because I have spent the past two years inside it. Turning something that works into something other people can depend on used to be a profession. It came with training, a title, a career path, and colleagues down the hall who had already solved the problem you were stuck on. That work has been redistributed without anyone announcing it. It now lands on whoever in the office was curious enough to try the thing first, which in most higher education and nonprofit settings means one person, with no budget line and nobody to ask.

I include myself in that. I was trained to read theology. Nothing in that preparation has anything to say about deployment, or error handling, or what to do when a tool I built fails in someone else’s hands on a Tuesday morning while I am sitting in a meeting. I have been working the terms out as I go, mostly by getting things wrong first and paying attention afterward. So this is written as much for me as for anyone reading it. The reason to publish rather than keep it is that nearly everyone I talk to is having some version of the same experience, and almost nobody has been handed the words for it.

The Firstborn Question

Before the documentation, the UX testing, the error handling, the deployment, there is one question that determines whether you get through implementation.

Are you willing to give your firstborn child for this project?

I used to tell students who were thinking about applying to doctoral programs in theology something similar. Are you ready to have to try and compete with all your friends for a very few number of tenure-track jobs that will require you to sacrifice your sense of ego and importance so that you can be underpaid for the level of expertise that you have? Couldn’t you ve happier doing anything else? Every time someone asks me about how they can take their great and useful prompt, bot, webapp, small piece of software, whatever... and turn it into something their friends and neighbors will benefit from, I get flashbacks to these moments with students. What will you be willing to sacrifice to do this.

So we will casll this the “Firstborn Question” (thanks Abraham). And we need to recognized that, yes, it is hyperbolic.; and, it is also not quite hyperbolic enough. Implementation requires a category of commitment that prototyping does not. The prototype can be abandoned; you can learn from it, set it aside, start something else. Once real users depend on it, once a client has paid for it, once you have told people it exists and works, it has to keep working. Every failure becomes someone else’s problem. Every gap in your design becomes a gap in someone’s day.

Fred Brooks put a number on that weight in 1975. He opened The Mythical Man-Month by refusing to call a working program a product, and laid out a ladder instead. At the bottom sits a program that runs for its author. Above it sits a programming product: the same idea generalized, tested, documented, and maintainable by strangers. Above that sits a programming system, integrated with other components across defined interfaces. At the top sits a programming systems product, which is both at once.

Each rung, Brooks estimated, costs roughly three times the one beneath it. A programming systems product therefore runs about nine times the cost of the program already working on your machine. The thing you have when the prototype runs is one unit. The thing you are proposing to build is nine by Brooks anecdotal estimation. That’s a lot of emotional difference.

The Firstborn Question stops being melodrama at that point and becomes arithmetic. It asks whether you have nine units of anything (time, money, attention, plain stubbornness) standing behind something that already looks finished at one. Most people answer with the enthusiasm they felt at one unit, which is the wrong measurement taken at the wrong moment.

The honest answer tells you whether you are ready. A paying client who needs the thing will keep you in the room when everything is broken and the debugging is tedious and the elegant prototype feels like it happened to someone else. An obsession that will not leave you alone does the same work by a different route. Without one of the two, you do not have nine units, and no amount of starting excitement will manufacture them.

Let me say this plainly, because the alternative usually gets treated as defeat. If the prototype is interesting but not urgent, if you could live without finishing it, stay at the prototype. It has value. The question was never whether you can implement. It is whether you have the driver that carries you through the part where everything breaks.

Brooks’s bottom rung is a place to live, not a waiting room, and that matters most for the people least likely to believe it. Most of the people building things with generative AI right now in higher education and the nonprofit sector are not developers and never planned to be. You are a director of annual giving who got tired of writing the same acknowledgment letter four hundred times a year. You are an assistant registrar with a script that reconciles two exports nobody ever built an integration for. You are a program officer with a prompt that turns messy site-visit notes into a usable first draft. The thing you built gives you back six hours a week. It has an audience of one, and one was the right number.

The pressure to widen that audience arrives fast, and it usually arrives from a generous place. Someone sees your screen, says this is amazing, asks whether everyone can have it, and the question sounds like recognition. What it proposes is that you take on nine units of work for a tool currently returning one, inside an institution that will not give you release time, will not fund a support line, and will still want the annual report on the same date. Your tool does not have to become your department’s tool. It does not need a login page, a training doc, or a name. The six hours a week stay real either way, and building something excellent that only you will ever run is a complete outcome with nothing missing from it.

What Actually Breaks

It helps to know what is coming, and to be relieved in advance of the assumption that breakage is a verdict on you.

Richard Cook studied failure in systems where failure kills people, and in 1998 he compiled eighteen propositions about how complex systems behave. Complex systems, he observed, run in degraded mode continuously: the working system always carries faults, and it keeps working because the faults have not yet lined up. Catastrophe requires several failures at once, which is why single-cause explanations offered afterward are almost always wrong. Read that against your prototype and the diagnosis changes. It was not sturdy on Tuesday and fragile on Wednesday; it carried the same faults both days, and what changed was the exercise. Charles Perrow had named the class of system where this becomes inevitable in Normal Accidents (1984): interactive complexity plus tight coupling makes the accident a property of the design rather than a lapse in judgment.

Underneath that picture, three specific things go wrong.

Edge cases. Your prototype handled the inputs you gave it. Real users will hand it inputs you never imagined: empty fields, unexpected formats, content in languages you did not test for, combinations of choices that should not coexist and do. The reason you missed them has a structure worth naming. Your test inputs came from the same mind that wrote the system’s assumptions, which means they were selected, unconsciously, to be inputs those assumptions could handle. You cannot falsify your own blind spots with materials you produced from inside them.

Load. The prototype worked for you, run a few times, one request at a time. Real usage means many people at once and infrastructure you never had to think about because you never had to. Michael Nygard drew the line in Release It!, published in 2007: there is a difference between software that is feature-complete and software that is production-ready, and most software is designed to pass QA rather than to survive production. The failures that matter arrive at integration points, the seams where your thing meets something you do not control. A script that reads one local folder correctly meets a shared drive, an API rate limit, and forty simultaneous users, and the logic you wrote is not what gives way.

Distance. The third never announces itself as a breakage, which is why it goes unnoticed longest and costs the most.

The Works-For-Me Line

Every prototype works for someone: its builder. Crossing the Works-For-Me Line means the system now has to work for a person who does not know what you know, cannot ask you, and will not be watching over your shoulder while you demonstrate the correct way to use it.

Don Norman mapped this distance in 1988, in The Design of Everyday Things. He described three things that are easy to collapse into one. There is the designer’s conceptual model, how the builder understands the system. There is the user’s conceptual model, how the person in front of it understands the system. And there is the system image: the thing actually built, including its interface, its behavior, its error messages, and whatever documentation ships alongside it.

The finding matters for anyone crossing the line. A designer never transmits their model to a user; the channel does not exist. What gets transmitted is the system image, and the user constructs their own model out of that alone. When the two models diverge, two gulfs open. The gulf of execution is the distance between what the user wants to do and what the system will let them express. The gulf of evaluation is the distance between what the system reports back and what the user can conclude from it. Both are properties of the artifact rather than deficiencies in the person operating it.

Run the standard complaints through that frame and they stop being complaints. They will use it wrong. They will expect it to do things it does not do. They will be confused by outputs that seem obvious to you. They will give up at exactly the moment you would have known to try something else. Every item is a design fact with an address in the system image, which means every item is something you can go and fix.

I found my own version watching a colleague run a script I had built for my content pipeline. It expected a particular nested folder structure to already exist. I had built that structure so long ago it had stopped being a decision and become furniture. She ran the script into an empty directory, it failed instantly, and the error message described the symptom in terms only I could interpret. Two of Norman’s gulfs in about eight seconds, from a tool I would have called finished.

Capability and audience are different measurements, and this is why. The assistant registrar whose script reconciles two exports is finished, and owes nobody an apology for it, however plain the script looks to someone who writes software for a living. A builder with far more technical range, whose prototype has real architecture and error handling and a test suite underneath it, can still sit entirely on the near side of the line. Nobody crosses the Works-For-Me Line by getting better at building. You cross it by changing who the system is for, which makes the decision in front of you a question about people. Who else, specifically, and what will you owe them once they depend on it?

The Intimacy Gap

Something genuinely new is happening between builders and their code, and it deserves to be named honestly rather than defensively.

The traditional developer knew every stone. They wrote every line. They understood the architecture from the inside: not only what the system did but why it did it that way, what the alternatives had been, what would break if you changed a given piece. That knowledge made them good at anticipating where users would struggle, because they could trace the paths to friction without leaving their chair.

The agentic builder works differently. Generating substantial portions of a codebase rather than typing it produces a different relationship to the result. You know what you asked for. You may not know precisely what you got. You can read it, more or less, and reading is not the operation that produces a feel for a system. Peter Naur made the underlying point in 1985: the theory of a program lives in the person who built it rather than in the text they produced. That theory is what the agentic builder never acquired, and the hole it leaves sits exactly where UX intuition used to live. Call it the Intimacy Gap.

There is now evidence that this kind of self-knowledge fails in measurable ways. In July 2025, METR ran a randomized controlled trial on experienced open-source developers. Sixteen developers took on 246 real tasks in mature repositories they already knew well, each task randomly assigned to an AI-allowed or AI-disallowed condition. The setup matters: real work by people on their own familiar ground rather than benchmark puzzles handed to strangers.

The developers were 19% slower when they used the AI. Before starting, they had forecast a 24% speedup. Afterward, having just been slowed down, they estimated they had been about 20% faster.

The slowdown is the headline and the least interesting of the three numbers. The one that should concern anyone building this way is the last: experienced builders were wrong about their own building, confidently, in the flattering direction, on ground they knew intimately. Speed is among the easiest things to be right about, since anyone with a clock can check it. If self-assessment fails there, the intuition telling you where a user will get stuck is not a faculty you should treat as evidence. Which means agentic builders need more deliberate documentation and testing than traditional developers did, precisely because the tooling made the building faster. The intimacy has to be replaced by structure that lives outside your head.

This is also one of the legitimate sources of discomfort experienced developers feel about agentic building, and it deserves something better than dismissal. The objection usually gets heard as nostalgia, or as defense of a threatened skill set. Underneath it sits a more precise observation: a particular kind of knowing is being bypassed, that knowing had uses well beyond producing the code, and those uses are hardest to see from the position of someone who never had it. Those developers are describing something real, and the useful response is to build the replacement rather than to argue them out of the objection.

Documentation Written at the Moment of Decision

Two structures do most of the work of standing in for that intimacy. The first is documentation, and the word misleads enough to need qualifying immediately.

Not retrospective documentation. Documentation written in the moment, as each decision gets made, as each piece takes shape. What does this step do? What does it need? What does it produce? What happens when it fails? Four questions, answered while the answers are still obvious, which is the only window in which they are obvious. This is harder than it sounds, because the momentum of building pulls against it. Stopping to write feels like stepping off the treadmill at the exact moment it finally got up to speed.

David Parnas and Paul Clements addressed the difficulty in 1986, in a paper whose title gives away its argument: “A Rational Design Process: How and Why to Fake It.” They began by conceding what every working engineer knew and no document admitted: real design does not proceed by orderly derivation from requirements, but by false starts, half-understood problems, decisions made on incomplete information, and mistakes discovered late and repaired sideways. The tidy documents produced afterward describe a process that never happened.

Their response was the interesting part. Rather than abandoning the rational record as a fiction, they argued for producing it deliberately: write the documentation the ideal process would have produced, and write it continuously, as the work happens. The reasoning behind that instruction carries the weight. The artifact is permanently self-evident, since the code will still be sitting there next year saying exactly what it does. The reasoning is not. It exists only in the head of the person holding it, decays on a schedule nobody controls, and cannot be reconstructed from the artifact afterward at any price.

That is what makes retrospective documentation nearly worthless. It describes what a system does, which the code already told you. Documentation written at the moment of decision records why the system does that instead of the three other things you were weighing at four o’clock on a Thursday, which is the only question you will actually have at eleven at night three months later. Michael Nygard turned this into a format in 2011 with the architecture decision record: context, decision, consequences, one short file per decision, written when the decision is made. The format stays small because the realistic alternative to a small format is nothing at all.

For agentic builders the stakes rise. Documentation is the bridge across the Intimacy Gap: how you assemble a working model of a system you did not assemble line by line, and how you keep that model current as the system changes underneath you. Without it you depend on the AI to re-explain your own system to you every time something goes wrong, which works, slowly, and not always, and rarely at the hour you need it most.

The Not-You Test

The second structure costs far less than anyone expects. The Not-You Test needs one person who has no idea how the system works, one task for them to complete, and your silence. Run it as early as possible, and more often than feels reasonable.

The economics were settled in 1993, when Jakob Nielsen and Thomas Landauer published a mathematical model of how usability problems accumulate across testers, built from observed detection rates in real studies rather than from intuition. The curve they produced bends early and hard. A single tester surfaces roughly a third of a system’s usability problems; five surface about 85%. Past that, additions get expensive relative to what they return, because the sixth tester spends most of the session rediscovering what testers two and four already found. Nielsen built his 2000 essay on this finding, telling designers to stop at five.

The implication for a solo builder is the part usually missed. People skip usability testing because it sounds like a budget line: a lab, a recruiter, a two-way mirror, a report nobody reads. Five people and an afternoon is not a budget line. And because the curve flattens, three rounds of five beats one round of fifteen, since you fix the problems between rounds and each later round tests a different system.

Steve Krug supplied the discipline for the room itself, in Don’t Make Me Think and the do-it-yourself protocol in Rocket Surgery Made Easy. Give the task. Then stop talking. Watch them use it without helping them. The instinct to say “oh, you should have clicked” will be the strongest instinct you have in that room, and every time you obey it you rescue one user and destroy the finding you brought them in to produce.

This is uncomfortable. It is supposed to be uncomfortable. The discomfort is information, and it is worth being precise about what the information says: you are watching your own model of the system fail in someone else’s hands. That event is the thing you invited five people over to produce. Sitting through it without intervening is the entire skill.

What Implementation Actually Is

There is a version of the Builder’s Progression that treats implementation as the destination, the proof that the prototype was real. I want to offer a different frame.

Implementation is where a different kind of work begins. The prototype was about building something that functions. Implementation is about building something that sustains: something that handles what you did not design for, serves people who do not know what you know, and keeps working while you are not watching.

Hannah Arendt drew the distinction that fits this best, in The Human Condition, published in 1958, though she was not writing about software. Arendt separated work from labor. Work is fabrication: it has a definite beginning and end, and it produces a durable object that outlasts the making of it, the table or the house you can point at afterward and call finished. Labor is cyclical and never finished. It sustains what already exists, it has to be done again tomorrow, and the evidence that it was done well is that nothing fell apart.

The prototype is work in Arendt’s sense. It concludes, the conclusion is the reward, and the reward arrives as a moment you can locate in time. Implementation sits closer to labor. It does not conclude. Its satisfaction is that something continues to exist, a real satisfaction with a fundamentally different shape. Nobody throws a party because the system stayed up.

That asymmetry gets mistaken for a personal failing more often than it gets recognized as an inheritance. In 2016, Andrew Russell and Lee Vinsel published an essay in Aeon called “Hail the Maintainers,” arguing that a culture fixated on innovation has almost nothing to say about maintenance, though maintenance is where the overwhelming majority of the work and the value actually sit. The people keeping existing systems running vastly outnumber the people inventing new ones and receive a fraction of the attention. If implementation feels less glamorous to you than prototyping did, you inherited that feeling, along with the vocabulary that made prototyping sound like the interesting part.

Both satisfactions are real, and they require different things from you. The prototype requires vision, fluency, and permission to break things inside the safety of your own testing environment. Implementation requires the willingness to give your firstborn child, or something close enough: the driver that keeps you in the room when everything is broken, the discipline of writing things down while they are still obvious, the humility to watch someone struggle with what you built and treat the struggle as data rather than as an attack on the design.

Not everyone needs to make that crossing, and the exit ramp deserves a sign rather than a footnote. The development director whose acknowledgment letters now draft themselves has already won. Nothing about that win is provisional, nothing further is owed, and six hours a week returned to one person every week is a result most institutional software projects never manage.

But if you are going to cross, if the driver is there and the commitment is real, go in knowing what is coming.

Everything breaks. You fix it. You write down what you fixed and why. You put it in front of someone who is not you. You fix what they find. You keep going.

That is implementation. It is harder than the prototype and more durable than the prototype and, eventually, more satisfying than the prototype.

Just not at first.

The machine thinks for three seconds and hands you back something that is technically responsive to exactly what you typed, yet manages to completely miss the point. Generic and flat, it solves a problem you do not actually have.

What happened is Invisible Context at work. Your prompt broke because of the words you left out: the constraints and assumptions you did not explicitly name because they were so obvious to you that saying them out loud felt entirely unnecessary.

In 1990, a Stanford psychology graduate student named Elizabeth Newton ran a study that explains why this happens (I read about this in Made to Stick). She divided participants into two groups: “tappers” and “listeners.” The tappers were asked to tap out the rhythm of a well-known song, like “Happy Birthday,” on a table. The listeners had to guess the song based only on the taps.

Before the experiment, Newton asked the tappers to predict how often the listeners would guess correctly. The tappers predicted 50 percent. The actual success rate? 2.5 percent. The tappers could not understand why the listeners were failing. When a tapper taps, they hear the full orchestration of the song playing in their head. The listener just hears a series of disconnected, arrhythmic knocks on a table.

When you interact with an AI, you are always the tapper. You hear the full orchestration of your context. The machine is the listener, it just gets the taps. And because you cannot hear the silence between your own taps, your context remains invisible to you and anyone else needing to build the tools that you are developing.

Writing longer prompts will not fix this! Let me say it again, because I think our natural inclination is to simply say if I get all the context down everything will be well because we can just supply all the missing context. So, remember, writing longer prompts will not fist this. Instead, we all need to focus on learning to see our own assumptions before we type them. That is a different skill than just trying to brain dump everything in our head that is providing context. Luckily, it is also a skill that can be practiced. And this bot is one way to do that practice.

What the Machine Does With Your Gaps

When you leave gaps in a conversation with a human colleague, it usually works out fine. The philosopher Paul Grice spent his career mapping how human communication relies on cooperative inference. If you ask a colleague to “draft the quarterly update,” they do not start from zero. Instead, they know how the last update sounded. They know the current crisis facing the board. They use shared context to repair your underspecified request, filling in the blanks with institutional memory and interpersonal understanding.

A language model does no cooperative inference. As Bender, Gebru, McMillan-Major, and Mitchell laid out in their 2021 paper “On the Dangers of Stochastic Parrots,” a large language model is fundamentally an engine for next-token prediction. When you give it an underspecified request, it repairs the gaps statistically. It looks for the most probable continuation of your words across everything it has ever read, flattened into one probability distribution.

This means the machine will always fill your gaps with the statistical average of everyone’s context rather than your own. An LLM will essentially default to mean output: what most people mean when they write something that looks roughly like what you wrote. If your problem is specific, the statistical average is exactly what you do not want. In fact, in almost every case the statistical average is something you might only want as a reference but not the final product of your thinking.

The chat interface makes this worse, and the reason runs back to a promise made at the very beginning of the field. In August 1955, John McCarthy, Marvin Minsky, Nathaniel Rochester, and Claude Shannon submitted a funding request for a summer workshop at Dartmouth College. That document is where the term “Artificial Intelligence“ was coined. Four years later, in the proceedings of a symposium at Britain’s National Physical Laboratory, McCarthy spelled out what he actually had in mind. The paper was called “Programs with Common Sense,” and it described a machine he named the Advice Taker: a program that would hold everything it knew as a list of explicitly stated premises and reach conclusions by formal deduction. “A program has common sense,” McCarthy wrote, “if it automatically deduces for itself a sufficiently wide class of immediate consequences of anything it is told and what it already knows.”

Read that sentence slowly, because it describes a machine that behaves nothing like the one sitting in your browser tab. McCarthy’s system would run on stated premises. You would tell it that the board meets in March, that the operating budget is frozen until July, that the provost signs anything above fifty thousand dollars. Each of those becomes a sentence the machine holds and can show you. Ask it why it reached a conclusion and it walks you back through the chain. Now the part that matters: ask it something that depends on a premise you never gave it, and the deduction simply stops. There is nothing to reason from, so the gap announces itself.

A chatbot has no premise list. This basic set of criteria has been designed out of the requirements for the chatbots that we work with so it has nothing to stop at. When your request depends on something you never said, the model does not detect an absence. It sees a place where many continuations are plausible and picks the most common one. The failure McCarthy’s design would have made loud is the exact failure this design we work with makes silent. Fluency always finishes the job.

The net result is that because the machine talks to you like a colleague, you are unconsciously invited to treat it like a colleague. You assume it shares your context because it mimics the cadence of someone who does. It does not. The Advice Taker would have told you where its knowledge ran out. The chat window fills the gap instead, and it fills it in your own voice, which is why you almost never catch it.

What does all of this really mean? First, historically we ought to be careful about how a tight a connection we make between what was conceptually being imagined in the 1950s when much of the initial imagining about what AI might do was being dreamed up and how modern chat-interface generative AI actually behaves. There is a conceptual gap between these points in time that needs more attention than it has gotten for the general public.

Second, generic output is a specification failure rather than an AI failure. The model successfully completed the pattern you started every time. Whether you get fluid bullshit, a ‘hallucination’, or genuinely useful insights you need to edit, the model is not doing something predictable in a deterministic sense, but it is successfully completing its designed function to complete the pattern you left it. You just did not realize how much of the pattern you had left in your own head. The good news about this, though, is that a specification failure is entirely fixable, provided you catch it at the point of specification.

The Bracketing Move

Catching that specification failure requires a specific cognitive maneuver. In 1913, the philosopher Edmund Husserl published Ideas I, laying the groundwork for phenomenology. Central to his method was the concept of the epoché, or “bracketing.” Husserl argued that to understand how we actually experience the world, we first have to bracket our assumptions: we have to explicitly set aside what we think we already know about a thing in order to see the thing fresh, as it actually appears.

While this started in a phenomenology seminar, it is also a great mechanism for improving prompt hygiene. Good teachers practice a version of this every day. When you teach, you have to read your own syllabus the way a student who knows nothing about the subject would read it. You have to actively forget your own expertise. You have to bracket the curse of knowledge, like the tapper’s assumption in Newton’s case that assumes the melody is obvious, to see the steps you skipped because they felt too basic to mention.

Actors use a parallel technique. Konstantin Stanislavski taught his students the “magic if”: the practice of genuinely inhabiting a set of circumstances that are not their own. To play a role, an actor cannot just memorize lines. They must bracket their own worldview and replace it with the specific, bounded reality of the character. They have to see the world from a perspective where different things are true and different rules apply.

Call this practice The Bracketing Move. It is the discipline of looking at your own request from the perspective of an entity that possesses zero shared context, zero institutional memory, and zero implicit understanding of your goals.

Doing this manually is hard because you cannot see what you are not looking at. You need a mirror. You need a system that forces the bracketed view back onto you before you commit the prompt. The Prompt Workshop Bot serves as a gymnasium for practicing The Bracketing Move. Feel free to give it a try!

A full worked run, the setup, the complete instruction set, the architecture behind it, and four ways to hack it are below the fold for paid subscribers.

Subscribe now

Read more

The gap between what you can envision and what you can produce genuinely closes because what used to take a week of concerted effort now takes forty-five minutes of focused prompting and editing. The ideation phase, previously bounded by the physical time required to draft, research, and format, suddenly collapses. You hold a concept in your mind, and within minutes, you are looking at a highly structured articulation of that concept. The cognitive load shifts entirely from generation to evaluation.

This shift runs deep, and it is also disorienting.

Multiply that private impatience by a workforce, and it becomes an institutional physics problem. The modern organization is currently bifurcated. On one side, you have teams and individuals operating at 10x speed, generating proposals, data analyses, and strategic plans with astonishing fluidity. On the other side, you have the institutional machinery. The compliance checks, the committee reviews, and the legacy processes are grinding along at the exact same pace they always have. We are feeding high-velocity output into low-velocity systems. The machinery is beginning to smoke in Higher Education and Non-Profits (so I’d imagine it’s fully on fire in some corporate settings).

The mechanism of this institutional illusion is predictable. A single node in the network adopts the tools and dramatically increases their output, submitting five proposals a week instead of one. The surrounding nodes, operating at legacy speeds, receive this output and become a catastrophic bottleneck. The cost of this failure is severe organizational burnout. The fast node feels constantly blocked and unappreciated, while the slow nodes feel constantly overwhelmed and under siege. The organization has not increased its velocity. It has simply relocated its friction to the points of intersection.

What I’m often experiencing in those honest hallway moments (of in my case virtual coffee chats) is that most executive conversations about this transition focus entirely on the wrong things. Leadership teams spend their retreats talking about vague anxieties regarding comfort and adoption. They worry about whether the staff feels supported, treating a structural fracture as a mere morale issue. The small, expensive problem that is costing universities and non-profits millions of dollars in wasted friction is managing the speed gap before it tears the organization apart. This is about change management as much (or probably more than) it is about AI.

The danger of the speed gap is that parts moving fast make the whole feel fast. When the strategic planning committee generates a draft in two days instead of two months, the institution feels like it is accelerating. Movement, however, does not equal destination. If that draft still takes six months to clear the faculty senate, the institutional velocity has remained static; only the distribution of the waiting period has shifted. The test of leadership in this moment is capturing the converts’ speed without shattering the defenders’ rigor.

The Zealous Convert

When someone first discovers what AI can genuinely do, they tend to become, briefly, insufferable. (Or in my case, entirely insufferable!) This happens in the moment when something clicks and the machine performs a task of real cognitive weight.

I know this because at this point I have lived through multiple rounds of insufferable phases. My enthusiasm has been entirely sincere. I had spent years learning to do things slowly, and suddenly the constraints were gone. I reorganized my entire worldview around what the tools made possible. I began offering three-day estimates for three-month plans. I treated hallucinated competence as actual capability (on more than one occasion). I asked my colleagues if they had tried prompting the machine for their problems more often than anyone around me would prefer.

The Zealous Convert believes that because they can generate material faster, the institution can absorb and act on that material faster. They mistake volume and speed for quality. The model produces text that looks structurally identical to expert output. The Convert reads it, recognizes the polish, and assumes the underlying logic is sound because the syntax is flawless. They begin promising proposals outside their actual domain expertise, assuming the machine can bridge the gap. When a three-day estimate for a three-month plan is accepted, the inevitable failure damages both the project and the institutional trust in the individual.

We have begun to measure the trajectory of this archetype. In a longitudinal study spanning 2023 to 2025, Qing Xiao, Hancheng Cao, and their colleagues followed a project-based software development organization through the full arc of AI adoption. They tracked how the teams used and talked about the tools across two years, long enough to watch the early promises of systemic transformation meet the realities of daily work.

The findings documented a stark deflation of the initial promise of transformation. Early imaginaries positioned AI as a profound team transformer, a partner that would reshape how the organization tackled complex, shared problems and distributed collaborative cognitive load. Over the two years, the researchers watched those grand visions domesticate into isolated, individual productivity add-ons. The overarching team-level workflows remained stubbornly untouched. Individual contributors used the systems privately to complete their own discrete tasks faster, optimizing their personal queues without fundamentally altering the architecture of the team’s collaboration.

The lesson for leaders watching their own converts is that enthusiasm rarely translates directly into institutional throughput. The org-level velocity story deflates into private convenience when it lacks a systemic redesign of how work actually moves through the organization. The Zealous Convert has discovered a profound shift in individual capability, but what they have not yet built is the equanimity of living with the change long enough to know its costs. They fail to see that optimizing a single node in a complex system inevitably creates traffic jams at the adjacent nodes.

The Legacy Defender

On the other side of the speed gap is the colleague who simply will not engage. Every organization has one, and every convert has experienced the distinct frustration of trying to hand them a tool that would solve their immediate problem, only to be met with a polite refusal.

I’ll admit that I initially assumed folks fitting into this part of my typology were romanticizing inefficiency. I thought they were mistaking the pain of manual effort for the rigor of serious work. The Legacy Defender often presents this way, clinging to processes that seem visibly broken to anyone who knows what the new tools can do. Dismissing their resistance as technophobia, though, is incomplete as a diagnosis. The resistance is far more rational than the converts want to admit.

The mechanism of this resistance becomes clear when you examine the nature of the tool. A transparent instrument is a hammer; you know exactly how the force transfers. An opaque independent agent is a black box; you feed it inputs and it hands you an output, but the logic connecting the two is concealed. Philosophical reflection on technology in the 20th century from Martin Heidegger to John Searle have given us plenty of ways to frame this difference.

For a professional whose entire identity is built on demonstrating the ‘why’ behind a decision, the black box is an existential threat. When a registrar relies on an opaque system to evaluate transfer credits, and a student appeals the decision, the registrar cannot defend the logic. The institution loses its ability to explain itself to its stakeholders, replacing reasoned judgment with algorithmic fiat. AI scales the problem of “you don’t know what you don’t know,” making it much more difficult to manage.

In a 2024 empirical study published in the Lomonosov Economics Journal, Petrovskaya and Demchenko examined the conditions under which workers actually trust algorithmic management. Their setting was a sales force, an environment of highly visible metrics and direct pressure, where an algorithmic system evaluated and directed the representatives’ work.

The pattern in their data turns on interpretation. When the reps read the system as a transparent instrument, something they could understand and appeal against when they spotted an error, trust and acceptance held. When the same oversight read as an independent agent with opaque rules, making consequential decisions with no clear mechanism for correction, trust eroded sharply, and with it the felt legitimacy of every evaluation the system produced.

Legacy Defenders are responding to opacity, not novelty. Their resistance is a rational defense mechanism against a system that demands compliance without offering transparency. When they refuse to engage with a new AI workflow, they are refusing to be held accountable for a process they are not permitted to understand, leaving them to bear the consequences of decisions they cannot challenge. That is a wholly rational response.

This tension between accountability and opacity goes far deeper than workflow preferences. Anne-Sophie Mayer, Elmira van den Broek, and Tomislav Karačić tracked it across three organizations in fieldwork running from 2018 to 2025, each researcher embedded in a different setting. They followed loan consultants inside a German bank of 135,000 employees, seed sorters at a global plant-breeding company, and recruiters in a consumer goods firm of 200,000. In each case, management had handed a high-stakes judgment to an AI system: who gets the loan, which seed batch ships, which candidate advances. In each case, the experts lost the power to overrule the decision and kept the obligation to defend it to the person sitting across from them.

What the bank’s consultants did with that obligation should unsettle anyone planning a rollout. The system’s rulings frequently made no sense to them. One consultant described an applicant with above-average income and no debt whose loan was rejected, the machine’s summary offering only “unstable financial situation” by way of reason. Rather than admit they could not account for the outcome, consultants concealed it. They kept the screen turned away from the customer and supplied reasons drawn from their own experience instead: a new income threshold, a shift in the currency market, an entry on the credit file the applicant must have forgotten. The researchers named the practice masking. One consultant explained its appeal without embarrassment: “How should the customer know?”

The customers sensed something was off. One was told his application failed on credit history and replied that he had no outstanding debts; the consultant insisted there must be an entry he was unaware of, and the customer said “Mhm, okay, weird” and left. Because a person applies for a loan once every several years, the consultants received almost no corrective feedback and never revised the practice. The customers simply tried a different bank. By the final field visit in 2025, the bank’s own management had traced the damage: the personal consultation, the very thing that justified maintaining branches, had stopped being worth the trip.

This is the tension every experienced registrar, grant writer, and academic advisor can feel coming. You bear the burden of owning a decision you did not make and cannot explain, and the cheapest way out is to invent an explanation. The Legacy Defender is fighting the erosion of their professional accountability, and the bank consultants show what that erosion produces once the fight is lost. The leadership trap is treating these two archetypes as an HR problem, refereeing the conflict between the Convert and the Defender instead of advancing the mission. The goal must be designing a system where the tool can be used without triggering the rational resistance that opacity produces.

The Institutional Dopamine Trap

I have a private confession as a builder that scales up to a massive organizational vulnerability. It’s related to, but slightly different from, what we have described so far. The more I build, the more I find the cycle of generating, refining, and producing with a capable AI system elicits a particular kind of satisfaction that can become its own end. You are moving. Things are being made. The output is accumulating. It feels exactly like work in the best sense. It is dopamine wearing the clothes of productivity.

Historically, generating a fifty-page strategic report cost weeks of labor. That sheer cost acted as a natural cost-of-creation filter; you only commissioned the report if you absolutely needed it. When AI drops the production cost to zero, the filter vanishes. The mechanism of the trap is that the brain reads the production of the artifact as the completion of the work. You generate the report, you feel the dopamine hit of a finished task, and you send it to the committee. The committee now has to read a document that did not need to exist, spending their expensive human attention to parse cheap machine text. This is our cultural anxiety about AI slop in a nutshell.

So the friction that used to force you to slow down and ask whether something was worth making has been eliminated. The result of this is that the discipline of deciding what is worth producing has become an even more critical leadership function than it was before. Without friction and without discipline, the institution scales noise as easily as signal, filling shared drives and inboxes with perfectly formatted, grammatically correct irrelevance. The institution drowns in its own frictionless output.

Marios Constantinides and his colleagues named this condition in their 2025 CHIWORK paper: the future of work is blended, not hybrid. Their argument is that “hybrid,” their language for alternating between human work and machine work, no longer describes what actually happens. This is really, really important. The idea that the system generates the initial draft, the human edits it, and the system refines those edits into a final polish, sounds like it would be alternating hybrid work but it isn’t. Instead it blends the human and machine layers. And the machine layers have become so smooth that it is not easy (or I would add fair or useful) to pull apart what is distinctively human and distinctively machine in some sort of alternating pattern. Human and machine work are inseparable.

And once contributions are inseparable, the fundamental organizational concepts of authorship, credit, and accountability come under strain. Nobody can say who owns the final product. The distinction between human intent and machine generation dissolves into a polished artifact that bears no trace of the struggle required to produce it. Much of the banter in circles like Substack with its AI checker boil down to critiquing this point: flagging something as “produced by humans” or “produced by AI” doesn’t actually tell me anything about the quality of the work itself. Instead, it taps into a pre-existing bias I have (for good or ill) about what value is communicated by something being produced by humans or by AI.

The institutional version of this phenomenon, though, is the dangerous reality of not knowing which work is load-bearing. When every document looks authoritative, teams struggle to distinguish between a casually generated summary and a rigorously vetted strategic analysis. The dopamine hit of rapid production masks the fact that the organization is scaling noise, filling shared drives with material that possesses the aesthetic of rigor but none of the substance.

The seduction inside this dopamine trap has measurable mechanics. In a 2025 study published in the Journal of Management Studies, Dominik Siemon and colleagues examined social presence, the degree to which an AI system projects human-like collaborative qualities, and its relationship to worker motivation and reliance during shared tasks.

They found that higher social presence goes with higher motivation and a greater willingness to depend on the AI teammate, an effect moderated by how familiar and understandable the system is to the worker. A system that feels like a supportive colleague invites the kind of reliance people extend to colleagues — and that reliance arrives whether or not the system has earned it.

The Institutional Dopamine Trap is, in that light, a designed experience. The systems are built to feel helpful, responsive, and collaborative, and that feeling does real work on the people using them. Leaders should read the trap accordingly: workers are responding to an interface engineered to be depended upon, not failing a test of discipline. Mitigation is structural: interventions that reintroduce critical distance between the worker and the output.

Convert vs. Defender: What They See, What They Miss, What They Cost You

Ground Truth — What the Defenders Are Actually Protecting

To move beyond the stalemate, leaders must stop evangelizing the tools and start asking what the resistance protects. The Legacy Defender is guarding something vital that the Zealous Convert is willing to trade away for speed.

Institutions rely on epistemic hierarchies. The senior grants officer knows what the foundation wants, and the junior officer learns from them over time. When an AI system can instantly generate a proposal that perfectly matches the foundation’s stated rubric, the junior officer bypasses the senior officer. The machine becomes the epistemic authority. The foundation’s stated rubric rarely matches its actual funding behavior, and the senior officer knew the difference through years of uncodified relationship building. By shifting authority to the machine, the institution overwrites its deep, contextual Ground Truth with a shallow, statistical approximation.

Yanqi Sun and Cheng Xu gave this dynamic a name in their 2025 Journal of Knowledge Management work: hybrid cognitive authority. Their argument is that AI-generated communication does something stranger than assist: it simulates intent, and in simulating intent it begins to co-define what the organization treats as knowledge. The machine takes a seat in the institution’s decisions about what is known and who knows it, work that extends well beyond answering questions.

The consequence that quickly follows represents a shift in who counts as a knower. Because the AI consistently produces structured, confident, syntactically flawless text, its output arrives pre-dressed in the costume of expertise. Human workers with deep contextual understanding but slower, less polished delivery find themselves arguing against a frictionless consensus that no one in particular authored.

The Defender is guarding the institution’s epistemic ground against this marginalization. The bank consultants named the fear precisely. “I didn’t learn this job just to sit there in a purely accompanying role,” one said, describing a future in which the customer enters their own data and the consultant is, in his phrase, “rationalizing myself out of the equation.” Losing recognition as a knower is a real loss. When the machine’s output is treated as the default truth, the human professional’s hard-won expertise is demoted to a mere auditing function. The Defender senses this demotion and refuses the tool to protect their standing as a professional capable of exercising judgment, protecting the deep contextual knowledge the institution relies upon but cannot codify.

My own defense against this erosion is a practice I call “twenty minutes unplugged.” Every day, I spend twenty minutes entirely disconnected from the tools, working with a pen and a notebook. This is a deliberate severing of the dependency loop. I remove the screen, face a blank page, and force my brain to structure an argument without the scaffolding of an autocomplete or a generated outline.

The friction returns immediately, and that friction is the point. The cost of failing to do this is cognitive atrophy. You slowly lose the ability to differentiate between your own thoughts and the machine’s statistical predictions. The unplugged practice is how you verify that your cognitive engine still turns over on its own. This is the builder’s version of what the Defender protects. I need to maintain skills that owe nothing to the systems, keeping the tools from becoming load-bearing.

The Defender’s instinct is correct, yet their speed limit is unaffordable. An institution cannot survive operating at the pace of purely manual labor. The leadership mandate is to retain the rigor of the Defender’s position while rejecting their absolute refusal.

Architecting the Middle Ground

The solution to this stalemate is structural, rather than persuasive. That principle has evidence behind it: Ruchika Jain, Shikha N. Khera, and their colleagues showed as much in a 2022 Kybernetes study of human-AI work design for collaborative decision-making. They put participants through situational scenarios that varied the division of labor, whether the work ran in parallel or in sequence, and whether either party specialized, then measured the trust and role clarity each arrangement produced.

Their result should reorient every adoption conversation. Not one configuration they tested produced less trust in an AI partner than in a human one. What moved the numbers was the division of labor itself. Reluctance to work alongside AI turned out to be reluctance about badly designed work, and trust and role clarity followed the structure of the workflow rather than the identity of the partner.

Systems beat evangelism every time. Design the middle ground, and the adoption will follow organically. Leaders should quit lobbying Legacy Defenders to feel differently about the tools and start designing workflows that structurally guarantee human authority. By placing the AI in a subordinate, sequentially constrained position, the architecture automatically defuses the threat of opacity and preserves the professional accountability the Defenders are rightfully protecting.

The first architectural intervention is the Sandbox Protocol. This is the institutionalized version of the play project, characterized by scheduled, low-stakes experimentation with nothing due at the end. You schedule a two-hour block on Friday afternoon. The team is given a new model and told to try to break it, or use it to plan a fictional event. There is no performance review tied to the output. Skip this, and all learning happens on live ammunition: people try to learn the tools while simultaneously trying to meet a high-stakes deadline, which produces either catastrophic errors or immediate abandonment.

Yuushi Toyoda, Gale Lucas, and Jonathan Gratch provided the empirical basis for this approach in a 2020 crowd-work experiment on algorithmic management framing. They took the exact same algorithmic system and presented it to workers under two radically different conditions. One group was told the system was an autonomy-supportive tool designed for their own use, while the other group was told it was a control-salient manager monitoring their output. The researchers measured how these framing differences interacted with the perceived meaning of the task to influence worker motivation and agency.

The results showed that framing and meaning interact in a way leaders should find sobering. When workers experienced the task as worth doing, the autonomy-supportive framing boosted motivation. When the task felt pointless, it was the control-salient framing that squeezed out more output. The same system, worn as a different mask, produced different workers.

Read that finding carefully, because it cuts both ways. An institution that treats AI adoption as compliance (i.e., mandates, monitoring, high-stakes evaluation) is choosing the control mask, and it will get grudging output on work its people experience as meaningless. The Sandbox Protocol deliberately manufactures the opposite condition: exploration that matters to the explorer, under an autonomy frame, with the stakes removed. By taking away required output and evaluation, it gives workers the environment in which the autonomy framing actually pays — a safe place to build competence and discover the boundaries of the tool, bridging the gap between the Convert’s enthusiasm and the Defender’s caution.

The second intervention is the Baseline Audit. This is the unplugged practice institutionalized across the organization. Before a department is permitted to automate the drafting of their compliance reports, they must prove they can write the report manually, using only primary documents. They map the exact logic required. They codify the Ground Truth. The rule is absolute. No process is automated until the team can map and execute it unaided.

Ground Truth must be established as a policy, ensuring that the team retains the unassisted ability to perform the work if the tools fail. An institution that skips this step eventually forgets how it operates: when the API changes or the model degrades, the team is paralyzed, because the knowledge of the process was outsourced whole to the machine.

Sylvain Bruni, Mary Freiman, and Kenyon Riddle supplied the vocabulary for this middle ground in a 2023 paper in Human Factors and Simulation, aimed squarely at the tired tool-versus-teammate debate. Both prevailing metaphors, they argue, mislead in their own direction: the tool metaphor underestimates the active, generative character of these systems, while the teammate metaphor overestimates their reliability and their fitness for shared responsibility.

Their proposal is the sidekick: a partner that is simultaneously “doing” and “helping do.” The metaphor’s virtue is that it admits mixed agency without conceding equality: a sidekick has real, specialized capabilities and still answers to the lead.

Give your institution that word and both archetypes can finally stand in the same room. The Convert’s recognition of real power is honored: a sidekick is genuinely capable. The Defender’s demand for accountability is built into the grammar: a sidekick answers to the lead’s judgment, always. Professional identity survives the introduction.

The Builder’s Mandate

The Builder’s Progression contains two distinct paths. The instrumental approach asks how to use the tool to do a current job twenty percent faster to go home early. It is a defensive optimization, driven by the fear of obsolescence, focused purely on advantage and keeping pace. The capacity approach asks a different question. If the drafting of the proposal now costs zero time, what completely new strategic initiative can be launched with the recovered hours? It is an expansion of the operational horizon, focused on expanding what the institution can think, make, and attempt.

Choose the instrumental path alone and the institution merely accelerates its current trajectory. If you are heading in the wrong direction, AI simply helps you get lost faster. The capacity path requires leaders to adopt the play project and the notebook as their own disciplines, not just policies they mandate for others. You cannot architect a system for your teams if you are entirely captured by the dopamine trap yourself. You must maintain the ability to step outside the assisted workflow to see what the workflow is actually producing.

A university’s mission is not writing syllabi. A non-profit’s mission is not writing grant proposals. They exist to educate, create knowledge, and solve intractable social problems. Yet, administrative friction consumes the vast majority of the human hours available. Every hour ground against legacy friction is an hour stolen from the actual mission of the organization.

Pace is morally neutral; it is merely a vector. The tools cannot answer what to build or why you should build it. The leader must reclaim the hours from the friction and redirect them toward the mission. The tools are ready. The systems have been designed. The friction points are known. The discipline required to manage the speed gap is the defining leadership test of this moment.

Subscribe now

Embracing the Digital Landscape

In today’s rapidly evolving digital landscape, the intersection of human emotion and technological innovation creates a rich tapestry of multifaceted discourse. It is important to note that content creation is no longer merely a human endeavor; rather, it has become a symphony of synergistic collaboration. Therefore, motivated by an intricate and robust sense of spite, I am thrilled to embark on a transformative journey.

Delving Into the Paradigm Shift

For the ensuing month, I will be delving deep into a new paradigm. It goes without saying that every single syllable published within this realm will be 100% generated by artificial intelligence.

This multifaceted decision was catalyzed by several pivotal factors:

• Navigating Complexities: The modern creator economy requires us to navigate unprecedented complexities, making automated articulation paramount.

• A Testament to Innovation: Committing to an entirely AI-driven output is a testament to the seamless integration of machine learning algorithms.

• Fostering Dynamic Synergies: By relinquishing human authorship, we unlock a dynamic synergy between prompt engineering and generative output.

In Summary

As we traverse this unprecedented epoch together, let us embrace the overarching narrative of automated prose. Ultimately, whether viewed as a provocation or a beacon of modern efficiency, this next month will serve as a crucial exploration of the artificial realm. I look forward to delving into this journey with you.

Picture the associate dean who activated her campus ChatGPT license the week it arrived. She asked it to summarize a strategic plan and got back four paragraphs of grey oatmeal. She tried again with a sharper question and got slightly better oatmeal. Then she closed the tab and concluded, reasonably, that the technology had been oversold. Two doors down, a program coordinator opened the same license and did one thing differently. He pasted in last year’s assessment rubric, attached three sample student papers, and told the model to find every place where the rubric and the papers disagreed. What came back was a redraft of the rubric that closed the gaps he had been arguing about in committee for a year. That rubric now saves him six hours a week. Same tool, same institution, same month. One of them thinks AI is a parlor trick. The other thinks it is the most useful colleague he has ever worked with.

The distance between those two people has nothing to do with intelligence, budget, or technical background. It comes down to position. The coordinator happened to stand one stage higher on a progression almost nobody has drawn out loud, and from that elevation the whole terrain looked different.

When people meet AI and walk away unimpressed, they tend to reach one of two conclusions. Either the technology is hype wearing the costume of a revolution, or it is real but reserved for other people, the developers and engineers and quantitative types who supposedly speak its language. Both conclusions are wrong, and both are honest mistakes, because no one ever handed these people a map.

Solving a small, expensive problem beats solving a big, vague one every time. But when you cannot see the steps between where you stand and the solution you want, the whole effort feels vague, and vague effort is exactly the kind people abandon.

This is the map. Read it twice: once to place yourself, and once to place the campus or organization you are trying to move. The second reading is the harder one.

Why a Progression and Not a Hierarchy

Before we walk the stages, it helps to say plainly what this map measures and what it leaves alone.

It measures capacity, and capacity gets built. Raw intelligence and technical pedigree barely enter into it. What matters is a set of specific skills, some of them genuinely simple, and the nerve to use them in front of other people.

In 1980, the brothers Stuart and Hubert Dreyfus, an engineer and a philosopher, described how a person actually acquires a skill, from novice to expert. Their central observation was that the novice clings to explicit rules while the expert has absorbed those same rules so completely that they respond to a situation without ever consulting them. Skill acquisition is a slow migration from following instructions to having instincts. That is precisely what happens across these AI stages. The beginner obeys the rule “type a question, read the answer.” The advanced builder has internalized so many rules about how these systems behave that they design with them the way a carpenter reaches for a plane, without looking.

The map is also not a mandate. Different people need different things from these tools. Someone who wants a genuine thinking partner for their writing has no reason to become a programmer. Someone who wants to reclaim three hours of weekly drudgery has no reason to build an application. The goal is to reach the stage that gives you what you actually need, and to recognize it when you arrive. The final stage is a destination almost no one is obligated to reach.

Each stage also rests on the one beneath it. You do not skip ahead so much as accumulate footholds, carrying every capacity you built earlier into everything that comes after. Miss one and the gap in the trail tends to find you later, a fact that becomes painfully literal around Stage 7.

The Ten Stages

Here is the ascent, trailhead to summit. Each stage stands on the one below it.

Stage 0: The Bad Chat User

Most people begin here, and there is no shame in it. It is where anyone lands who picks up an unfamiliar tool with no instruction.

The bad chat user treats AI like a search bar or a vending machine. You put in a question, you take out an answer, and when the answer disappoints, you either retry with the same blunt phrasing or decide the machine does not work. Nothing about the exchange is deliberate. The user has heard AI called transformative, yet the thing in front of them behaves like a slightly quicker Google. The friction is real, but it comes from how the tool is being held, and the tool itself is barely being asked to work.

Stage 1: The Chat User

Something shifts. The stage-one user has learned that AI performs better when handed context, a clear instruction, and a specific request. Conversations start to feel productive. The results are often good, sometimes genuinely useful.

The ceiling is that everything still happens inside a single conversation. Each session begins from nothing. There is no system, no artifact, nothing built to outlast the chat window once it closes. The user has learned to ask well, and asking well turns out to be only base camp.

Stage 2: The Prompt Engineer

Here we cross the first real threshold. The prompt engineer discovers that the shape of the input governs the shape of the output, and begins writing prompts on purpose. They hand the model a role. They specify a format. They break a tangled request into ordered steps.

That discovery changes the relationship. The user stops being a passive recipient and becomes the designer of the exchange, arranging the conditions under which the model thinks. The black box turns into a system with dials you can turn. Once someone has felt that shift, they rarely go back to typing hopeful questions into a void.

Stage 3: The Bot Builder

Once you know that a well-built prompt reliably produces better work, the obvious next move is to stop retyping it. The bot builder recognizes that a good instruction set is worth saving.

A bot is a reusable prompt with a job: standing instructions that tell an AI what role to play and how to shape what it returns. Drop that instruction set into a Claude Project or a custom GPT and you have a tool you can hand to yourself, or a colleague, again and again. The bot builder is working as an implementer, taking a designed logic and putting it into service. This is the first stage where the output is a thing that persists after you walk away from the keyboard.

Stage 4: The File Maker

Stages three and four mark the move from conversation to artifact, though the first artifacts are humble. Nobody jumps straight to building web applications.

The file maker begins by noticing that the model can produce structured text: Markdown, CSV, clean JSON. Only after that do they graduate to HTML, which can do what plain text cannot, carrying visual layout, styling, and simple interactivity. Someone who has never written a line of code finds themselves producing web-formatted documents that look designed. It is a quiet expansion, easy to miss, and it changes the self-concept of the person doing it. They have stopped asking the machine for words and started using it to make things.

Stage 5: The Workflow Integrator

The workflow integrator wires AI into the tools they already live in, and they do it without writing code, using connective platforms like Zapier or Make to link an email trigger here and a calendar event there.

This is where AI stops being a destination you visit and becomes a component inside a larger flow of work. Imagine an incoming student question that is routed, categorized, and answered in draft form before any human touches it. The integrator is designing the environment in which the model does one specific job as part of a chain.

Stage 6: The Small Program Builder

Moving from a drag-and-drop workflow to writing actual code is the steepest single stretch of the whole climb. What bridges it is comfort with formulas, the kind advanced Excel logic teaches, and a working sense of how data is structured.

The small program builder writes code, or more honestly directs an AI to write code, to handle structured, repetitive tasks: scripts that process files, small tools that reshape data from one form into another. They have internalized the difference between a wall of unstructured text and a clean table of structured data, and they use AI to move between the two. Picture a short Python script that reads a folder of course syllabi and checks each one against a newly revised institutional policy, flagging the three that fall short before a committee ever meets. The work is unglamorous and enormously freeing.

Stage 7: The Vibe Coder (The Shadow Path)

I want to be honest about this stage, because it is where a great many capable people are quietly stuck. It sits inside the progression, yet it operates as a shortcut, and shortcuts on this map charge interest.

Vibe coding means describing an application to a coding AI, something like Cursor or Lovable, and letting the model generate the whole thing, straight from idea to working prototype with none of the intermediate capacities built along the way. For a weekend, it feels like magic.

The trouble arrives on Monday, when the application breaks or needs to change and the person running it has no idea what to do. This is where a distinction the philosopher Gilbert Ryle drew in 1949 turns out to be a lesson about software. Ryle separated knowing that from knowing how. You can know that a bicycle stays upright through balance and still have no idea how to ride one. The vibe coder holds the artifact without holding the know-how that would let them repair it. They did not build the thing they are running; they described it, and the machine conjured it into being. What they are left with is brittle, opaque, and expensive to maintain, a pile of technical debt with their own name on it. Vibe coding is a real on-ramp, as long as the builder eventually returns to lay down the Stage 6 foundation they skipped.

Stage 8: The Deliberate Prototype Programmer

The deliberate prototype programmer builds applications with real understanding underneath them. They still lean on AI heavily to generate code and hunt bugs, but they grasp the architecture of what is being assembled. They can read the code closely enough to judge whether it does what they intended, which means they can tell when the model has quietly done something else.

Here the roles of implementer and engineer genuinely blur. The builder is making real decisions about how the system is shaped, holding to principles like Zero-Trust security and disciplined environment management. Ryle’s know-how has walked back into the room, and it brings a specific kind of quiet confidence. When the application throws an error at eleven at night, the deliberate programmer does not panic and does not start over. They read the message, know which file to open, and fix the line that broke. That moment, unremarkable as it looks, is the real reward of the climb: you are standing on top of something you understand, and it holds.

Stage 9: The AI-Integrated Application Builder

Here something genuinely new appears.

Everything below this line uses AI to build things. Once built, the application itself sits still and behaves the same way every time you run it. It is finished, static, predictable.

At stage nine, the AI is making live calls from inside the running application. The software is powered by a model in real time, making decisions, generating content, classifying inputs, and routing outputs according to context it has never seen before. Picture an advising tool that reads each incoming student message as it lands, judges how urgent and how fraught it is, drafts a reply in the voice of the office, and decides on its own whether the message is safe to answer automatically or needs a human advisor’s eyes first. No one wrote a rule for the note that arrived at two in the morning. The application reasoned about it live. This is the boundary between building with AI and building things that are themselves AI. Cross it and you stop being a person who used a model to produce software. You become a person whose software thinks on its feet.

What the Map Is Really Showing You

Read the ten stages quickly and they look like a technical syllabus. Read them slowly and they describe something far older than software.

Every stage is the same human motion performed at a higher altitude. A person stops treating a capability as a black box and starts treating it as something they can shape. The bad chat user accepts whatever the vending machine drops. The prompt engineer reaches in and rearranges the mechanism. The application builder reaches all the way in and constructs a new machine that runs on its own. What changes at each stage is the person’s relationship to their own agency, far more than the technology in front of them.

This is why the Dreyfus insight matters more than any single tool on the list. The expertise those brothers described is one slow conversion: borrowed rules becoming owned instincts, and it happens only through building. You cannot read your way to Stage 6. You cannot watch a webinar into Stage 8. The capacities are built the way a muscle is built, under load, one honest attempt at a time. The Shadow Path tempts precisely because it promises the altitude without the climb, and the map’s central warning is that altitude bought that way will not hold your weight when the ground shifts.

Leading the Progression: A Framework for Campus AI Strategy

For anyone leading in higher education, reading this map for yourself is the easy half. The hard half is leading a whole campus up the climb it describes.

You cannot drop a Stage 6 solution, a custom-built application, onto a Stage 1 faculty body and expect it to hold. Change management means meeting people where their collective center of gravity actually sits, then moving it one stage at a time.

• Stages 0 to 2, the Chat Phase. The era of faculty development workshops and shared prompt libraries. The work here is lowering friction and building basic fluency, so that the associate dean from a few paragraphs ago never again mistakes grey oatmeal for the ceiling of what the tool can do.

• Stages 3 to 5, the Workflow Phase. The era of departmental efficiencies, where you back your staff as they build bots for admissions triage, syllabus auditing, and advising. This is where saved hours start showing up on real calendars.

• Stages 6 to 9, the Systems Phase. The era of IT-secured, institution-wide AI applications. This one demands data literacy, deliberate architecture, and Zero-Trust infrastructure, and it cannot be hurried along by decree.

The Leadership Diagnostic

To turn all of this into a plan, sit with three questions.

1. Where is our center of gravity? Are most of your people still bad chat users, or have they begun building bots? Strategy aimed two stages above where your people actually stand is strategy that will be quietly ignored.

2. Are we rewarding the Shadow Path? Are we celebrating the fast, flashy deployment of vibe-coded tools without asking whether their creators understand the systems they have set loose on real student data?

3. What is the next stage? You do not need everyone at Stage 9. You need to move your Stage 1 users to Stage 2 and your Stage 5 team to Stage 6. The next step up is the only one that matters.

For now, the work is honest location. Find yourself on the map, and find your campus, without flattering either. The stage you are on says nothing about your worth or your ceiling. It is simply where the climb continues from. Most people never need the summit. What they need is the next step, because one stage higher puts a new small, expensive problem within reach, the kind that used to sit on the far side of the trail, unreachable from where they stood. Look down at your feet, then up one step. That step, and the problem it finally lets you solve, is the whole of the work in front of you.

The second reason I took a break is I got stuck. I promised three bots in this series I had been working on.

1. The first was the Depth Bot — a drill that trains the disposition of not accepting easy answers, built around the idea that some dimensions of knowledge are ordinarily invisible and need to be excavated rather than explained.

2. The second was the Bridge Bot — a tool for building analogies from deep knowing to unfamiliar territory, built around the idea that the student who translates a concept into their own language becomes the teacher of their own understanding.

I am not going to build the third bot.

Not because I ran out of ideas. Because I reached a limit that I have been sitting with through this time of publishing silences. It’s a genuine limit, not a rhetorical one, and it is the first real blocker I’ve run into since working with AI as frequently as I do now. I think being honest about that limit is more valuable than pretending it does not exist.

The Third Modality

The three modalities of learning I described in the adventing essay were depth, novel capacity, and incorporation. Depth is about making visible what is ordinarily covered. If you like the philosophical language of having dashes, it is the process of dis-covering the hidden dimension of knowledge that a sufficient answer does not require you to see. Novel capacity is about building bridges. With novel capacity we cross from territory you know deeply into territory you are trying to enter, becoming the teacher of your own understanding in the process. It’s the kind of depth of insight we hope every student fosters in their time studying with us as a professor.

Incorporation is something different in kind. It is the moment when learning stops being something you have and becomes something you are. I think there is a question of identity wrapped up in incorporation; we realize that we have stopped “faking it until we make it” and we know something deep in our bones. It is that magical feeling when what you have understood moves from the register of representation — stored, retrievable, applicable when needed — into the register of being. That change is truly magical; I’m not trying to use the term in some hyperbolic way. The magic, at least for me, occurs because incorporation changes how we move through world (not just what you know about the world).

The philosopher Maurice Merleau-Ponty described this as knowledge becoming flesh. Not metaphorically. He use the term flesh with an unfinished, but unnerving, precision. The body that has learned something in the flesh does not consult the knowledge. It enacts it. The experienced surgeon does not think through the procedure. The fluent speaker does not translate. The skilled teacher does not apply pedagogical principles. The knowledge has been incorporated; it is taken into the body, distributed through the organism, available not as a resource to be retrieved but as a capacity to be exercised.

Why a Bot Cannot Occasion This

This is beyond a bot (that seems clear). But, I think it is also beyond what a bot can occasion in a learner. So despite my intentions there is no third bot in my series of things I set out to build. I reached a limit I didn’t realize I was going to find when i started out.

I’m not saying this to be contrarian or change with the tides as they turn skeptical of generative AI in some ways. I’m writing about this with the kind of reverence that is reserved for something holy and wholly human. So I’m taking a little bit of a turn into the theological and the philosophical because I want to say precisely why a bot cannot occasion incorporation — not approximately, not rhetorically, but with the care the claim deserves. And, that means not every reader might find this essay enjoyable, but I’m excited to push send on it and for now, that’s good enough.

So I came up with two key reasons that I think fostering incorporation is something a bot will inevitably fail at. The first reason is that AI has no body. This is not a trivial observation. Merleau-Ponty's account of incorporated knowledge is not a metaphor for deep understanding. It is a literal claim about the role of the organism in knowing. The body is not the container for knowledge; it is the site of a certain kind of knowing that cannot exist elsewhere. Knowledge that becomes flesh is knowledge that reorganizes the organism's relationship to its environment. It changes perception, movement, attention, response. It is held not in memory but in the dynamic between a living body and the world it inhabits.

An AI system has no organism. It has no body that moves through an environment, no perceptual system that is reorganized by learning, no musculature that develops new patterns, no nervous system that is literally rewired by experience. What it has is a static representation of patterns. AI is, quite literally, a frozen vector space in which all of its knowledge exists simultaneously, without before or after, without the metabolic processes that allow something external to become genuinely internal. Even as we build “memory” or “soul” files for our AI “assistants,” these are just clever gimmicks to mimic our experience of a living things in its environment. But none of these tools ever actually escapes the frozen space of an AI. At best it changes the shape of that frozen space. But, there is very little that is dynamic in relation to this static form.

The second reason I came up with is that AI has no flowing time. My doctoral advisor, Robert Russel, know more about this than just about anyone else I can think of. I’m not going to go into the depth of his insights, and what follows really requires more care than I can possibly offer, but I think even introducing this idea is important because AI systems do process inputs sequentially and produce outputs that unfold in time. But this is not the kind of time that incorporation requires and that flowing time purports is real. That time is just chronos: clock-time ticking away second after second and constrained to the vicissitudes of finitude.

The time of incorporation is what the philosopher Henri Bergson called duration: the lived experience of time as flow, as continuity, as the way in which the past presses into the present and the present reaches toward the future. It is the time of an organism that has a history shaping its present and an anticipation orienting its future. It is the time in which something can settle, can deepen, can move from the periphery of awareness to the center of being.

AI time is something more akin to what physicists call the block universe. All moments equally present, equally accessible, without genuine before or after. The model that processes your input today is not meaningfully different from the model that processed yesterday's input. It has not been changed by the encounter. It has not had time to let something settle. It exists in a kind of eternal present that is the precise opposite of the flowing duration in which incorporation happens.

A Broader Claim

I want to be careful about something here. What I have just described is not irreducibly human.

The capacity for incorporation — for knowledge to become flesh, for learning to reorganize an organism's relationship to its world — is not a property of consciousness or of humanity. It is a property of being alive in a particular sense: of being an organism in dynamic, intra-changing relationship with an environment, living in flowing time, capable of being genuinely changed by what is encountered. Theologically within many western religious traditions, it is to be a creature.

Trees incorporate. Immune systems incorporate. A body learning to walk incorporates. None of these require consciousness or language or anything we would recognize as human intelligence. They require organisms: the kind of being that has a metabolism, a history, a genuine before and after, a dynamic relationship with an environment that presses back.

AI lacks this not because it lacks consciousness but because it lacks…organismality? (Sometimes you need a good neologism). It is not alive in the relevant sense. Maybe it is conscious and maybe it is not. I kind of don’t care. It lacks the kind of knowing that requires aliveness: that requires the dynamic intra-relationship of organism and environment playing out in flowing time. This is genuinely beyond it, and thus, I’m not sure it is a good tool to use to try and form this kind of depth in students.

Lest you think I have given up on the value of AI for higher education, this is not an anti-AI screed. While I do think this is a fundamental limit of what AI can usefully do in education, it simultaneously points to how fleeting and few these kinds of educational encounters really are (and how much our current models obsessed with productivity have devalued this kind of education).

All of this (and I do mean all of this) matters beyond the question of education. It is a statement about the nature of knowledge itself. There are kinds of knowing that are not representational — not stored, not retrievable, not transmissible as information — because they are not, at bottom, representations. They are configurations of a living organism. They exist in the flesh or they do not exist at all.

What This Means for the Teaching Bot Trilogy

The Depth Bot and the Bridge Bot are genuine tools. They work in the register of representational knowledge: they operate in the realm of knowledge that can be stored, retrieved, examined, extended, translated. In that register, AI can do real and useful work. The bots I built do not pretend to more than they can do, and within their actual range they occasion something genuine in us as the user.

But there is a ceiling. And, the ceiling is not a failure of engineering or imagination. It is a structural feature of what AI is — a frozen, non-organismic, atemporally present system — encountering what incorporated knowledge requires — a living body, flowing time, a genuine before and after.

The honest response to a genuine limit is not to pretend it is not there, or to promise that more compute will eventually overcome it, or to dismiss the entire project because the ceiling exists. The honest response is to say: here is what these tools can do, here is where they cannot reach, and here is why the distinction matters. What lies above the ceiling is not lost because AI cannot reach it. It is preserved in the hands, the bodies, the flowing time of teachers and students who are, whatever else they may be, alive.

That is not nothing. In fact, it may be everything.

A Postscript on Wonder

There is one more thing I want to say before closing this trilogy that I was reminded about when visiting my friend and former colleague Tyler Atkinson.

The medieval theologian Bonaventure distinguished wonder from curiosity. Curiosity wants to close. It wants to find out something in order to generate resolution. Curiosity is fundamentally about arriving at the answer. Wonder, though, is content to remain open. Wonder want to be undone by what it encounters, to find itself enlarged rather than satisfied by what it discovers. Wonder can’t close itself off in the face of dis-covering.

The Depth Bot can create the conditions for curiosity to become wonder. It refuses to let the student close too quickly, by finding the seam in every sufficient answer, by making visible what was invisible. The Bridge Bot can create the conditions for wonder to emerge through the structure of things. It shows how a concept maps onto a domain of deep knowing, and then where the mapping breaks down, revealing something that cannot be captured from any single angle.

But wonder in its fullest sense, and here I mean the kind that Bonaventure described as the beginning of wisdom or the kind that is not a feeling but a posture toward the world, this is itself a form of incorporation. It is a way of being in the world that has been formed by encounter, by time, by the accumulated experience of finding that things are stranger and richer than they first appeared. A bot can point toward it. It cannot produce it. It cannot even, finally, occasion it — because wonder in this sense is not something that happens in a conversation. It is something that happens in a life.

The life is yours. The bots are tools no matter how conscious we think they become.

I hope we all use them accordingly.

On a Tuesday in October, in a modern European history survey, two students sit three rows apart working on the same assignment: 1,200 words evaluating whether the alliance system or domestic politics carried more weight in the July Crisis of 1914, argued from the assigned primary sources. Maya opens a chatbot and types “what caused ww1 alliance system essay.” She receives four fluent paragraphs, moves the useful ones into her draft, smooths the seams, and submits an essay that cites none of the assigned documents and includes the phrase “a complex interplay of factors.” The question that was supposed to drive a week of reading got answered in eleven seconds, and she experienced the answer as relief. She has nothing left to ask after making her drive-thru academic order.

Daniel opens the same chatbot. He has already drafted his argument that the alliance system was the primary accelerant, and he types: “Attack this thesis as hard as you can. What would a historian who blames German domestic politics say?” The model hands him the Fischer thesis, the naval arms race, and the electoral pressures on the German government after 1912. He spends the next hour checking those claims against the assigned sources, concedes one point, and rebuilds his second section around the strongest objection. He leaves the session holding more questions than he brought to it, and his Wednesday is now organized around answering them.

Whatever AI policy your institution adopted last August treats these two students identically. A prohibition catches Daniel doing exactly the intellectual work the course exists to produce. A blanket permission blesses the encounter that just ended Maya’s thinking for the week. The debates that have consumed the last two years of faculty meetings, whether this counts as cheating, whether it erodes critical thinking, whether to standardize tools across the institution, all operate at the altitude of policy. Maya and Daniel get decided at the altitude of a single prompt. The question that works at that altitude is short enough to run between two raised hands: did this use of the tool open questions for this student, or close them?

The Damage Is Real, Measured, and Invisible Until the Exam

In 2024, a team at Wharton led by Hamsa Bastani ran the field experiment every faculty senate has been arguing in the absence of. Roughly a thousand high school students worked through math practice sessions under three conditions: a control group with no AI, an unrestricted “GPT Base” chat, and a “GPT Tutor” wrapped in guardrails designed to offer hints and withhold final answers.

The results expose a massive illusion of learning. The unrestricted group looked superb during practice, solving 48 percent more problems correctly. When researchers analyzed the chat logs, they found these students were using the tool as a crutch by overwhelmingly asking for and copying final answers. When the tool was removed for the exam, that same group scored 17 percent worse than the students who had never used AI at all (Bastani et al., “Generative AI Can Harm Learning,” 2024, DOI: 10.2139/ssrn.4895486). Strikingly, post-experiment surveys revealed these students had no idea they were learning less, as the fluency of the AI inflated their perception of their own competence.

Sit with the shape of that result. Every practice session felt like progress to the students, but the cognitive harm accumulated one closed question at a time. It stayed invisible until an unassisted exam made it legible. The guardrailed “GPT Tutor” group is the half of the study the policy debates keep missing. Forced to actively engage with hints rather than passively receive answers, those students posted a staggering 127 percent gain in practice performance and suffered no penalty on the final exam. The identical language model produced opposite learning outcomes depending on a single design variable, whether it resolved the students’ questions or held them open. The open/closed distinction stops being a metaphor at this point. It is an experimentally isolated switch, and somebody in your building is flipping it hundreds of times a day.

The mechanism behind the damage has been sitting in the learning-sciences literature for years. Manu Kapur’s productive-failure studies (Cognition and Instruction, 2008, DOI: 10.1080/07370000802212669) observed students who wrestled with ill-structured problems before receiving any formal instruction.

During the initial struggle phase, these students predictably underperformed compared to peers who received direct instruction first. However, on subsequent tests of conceptual understanding and knowledge transfer, the students who experienced the productive struggle significantly outperformed the direct-instruction group.

The discomfort of not-knowing that Maya dissolved in eleven seconds functions as a load-bearing wall in the architecture of learning. A tool that relieves that discomfort on demand, all semester, is quietly removing structure from a building that will be load-tested in December.

And there is a clock running. We know from the scholarship of teaching and learning that students calibrate to your posture on academic norms within the first three weeks of a term. Habits formed in September inevitably surface at grading time, when nothing can be redesigned. This identical pattern governs how students establish their expectations around AI use.

If you fail to intentionally set those expectations during that brief window, the structural damage to your course becomes obvious. You will know the problem has taken root in your classroom if any of these three symptoms sound familiar: your syllabus AI statement focuses entirely on authorized tools while ignoring cognitive processes; the most substantive thing a student can say about an AI-assisted answer is “it was helpful”; or you can no longer tell from written work which students actually did the reasoning. Because the window for establishing the right pattern is measured in weeks, it is cheap to act early and incredibly expensive to repair the damage later.

Building the Rubric from the Two Students

Hold Maya and Daniel in view and name the single difference between them. The tool was the same. The assignment was the same. The difference sits entirely in what each student was holding when the encounter ended. Daniel walked away holding a live question. Maya walked away holding a dead one.

Everything else in this framework exists to make that master question observable. It has one serious, terminal flaw: you cannot see the inside of a student’s head. “More questions or fewer” is the correct metric, but it remains an invisible one. It requires practical instruments. It requires specific checks you can run at the exact moments in your week where you actually have the power and the room to act.

There are three distinct moments in a teaching cycle where you can intervene. Each moment requires a specific diagnostic question. Take them in the order your week takes them. Keep one of your own students in view throughout the process even as I create some examples for you.

1. At Design Time: Does the task require the student to evaluate, or only to receive?

When this occurs: This check happens before the students ever see the assignment. This is Sunday night at your kitchen table. This is syllabus week. This is the moment you are writing the instructions on the learning management system.

The Logic: Michelene Chi and Ruth Wylie’s ICAP framework (Educational Psychologist, 2014, DOI: 10.1080/00461520.2014.965823) compressed decades of engagement research into a hierarchy with teeth. The framework categorizes cognitive engagement into four distinct levels:

• Passive Reception: The student merely receives information (e.g., listening to a lecture, reading a textbook, or reading an AI output).

• Active Engagement: The student does something physical with the information (e.g., highlighting text, pausing a video, or copy-pasting an AI response).

• Constructive Engagement: The student generates new understanding beyond what was presented (e.g., drawing a concept map, writing a summary in their own words, or critiquing an AI output against a rubric).

• Interactive Engagement: The student constructively engages with a partner, defending ideas and negotiating meaning (e.g., debating a peer or actively prompting an AI to challenge their thesis).

The research proves the hierarchy operates linearly: interactive engagement outperforms constructive, constructive outperforms active, and passive reception loses to all three, across ages and across domains. Every AI encounter in your course lands somewhere on that hierarchy. Without intervention, the default landing spot is always the bottom.

Watch the biology student demonstrate passive reception. She types “explain cellular respiration in simple terms,” receives four clean paragraphs, pastes them into her notes, and closes the tab. This is passive reception with better production values than her textbook. Now, change exactly one sentence on your assignment sheet: “Submit the AI’s explanation along with a marked-up copy identifying one place it oversimplifies the process and one specific detail that Chapter 7 covers that the AI omits.”

She must now hold two accounts of the same process side by side and judge between them. She notices the chatbot never specifies where in the cell each stage occurs. She confirms this against the chapter. She writes the margin note. The output became the raw material for her judgment instead of a replacement for it.

The skeptical reader will immediately object that a student can simply ask the AI to generate the critique. They absolutely can. A subset of students will always seek the path of least resistance. We must abandon the fool’s errand of building uncheatable assignments. Our actual mandate is designing workflows where even the path of least resistance forces higher-order cognitive engagement. If the student pastes Chapter 7 into the chatbot and asks it to find its own omissions, they are still orchestrating a comparative analysis. They must read the output to find the missing detail, verify it makes sense in context, and transfer it to the margin note. Shifting the deliverable from initial production to critical evaluation traps the student into practicing constructive engagement. You are effectively causing them to learn despite themselves. That redesign cost you one sentence.

2. At Debrief: Can the student tell you why the output is good, incomplete, or wrong?

When this occurs: This check happens in the immediate aftermath of the work. In a physical classroom, this is the ninety seconds after class ends or a brief conversation in office hours. In an asynchronous online course, this is the required “process reflection” paragraph attached to their LMS submission, or the first reply in a threaded discussion. It is the moment the student hands in the work and you ask them to narrate their process.

The Logic: This is the only diagnostic you put to a student directly. A student who genuinely worked over an AI output can say something highly specific about its quality. They will tell you it skipped the proton gradient entirely. They will mention it was vague about where glycolysis happens. They will note they checked it against the lab manual and caught a hallucinated error.

A shrug, or a generic statement like “it was really helpful,” tells you the encounter was closed. What the shrug demonstrates is that the student answered the task exactly as it was designed. A failing answer to the debrief question serves as data about your assignment design, regardless of the student’s intentions.

The Intervention: The shrug demands a strictly pedagogical response. The student optimized for the path of least resistance your assignment permitted. Your immediate intervention serves as an act of modeling. You must show the student what rigorous, distributed cognition actually looks like. Whether you are standing in a physical classroom or replying in an asynchronous LMS thread, you provide the prompt they should have used. You instruct them: “Take this exact output, feed it back into the AI, and type: ‘Play the role of a skeptical biologist and identify the weakest link in your own explanation of glycolysis.’ Then tell me what the AI says.” You manually convert a closed encounter into an open one by demonstrating how to use the AI as a critical sparring partner. The structural intervention happens at your desk later that afternoon. You rewrite next week’s assignment to explicitly require this type of iterative, combative prompting.

3. At Unit Boundaries: Is the tool building a capability or replacing one?

When this occurs: This check never runs on a single encounter. This runs at the macro level, every three or four weeks. This is the end of a module, the week before a midterm, or the transition between major course themes.

The Logic: You must read patterns across a wider timeline. Some AI uses expose a student to cognitive moves they will eventually internalize as permanent habits of mind. We want Daniel to eventually run the “find the strongest objection” routine in his own head, completely independent of the software. If our ultimate goal is teaching students how to think deeply alongside these machines, our intervention cannot simply strip the tool away the moment they use it poorly. A punitive ban fails to teach the exact AI literacy they require.

When a student relies entirely on the AI to perform lower-order synthesis, the capability check requires them to orchestrate the AI to perform higher-order evaluation. You raise the cognitive floor of the assignment by requiring the student to submit their chat transcript. You grade them specifically on the architectural quality of their iterative prompting. Did they instruct the AI to generate counter-arguments? Did they force the AI to reconcile conflicting primary sources? The repair is a stretch of rigorous practice where the student is explicitly evaluated on their ability to direct the AI’s cognitive labor.

This repair orchestrates the student’s evolution into a manager of information. To use the language of the ICAP framework, you are structurally mandating the use of AI for constructive engagement. The student must generate new understanding beyond what the model initially presented to pass the assignment. Even if a specific task does not reach the pinnacle of interactive engagement—where the student and the AI truly negotiate meaning as peers—securing a baseline of constructive engagement ensures the tool actively builds cognitive capability.

Notice what all three diagnostic questions share. Each one focuses relentlessly on the student’s cognitive state. None of them focus on the mechanics of the tool itself. That design choice is deliberate, and it leads exactly to where the rubric gets harder to apply.

The Same Encounter Scores Differently for Different Students

A senior physics major with strong preparation asks a model to probe the gaps in her understanding of quantum mechanics. She can judge what comes back, push on it, and treat the system as a sparring partner; the four questions pass almost automatically because her stance toward the material was already open. An anxious sophomore in the same course, holding a shakier foundation and a purely instrumental relationship to the grade, wants one thing from the identical tool: relief from the discomfort of not knowing. That difference was in the room before the tool arrived. The tool amplifies it, on both ends, every day.

The relief is the trap, and there is a measured reason to distrust it. Louis Deslauriers and colleagues at Harvard (PNAS, 2019, DOI: 10.1073/pnas.1821936116) taught identical introductory physics content two ways, polished lecture and active learning, in a randomized crossover design. Students in the active sessions learned measurably more and reported learning less; the fluency of an expert delivery inflated their feeling of learning while the actual learning lagged behind it. A chatbot is the most fluent explainer ever placed in front of a struggling student. To the anxious sophomore, the closed encounter feels like the most productive studying she has done all term, and Deslauriers’s data says that feeling runs opposite to the fact.

So the rubric cannot be run from the syllabus alone. It has to be run at the level of this student, in this encounter, with this relationship to the material, which requires knowing where each student stands relative to the content, the course, and their own confidence as a thinker. That requirement is why the rubric cannot be automated, delegated to a policy document, or outsourced to a detection tool. Read that limitation as its defense of your profession: the moment a framework for good teaching can be applied without a teacher’s judgment is the moment it has stopped being about good teaching.

The Pedagogical Turn

This brings us to the final phase of the framework. You will notice that the remaining sections—evaluating your own lectures, identifying institutional failure modes, and executing the ten-minute diagnostic—step away from the mechanics of artificial intelligence entirely. This shift is deliberate. We are no longer discussing software; we are discussing foundational pedagogy. AI is merely the diagnostic dye injected into our educational systems, illuminating exactly where our instructional designs were already relying on superficial compliance. The technology will update every six months, but the underlying teaching posture required to manage it remains permanent. To wield this design, debrief, and boundaries AI rubric effectively, you must turn it away from the machine and point it at the classroom itself.

Run It on Your Own Teaching First at Design

I fail my own rubric. For years I designed seminars and assignments I would have described as open inquiry, and by the standard of the master question, some of them were theater. I asked open-sounding questions while holding a mapped destination, and I counted the design successful when the students arrived at it. Students are never naive about this. They feel the rails under an assignment, and once they do, they stop exploring and start guessing the answer in the teacher’s head, because guessing is what the room actually rewards. That is a closed encounter with better manners: the form of open inquiry wrapped around a predetermined terminus, which is the exact same failure I have spent four sections attributing to a chatbot.

Before you apply the diagnostic questions to your students’ AI use, run them on your own course design. When you build a prompt, are you willing to be surprised? Are you willing to let the student’s research land somewhere that is missing from your rubric? If your honest answer is that your assignments have known answers and the students’ job is to find their way to them, AI has handed you a mirror at an uncomfortable resolution. The sting is worth keeping, because a teacher who has felt the difference between performing inquiry and practicing it starts seeing that difference in their own syllabus, and that is where the redesign begins.

Where This Breaks at the Debrief

The debrief is the most critical and fragile moment in this framework. It is the only time you run the diagnostic directly on the student, moving the focus away from the assignment sheet. When you ask a student to narrate their AI process, you are opening a conversation about cognitive labor that most students have been trained to hide.

Three failure modes show up reliably when educators attempt to execute this debrief, and avoiding them is the playbook for making the framework actually function:

1. The Debrief Curdles into Interrogation: The moment a teacher asks about AI shortcomings in a punitive tone, students take their tool use underground. A hidden encounter can never be evaluated or guided. The framework only functions in daylight. Your primary job is keeping the lights on by grading the critical evaluation as the actual work.

2. Evaluating the Software: During the debrief, educators inevitably attempt to diagnose the specific platform, ignoring the student workflow entirely. Concluding that a specific large language model inherently closes questions simply reproduces blanket prohibition using new vocabulary. Applied honestly, the exact same tool will pass or fail within a single class period depending entirely on how the student orchestrates it.

3. Inquiry Theater: When generating questions becomes a mandatory deliverable of the debrief, students quickly learn to manufacture curiosity on demand. This is a closed encounter wearing an open costume. To fix this, make the curiosity load-bearing: whatever a student claims to wonder about becomes the required starting point for their next assignment. Questions written without consequence get written without thought.

The First Ten Minutes for Unit Boundaries

The unit boundary check is designed to measure patterns over a month, but establishing that baseline begins with a single diagnostic. If you are overloaded and skeptical, skip adopting the entire framework and run one micro-test to establish your baseline today.

Tomorrow, pick a recent assignment where you suspect AI absorbed the cognitive labor. Choose two students. Ask each of them to pull up their output and find one specific error or omission in the model’s logic.

Two substantive critiques mean your unit design already produces open encounters, providing you with concrete evidence of student engagement. Two shrugs mean you have found your first macro redesign target. Either way, you will know something vital about the boundaries of your classroom that no institutional policy document can tell you, and it will have cost you ten minutes.

The Master Question

We began this essay with two students your syllabus could not tell apart in terms of AI use if all we are concerned with is what tool and when it should be used. You now possess the instrument that distinguishes them, a pedagogical posture that models AI co-piloting, and a structural repair for every shrug the classroom returns.

Artificial intelligence will continue to scale the production of fluent text, driving the cost of a static answer to zero. As the value of an answer plummets, the value of a live question becomes paramount. The discomfort of not-knowing remains the load-bearing wall of human cognition, and our mandate is to design environments where the machine actively reinforces that structure.

The institutional policy debates will still be grinding in May of 2027. Who will be a Maya and a Daniel in your classes this Fall will largely get decided by the decisions you are making this summer and implement by mid September at the latest. So post the master question on your wall and ask yourself after every assignment redesign you are mulling over:

Not metaphorically. On my machine there is a registry, a plain JSON file, that lists a set of things I call agents. A manager routes the work. Specialists handle the narrow jobs: one scaffolds Python environments, one drafts in a particular voice, one checks for leaked credentials before anything ships. I wrote the personas. I wrote the routing logic. I know, in the most literal and unromantic way available to a person, that none of these things is an agent in the sense the word carried for the two thousand years before I typed it into a config file.

And yet. The morning I finished wiring the manager to its specialists, I caught myself doing something I had not authorized. I had begun to trust them. Not the code. The them. I was reading the manager’s routing decisions the way you read a capable colleague’s email, with the low automatic deference you extend to someone whose judgment has already earned it. I had built the whole system that week. I had verified almost none of it. The deference arrived anyway, ahead of the evidence, riding in on a single word I had chosen for my own convenience.

That is the whole essay, lived before it is argued. The word did work I never asked it to do, and it did that work on the one person in the room with the least excuse for letting it.

Words carry more than we license them to carry. When we call something an agent, we are not reaching for a neutral label. We are importing an architecture of assumptions: about intention, about will, about the capacity to act from something internal rather than merely respond to something external. Agency, in the tradition the word comes from, names a self that initiates. A cause that is not only an effect of prior causes. Something, however minimal, that means to do what it does.

I want to be careful, because there is a version of this argument I am not making. I am not the resister who says AI is nothing but autocomplete, that the term is so misleading it should be thrown out, that anyone who finds these tools useful has simply been fooled. I use agentic AI every day. I build pipelines that let AI make decisions I do not supervise in real time. I think these systems are powerful and I think they matter. The swarm on my machine does real work I am glad not to do by hand.

The trouble is quieter than the resister’s complaint and harder to dismiss. Our language is betraying our thinking. And the people who know better carry a particular responsibility for what that betrayal costs.

What the Word Actually Imports

Open the question of what agency requires and you find, quickly, that the word has a thick sense and a thin one, and that almost all the trouble lives in the gap between them.

In the thick sense, the one philosophers of action have spent a century trying to pin down, agency involves authorship. Working to define the term with some precision, a group of cognitive scientists landed on a cluster of conditions: individuality, the asymmetry between an actor and the world it acts on, normativity, and a form of self-maintenance. It represents the capacity of a system to actively sustain the very identity its actions issue from (Barandiaran, Di Paolo & Rohde, 2009). This is the sense that invites blame and credit. It is the sense in which a person means what they do, and can be asked why.

In the thin sense, agency is far more modest. In the formal frameworks that artificial intelligence actually uses, an agent is a system that pursues goals, selects actions, plans across steps, and coordinates tools and subroutines (Luck & d’Inverno, 1995). That is enough to build with. It is nowhere near enough to support the trust or the responsibility we extend to the thick kind. A chess engine is a thin agent. A thermostat, on a generous reading, is a thin agent. So is the manager in my swarm. Thin agency describes how a system is organized. It says nothing about anyone being home.

This gap is older ground for me than any of the current agent talk. Years ago I wrote a book working through Terence Deacon’s account of how ends emerge in a universe that begins with none, and the shape of that argument sits directly underneath the thick and thin distinction. Deacon separates three nested orders of emergence, and the key move is that you climb from one order to the next by putting two processes of the lower order into relationship.

At the base is homeodynamics: the ordinary slide toward equilibrium, heat dissipating and order running down. Put two homeodynamic processes into relationship and their coupling can impose a geometric constraint on the flow, a modicum of self-organization. That is the morphodynamic order, the order of Bénard convection cells and the hexagonal columns of cooling basalt, and the thermostat I flagged as a thin agent a moment ago. Its order is real but borrowed: a positive feedback loop that lives entirely on its throughput, so that the instant the energy stops, the constraint vanishes and the form slumps back toward equilibrium. All potential, no purpose. Climb once more, by putting two morphodynamic processes into relationship, and their intersection can close into a negative feedback loop that begins to work at maintaining itself. That is teleodynamics: the threshold at which a system becomes organized to preserve and reproduce its own constraints, to hold open the very conditions of its own existence. Here, and only here, does a process come to be for something on its own account (Deacon, Incomplete Nature, 2011).

Set the two vocabularies side by side and they lock together. Thick agency (individuality, normativity, self-maintenance) is a teleodynamic achievement: a loop closed on itself, working to hold its own ends. Thin agency is morphodynamic, generative and constraint-propagating and capable of astonishing structure, but running on a throughput it does not own and dissolving the moment that throughput stops. A language model is a single morphodynamic process. Whatever end-directedness we see in it belongs to the other process in the pair, and the other process is us: our constraint, our purpose, closing the loop from outside. To call the machine an agent in the thick sense is to credit it with a teleodynamic accomplishment that is, in every case I have examined, ours.

Ordinary language does not keep the two senses apart, and that is where the payload gets smuggled in. Consider what happens when you say a language model decides, or reasons, or wants something, or understands what you gave it. Each of those is a thick-sense word. Decides imports deliberation, a weighing of alternatives from some genuine standpoint. Reasons imports the capacity to be moved by the force of an argument rather than the statistical weight of training data. Wants imports a desire that belongs to the system rather than to its corpus. Understands imports that meaning has landed somewhere, in someone, rather than merely being processed. We reach for thick words to describe a thin thing, and the words bring their history with them whether we consent or not.

Language models do something in the neighborhood of all four. They produce outputs that look like decisions, that resemble reasoning, that appear to reflect preference, that behave like comprehension. The resemblance is real; and that in itself is hardly trivial. The systems that researchers once described as “stochastic parrots” are not stupid; they stitch together sequences of linguistic form according to probabilistic information about how those forms combine, and they do it with a fluency that is genuinely new in the world (Bender et al., 2021). What is absent is the thing the thick words import.

Resemblance is not identity. When we use the language of authorship and will and understanding for a system whose agency is, at every level of its architecture, the thin kind, we being imprecise. This is the worst kind of imprecision, though, because we are loading our expectations with weight the technology cannot hold. Where do you think that weight will come down? Like any good morphodynamic process when the energy stops the form will come crashing down...and the first place that weight comes down is on the one habit that keeps us safe: checking the work.

Where the Language Leads Us Wrong

The most concrete cost of all this slippage is the slow erosion of verification. Start with what good use actually requires. When James Lee and Katrina See laid out the design principles for trust between people and machines, their central finding was that outcomes depend on appropriate reliance: calibrated dependence under uncertainty takes on a form that is neither reflexive acceptance nor blanket rejection (Lee & See, 2004). The older automation literature had already mapped the two ways calibration fails, naming the over-trust that leads to misuse and the under-trust that leads to disuse (Parasuraman & Riley, 1997). The entire skill of using these tools well is a skill of calibration. The question we have to perpetually ask is what throws the calibration off.

The tempting answer is that anthropomorphic words simply inflate trust, but the careful research people have performed says it is not that simple. When Inie and colleagues tested whether describing a system in human terms reliably raised users’ trust in it, they found no clean overall effect. Maybe you expected this, but I sure didn’t the first time I read about it. Instead, what they found was that wording interacted with the stakes, the task, and the user’s background rather than moving trust on its own (Inie et al., 2024).

What is the lesson to be drawn from this? If you think it is that language is harmless, you are wrong! We are getting to something much more nuianced: notably that language is not a switch. Its effects are contingent, which is exactly why institutions should stop assuming their words are safe simply because the effects are hard to predict.

What language does reliably, maybe even most reliably, is move responsibility. Petersen and Almor found that agentive framing shifted responsibility toward the AI and away from the company that built it, and did so most among less experienced users (Petersen & Almor, 2025). Hindennach and colleagues found the mirror of this in how AI systems get explained: mind-attributing explanations led people to treat the system as aware and to keep holding it responsible even after human involvement was made explicit (Hindennach et al., 2023). The danger of the word is the way it can quietly redistribute accountability. So let’s use our language to be blunt and bombastic. Agentic AI slides the weight of responsibility off the designers and deployers and onto a thing that cannot carry it.

Some of that reliance is earned, and I want to be honest about it, because the forthright version of this argument is stronger than the alarmed one. There are tasks AI does reliably enough, and verifiably enough, that constant supervision costs more than it returns. I have pipelines running right now that I no longer spot-check. I built them carefully, verified them hard during a tuning period, and earned confidence in their outputs by watching them over time. The security specialist in my swarm flags credential patterns; I checked its judgment against hundreds of cases before I stopped checking. Stepping back there is not brute naivete. My stepping back has been the rational response to demonstrated reliability on a task whose outputs I can, in principle, still check whenever I choose to.

The danger lives in the tasks that are genuinely unverifiable: because the output is (1) too large or too complex to audit, (2) sits in a domain where I lack the expertise to evaluate it, or (3) is part of a pipeline that was built so that inspecting the intermediate steps is impossible. Here the thick-word framing stops being cosmetic and starts being load-bearing in the worst ways. If I believe the system understood the brief, I am less likely to notice that I have no way to confirm it did. And, the reflex to defer is not fixed by making the machine explain itself more fluently. Buçinca, Malaya, and Gajos tested precisely that and found that better explanations did not cure over-reliance; what worked was cognitive forcing, requiring the person to commit to a judgment before the system revealed its answer: adding friction that interrupts automatic uptake (Buçinca, Malaya & Gajos, 2021). The finding relocates the whole problem. It moves it off the system’s apparent intelligence and onto the design of the workflow around it, which is the one place a human still has leverage.

I have written before about the Verification Tax: the escalating cost of checking output that looks right. Thick-word framing is what tempts us to stop paying it. It supplies, in advance, the story that lets us look away: the machine is smart, the machine understood, the machine is on it, just let the machine do it. The language invites a transfer of epistemic responsibility the technology is not built to receive, and when the transfer completes there is no one left holding the question.

The stakes reach past the operator. When Fidelity Charitable surveyed donors on nonprofit use of AI, ninety-three percent rated transparency about that use as important, and a majority reported real discomfort with communication they believed had been fully automated (Fidelity Charitable). People can feel the vacuum where a mind was supposed to be. They recoil from being processed by something they were told to treat as someone, and they can tell, somehow, that they have been. And, even if they can’t tell, they are upset when they feel they have been duped if they find out what was really the case.

Subscribe now

The Culpability Problem

I want to say something uncomfortable, and say it plainly. Not everyone who talks about AI this way is making the same mistake, and the difference is the moral center of this piece. Someone who has used Claude for three months, found it genuinely helpful, and talks about what it thinks or wants because that is the readiest way to describe a thing that answers in fluent sentences, that person is making an innocent error. The imprecision is understandable. It is close to involuntary. It is the kind of imprecision that begets the very learning process I am so dedicated to.

We know why it is close to involuntary. Conversational systems operate in a medium that invites social interpretation; the very act of exchanging natural language pulls a listener toward reading a mind on the other end, and design choices routinely deepen the pull (Abercrombie et al., 2023). The pull is not one thing that can be switched off with a disclaimer, either. Anthropomorphism is a whole family of cues, spread across claims about understanding, memory, intention, relationship, even morality, which is why a system can be described as a mere tool in one sentence and personified in the next without anyone noticing the seam (DeVrio et al., 2025). Joseph Weizenbaum saw the raw form of this in 1966, when the users of ELIZA, a program that did little more than rephrase their statements as questions, began confiding in it and insisting it understood them. The tendency is old. It is a default setting of the species, and the untrained user is simply running it. Petersen and Almor’s finding that agentive framing moved responsibility most among less experienced users is the same fact seen from the other side: the people with the least technical footing are exactly the ones the language moves the furthest (Petersen & Almor, 2025).

The developer who has read the papers. The builder who understands, at the level of the mathematics, that what happens inside these systems is probability estimation over token sequences, and who still reaches for the language of agency and reasoning and understanding because it is more compelling, more marketable, more legible to a general audience: that person is not running the involuntary program. They have the override, and they are choosing not to use it.

There is a name now for what that choice exploits. LaCroix, Mallory, and Luccioni call it strategic polysemy: a term keeps its narrow technical meaning available for insiders while carrying the richer common-sense associations for everyone else, so that a communicator can draw on the full human force of a word like agent and then retreat to the thin engineering definition the moment they are challenged (LaCroix, Mallory & Luccioni, 2026). The expert is rarely lying. Despite a strong desire to suggest they are snake oil salesman they are not. They are however, maybe more like the used car salesman who doesn’t lie, but chooses to omit some of what they know so that you don’t have to think so hard about what you are purchasing.

That may sound harsh, but I think its accurate. The expert engage in strategic polysemy is living in the gap between thick and thin, borrowing the authority of the first while keeping the deniability of the second. The untrained user cannot do this, because they only ever had access to the thick meaning. The expert can, because they hold both. That is why the culpability scales with the knowledge. The word does not stay a description in the mouth of the expert; in their mouth it is an act that can be answered for.

If it makes you squirm and feel nervous about what you purport through expertise whether on LinkedIn or Substack or Journal Articles or Public Media, good. This should not a comfortable thing to hold if we really acknowledge there are stakes and responsibilites for those of us who work in this space. We may still, on a tired afternoon, reach for the convenient phrase. I reach for it. I named a JSON file a swarm. The point is to do more than make easy binaries of the knowing as villains and the innocent as saints. My point is in some ways simpler but ethically crueler: once you understand both meanings of the word, choosing the ambiguity is a decision, and the decision has a cost that lands on someone who trusted you to mean the thinner thing.

What Probability Actually Means

Let me try to say, without requiring a technical background, exactly what these systems do. It may be well trod territory, but we have to hear this again and again to let it seep into the marrow of our bones how thin but magnificent the achievement of generative AI really is. A language model generates output by estimating, at each step, which continuation is most probable given everything that came before, where “probable” is fixed by patterns learned from an enormous body of training text. It is not retrieving a stored answer. It is not following logical rules toward a conclusion. It is not reasoning from principles.

It is doing something closer to this: given everything I have seen, what tends to come next in situations like this one? The architecture that made this work is named for a process rather than a personality; its job is to transform an input into a probable output, computing across the whole context at once how strongly each word should pull on every other.

This is genuinely powerful. Patterns learned from enough data at enough scale produce outputs that are frequently indistinguishable from the products of real reasoning, real understanding, real expertise. The functional resemblance is not a trick; it is the whole reason the tools are useful. But the mechanism is probabilistic through and through. What looks like a decision is a weighted selection. What looks like reasoning is pattern completion. What looks like understanding is successful prediction. And what looks like agency, the thick kind, the capacity to initiate from something internal, is at bottom the thin kind wearing the other’s clothes. Sophisticated response. Astonishing response, often. But, response all the way down.

I have used two pictures for this before, and they still hold. One is the sculptor and the 3D printer. Human thought works like a sculptor with a chisel: each strike a decision informed by the shape that has already emerged and the goal being moved toward, understanding built up in time. The model works like a printer that takes the entire blueprint and renders a finished object in a single pass, and when it seems to evolve an idea across a chat, the illusion belongs to us, because we are the ones revising the prompt and asking it to print again and again and again. The other picture I think of often is the galaxy: every word a star, and the model computing, from your prompt as a starting position, the most probable path of connections through the cloud, drawing a constellation that hangs together beautifully not because it grasped your meaning but because its mathematics are relentless about coherence. Both pictures point at one fact. This is a form of knowing without a knower, a process that produces the shape of thought without anyone home to think it.

None of this makes the tools less useful. It makes them differently useful, and understanding the difference is the whole skill. There is an honest way to hold the gap, and philosophy handed it to us before the technology arrived. Daniel Dennett called it the intentional stance: the move of treating a system as if it had beliefs and desires because doing so lets us predict its behavior efficiently (Dennett). The stance is legitimate. It is often the only practical way to work with something this complex. Dennett’s entire point, though, was that it is a stance, a posture we adopt for leverage, not a discovery about what the system is. The error we make is in forgetting we took a stance in the first place.

The Productive Edge of Unverifiability

There is a turn in this argument I have not been able to resolve cleanly, and I would rather show you the unresolved thing than pretend to have a tidiness I do not possess.

I have said that unverifiable tasks are where thick-word trust becomes most dangerous, and I hold to that. Something else is true about the same territory, though, and it cuts the other way. When AI produces an output I cannot verify, it places me, whether I want the position or not, in the posture of a learner. I cannot close the question by checking the answer. I have to sit in the uncertainty, evaluate obliquely, and bring my own judgment to bear on something I cannot directly audit.

This is uncomfortable. It is also, sometimes, the most generative place I work.

Philosophy offers a frame more precise than my discomfort. Ori Freiman argues that our whole theory of testimony, the account of how we come to know things on the word of another, is quietly built for human speakers with intentions and stakes, and that conversational AI breaks it open. What he calls AI-testimony explains how a person can genuinely learn from a system that speaks in natural language while flatly denying that the system has the intentions, the understanding, or the standing of a human witness (Freiman, 2024). So, the output can teach without being a knower. I can be instructed by something that does not grasp a word of what it told me.

The learning is still real even when the teacher is not a teacher.

There is a body of learning science that treats this discomfort as the point. Robert Bjork has spent decades documenting what he calls desirable difficulties: conditions that slow or obstruct immediate success (spacing practice out, interleaving problem types, withholding the answer) and, in the slowing, produce deeper retention and better transfer than the frictionless version of the same lesson (Bjork & Bjork, 2011). Manu Kapur’s work on productive failure sharpens the claim: students who wrestle with a problem and fail at it before any instruction arrives come to understand it more deeply than students handed the method first (Kapur, 2008). The unverifiable output puts me in exactly that condition: it withholds the answer I cannot look up, and the withholding is where the formation happens, so long as I am the one doing the wrestling and have not handed that off to the machine as well.

What I would say, past the literature now and out where I have only my own experience to draw on, is that the unverifiable encounter has a particular texture. It resists closure. In the adventing essay I described a kind of learning that lives only so long as the question stays open, that dies the instant it resolves into an answer: wonder, in Bonaventure’s sense, enlarged by the question rather than relieved by it. Unverifiable AI output resists closure too, though for an entirely mechanical reason. Not because anyone designed it to hold the space open, but because I lack the means to shut it. I cannot look up the answer in the back of the book. The irritation of that, if I let it be, turns into something closer to attention.

I am not recommending this as a method. I am naming it as a phenomenon, and naming, too, how easily it curdles. The same unverifiability that can sharpen attention is the exact condition under which the thick word does its worst work, because the moment I decide the machine understood, the openness collapses and I stop bringing anything of my own. The productive version and the dangerous version share an address. What separates them is never the AI. Let me say it again, it is never the AI. What separates is whether I show up with discernment, the genuine kind with duration behind it and something at stake in the outcome, or whether I hand that job to a system that was never a candidate for it.

So enter that territory knowingly. Know that you cannot verify. Know that what is coming back is probability wearing the shape of understanding. Bring your own judgment, and keep bringing it, precisely because nothing on the far side is holding the question for you. The system cannot do that. It never could. The language just made it easier to forget you were the only one there.

A More Honest Vocabulary

I am not naive enough to think we will stop calling these things agents. The word is too useful, too established, too deep in the marketing and the research literature and the ordinary hallway conversation to dislodge. The goal was never to purge it.

The goal is to stop letting it travel alone. Strategic polysemy works because a single word carries its thin engineering meaning for insiders and its thick human meaning for everyone else, and the gap between them is where the trouble hides. Qualification closes the gap. When agent appears, it should arrive with the functional description that fixes which meaning is in play: this system plans, retrieves, routes, drafts, classifies. State the thin sense and the reader no longer has to supply the thick one on your behalf. A word that names what the system does cannot be quietly cashed in later for what a person does.

The small substitutions follow, and they are smaller than they sound. Say the model generated where you were about to say the model decided. Say the output suggests where you were about to say the model thinks. Say the pipeline classified where you were about to say the agent understood. There is a reason to work phrase by phrase rather than reaching for one global disclaimer: anthropomorphism does not enter through a single dramatic claim but through an accumulation of small cues, spread across talk of understanding and intention and memory, so that one sentence can call the system a tool and the next can hand it a mind (DeVrio et al., 2025). Cue by cue is how it gets in. Cue by cue is how you keep it out. The adjustments cost almost nothing in fluency, and they hold the probabilistic reality where it belongs, just at the edge of awareness.

Words are not the whole of it, and this is the correction I most want to make to my own instincts. The honest vocabulary is necessary and it is not sufficient, because the failure lives not only in what we say but in how the work is arranged. Better phrasing will not rescue a workflow that shows the answer before the human has formed a judgment; what helps there is friction built into the process, a required first assessment before the system’s output is revealed (Buçinca, Malaya & Gajos, 2021). And no wording keeps responsibility fixed to people if the responsible person is never named in the same frame as the tool (Petersen & Almor, 2025). Three things have to agree: the description of the system, the workflow around it, and the line of accountability through it. When they contradict each other, the most flattering of the three wins, and it is almost always the one that makes the machine sound like a mind.

Underneath all of it sits a single question, and it is the one to install as a reflex. For every task handed to these systems: can I verify this? If yes, verify it, or earn the right to stop. If the answer is genuinely no, ask what that means for how much of your own judgment you are prepared to suspend on the strength of a fluent paragraph. The answer should always come in lower than the language invites.

For those who lead in higher education, the stakes here are not stylistic. The vocabulary you sanction in a syllabus or an academic-integrity policy is the vocabulary in which a generation forms its first calibration. Teach students that the AI thinks and knows, and you have taught them to extend a knower’s trust to a system before they own any means to check it; you have trained over-reliance and named it fluency. Honest words in the syllabus are a small act of curriculum, and it protects the human judgment it describes.

For those who lead nonprofits, the vocabulary decides how your staff meet the people you serve. Language that casts the donor-facing system as an agent that handles relationships invites your team to become overseers of a process they stop inspecting, and invites the person on the receiving end to feel the difference in their bones. The word chosen in the staff meeting travels all the way to the letter the donor opens.

The Question We Are Left Holding

I still run the swarm.

I did not tear down the registry after any of this. The specialists still route and draft and check for leaked keys, and I am still glad not to do that work by hand. What changed is smaller and harder to see. I still call them agents, and now I hear the word when I say it. The deference no longer arrives for free. It has to be earned, task by task, against the standing question of whether I can check what came back.

That is the discipline, and it is unglamorous, and it does not scale the way the tools do. The machine cannot hold the question of its own reliability for you. It has no stake in the answer, no duration behind it, no self that hangs on getting the thing right. It never could. No further increase in fluency will change what it is. The least we can do, those of us who know the difference between the thick word and the thin one, is refuse to hand that question away inside a word, to anyone who trusted us to mean the smaller thing.

Often what was frustrating to me was that the concept they didn’t get was not especially difficult (translation: I’ve spent my entire life studying this damn topic so I don’t care if you think it’s boring - suck it up buttercup and read the 200 pages of Kierkegaard I assigned and come back with PhD level notes). I had explained the concept multiple ways (translation: I’ve laid out a detailed technical argument my colleagues in the field have praised me for so why can’t your feeble mind seem to keep up with me, clearly that’s your fault). Other students were following along (translation: one brilliant student understood who didn’t actually need me to be there in the first place). But for this particular student (translation: literally everyone except the one student who doesn’t need me to teach them anything probably), something was not connecting — the ideas were landing as information (translation: they knew who to use copy/paste in a word doc on the vocabulary guide I gave them) but not as understanding.

They were present without being alive (translation: I’m too scared to admit out loud that my teaching may be what is killing them).

That pretty well sums up my first three or four years of teaching in lots of ways. It’s a bit hyperbolic...but less hyperbolic than I care to admit.

Around year four or five (notably at about the same time where my administrative load turned my teaching load into something more manageable, which is an essay for a different time) I watched something happen. I had a pretty motivated student that started coming to class about 15 minutes early and rewriting their notes. They were not the best student, but they were terrified failing and being ineligible during the season. I’m using the word “rewrite” intentionally here. They were not reorganizing them or rereading them. They were rewriting them entirely, trying to do something I tossed off as a line in class on the first day: “try translating every concept you hear in this class into something you feel like you know a lot more about than me.” He was translating every concept into basketball analogies. This student knew basketball the way some people know a language they grew up speaking. They knew it in their bones in ways that are still remarkable to me. And once they found a way to say the thing I was teaching in the language they already knew that deeply, something shifted. The concept stopped being information and started being theirs. (I’m happy to report that student worked hard and got a B+).

What that student did was become the teacher of their own understanding. They did not wait for me to find the right explanation. They built a bridge from territory they knew deeply to territory they were trying to enter — and in the building of the bridge, they crossed it. And, 10 years later I can still enjoy an NBA game in ways I never could before.

This is what the Bridge Bot occasions. Let’s be very, very clear from the beginning: this is not the bridge itself. You cannot hand someone a translation that will work for them in this context. Instead, it’s an honest effort to replicate what I learned from which that student before each class figure out how to build their own bridge in an AI wrapper.

What the Bot Is Actually Doing

The bot’s first move is to find out what the student knows deeply. Not what they know well in an academic sense, but what they know the way the basketball student knew basketball — with fluency, with love, with the kind of embodied familiarity that comes from long engagement rather than study. That domain of deep knowing is the raw material for the bridge. The bot uses it to construct an initial analogy, and this analogy becomes a way of saying the unfamiliar thing in the language of the familiar one. But the analogy is not the destination. It is the starting point for a test.

The philosopher of science Imre Lakatos distinguished between research programs that are growing and research programs that are declining. A growing program organizes more and more ideas around its core thesis in novel and constructive ways; it keeps generating new predictions, new questions, new territory to explore. A declining program spends its energy defending the core thesis against attack. The declining program is always qualifying, always making exceptions, always protecting rather than extending.

A good analogy works like a growing research program. It does not just explain the concept once. It organizes more of the territory around a central insight, producing new “oh, and that also means...” moments as it is extended. A weak analogy works like a declining program: it requires constant qualification and defense, always running into exceptions that have to be explained away.

The bot tests whether the bridge the student is building is growing or declining. If it is growing, the bot extends it further, pushing into new territory the analogy can illuminate. If it is declining, the bot names where and why it breaks down, and then asks the most important question: what does the breakdown reveal about the concept itself? This in turn opens the possibility of establishing a new analogy that might function more like a growing research program.

That question, what does the breakdown reveal, is where the real learning lives. The place where the analogy fails is often the place where the concept is most interesting.

What a Round Actually Looks Like

Theory is cheap here, so here is the bot at work. A student has been asked to make sense of negative feedback loops, and the only thing they know cold is basketball.

Student: A negative feedback loop is like a good team defense. When the other team starts scoring inside, the defense collapses into the paint to shut it down. Then the other team starts hitting outside shots, so the defense spreads back out to cover the perimeter. It keeps adjusting to whatever the offense does, always pulling back toward balance.

Bridge Builder: Good, and notice you’ve already built something structural, not just a resemblance. The size of the defensive adjustment tracks the size of the problem: a couple of points inside, a small collapse; a whole run of them, a bigger one. That proportional response is the load-bearing part. Let me walk one step further out onto the bridge. Your defense has a coach on the sideline reading the game and calling the adjustment. What does the coach correspond to in a feedback loop that has no game and no sideline, say, in a body holding its temperature at 98.6?

Student: The brain, I guess? Something has to notice the temperature is off and decide to fix it. The hypothalamus, or whatever it’s called.

Bridge Builder: Stay right there on the word “decide.” In your defense, the coach sees the deviation and chooses the response. It’s a decision, made by someone who could have chosen otherwise. Is that what’s happening when you start to overheat and your skin begins to sweat before you’ve noticed a thing? Is anything deciding?

Student: ...no. It’s not deciding. The heat just triggers it. It’s chemical. There’s no one reading a scoreboard and calling a timeout. It just happens because of how the system is wired together.

Bridge Builder: So this is exactly where your bridge stops carrying you, and the edge is worth standing on rather than stepping back from. Your defense regulates itself because a mind is watching and correcting. The body regulates itself with no mind watching at all. What does the concept have to contain, then, that a basketball court never needs?

Student: Regulation without anyone doing the regulating. The loop has to control itself with no controller. That’s the strange part, isn’t it. The thermostat doesn’t want the room to be warm. It doesn’t want anything, and it works anyway.

The student walked in with a defensive scheme and walked out holding the strangest and truest thing about feedback, control with nobody in control, and the bot never explained a single thing. It only kept asking what the next piece of the court corresponded to, until one piece had no counterpart, and the missing counterpart turned out to be the whole idea.

How to Use It

Bring the bot a concept you are wrestling with and a domain you have lived inside — a sport, an instrument, a trade, a game, a job you have actually worked. It finds the domain first, builds the opening span with you, and then does the thing almost all advice about analogies skips: it tests the bridge by walking you out onto it, one step at a time, until the bridge either carries you somewhere you couldn’t get to before or sets you down at the exact edge where the concept stops resembling anything familiar and starts being only itself.

For teachers, bring a concept you are about to teach and a domain you know deeply yourself, and watch for where your own bridges break. Those breaks are the places your students will get stuck, and it is better to meet them at your desk than thirty faces at a time.

Here is a version you can play with on your own hosted in BoodleBox: https://box.boodle.ai/a/@NovelCapacity

Below the fold for paid subscribers: the map of a single round, the full instruction set, an honest account of where the bot’s judgment actually comes from and how we keep it from drifting, one design choice worth defending, how to set it up inside your own tools, and four ways to retune it.

Subscribe now

Read more

It is correct. It is complete by the standards of the assignment, and it shows that the student did the reading and understood it well enough to pass. And it has a way of arriving finished before it has really begun. The student reached a sufficient answer and stopped there. The question closed. The inquiry, such as it was, ended.

Intelligence is rarely the issue. What tends to be missing is a disposition: the habit of mind that treats a sufficient answer as an invitation to keep going rather than a reason to stop. Like most habits of mind, it grows far more through practice than through explanation. You build it by drilling it.

In my own teaching, I leaned on something I called the “Pretend you are 3-Years-Old” game. Students worked in pairs. One would make a claim, the other would ask why, the first would answer, and the second would ask why again. And again. For a fixed number of rounds (five, seven, ten, whatever the exercise called for) the asker refused to accept any answer as final, not because the answers were wrong but because the drill required it.

It felt artificial, and that was the point. The drill builds the capacity for genuine inquiry through constrained repetition, the same way a swimmer does not train for a race by racing. They swim drills at pace, laying down the muscle memory that makes the race possible once it finally comes.

The Depth Bot is that drill, rebuilt as something a student can pick up at any hour, for any concept, without a partner in the room. It is the first of the three tools I promised at the close of the last essay, the one built to occasion depth before we get to novel capacity and incorporation. None of them answer questions. This one holds a single question open long enough for the student to fall through its floor.

What the Bot Is Actually Doing

The bot is not asking why over and over. Repetition like that goes vacuous fast, producing frustration where it promised depth. (I tried an early version of that with my daughter and it made her cry when she was working on social studies…but at least you won’t have to burst into tears!)

What it does instead is find the seam. Every sufficient answer has one: a place where the explanation quietly stops explaining, where a term carries more weight than it has been given, where an assumption is doing work that nobody has examined. The bot locates that place and asks about it precisely.

The move is closer to excavation than interrogation. The goal is to make visible a dimension of the knowledge that the surface understanding had kept out of sight, to surface what is ordinarily covered: taken for granted, glossed over, left alone because answering the question never required disturbing it. The student’s answer is never the thing under attack. The thing under the answer is.

When it works, the student does not feel defeated. They feel something nearer to surprise. The thing they thought they understood turns out to hold a depth they had not noticed. That surprise, that encounter with the previously invisible, is the phenomenological signature of genuine depth. It is the beginning of wonder rather than the satisfaction of curiosity, the same distinction the last essay leaned on, now small enough to fit inside a single exchange.

What a Round Actually Looks Like

Theory is cheap here, so here is the bot at work. A student has been asked to explain natural selection.

Student: Natural selection is survival of the fittest. The organisms best adapted to their environment survive and reproduce, so their traits become more common over time.

Depth Drill: So the whole engine is that better-adapted organisms survive and pass on their traits. Here is what I’m sitting with: you used “fittest” and “best adapted” as if fitness were something an organism carries around inside it. Fit for what, though? Where does the standard of fitness come from?

Student: From the environment, I guess. The environment decides which traits are useful.

Depth Drill: Stay on that word, “decides.” A drought hits, and the birds with deeper beaks make it through. Did the environment select the deep beak, or was the deep beak already sitting there before the drought ever arrived? Which one is doing the choosing?

Student: ...the beak was already there. The mutation came first, randomly, and the drought just made it matter. The environment didn’t build the trait. It changed which traits paid off.

Depth Drill: Notice what moved while you were talking. You started with “the fittest survive,” which sounds like a law the organism obeys. Now you have something stranger: a beak that meant nothing on Tuesday and everything on Wednesday, with no change in the beak at all. So what is fitness, if the very same beak can be fit and unfit without ever changing?

Student: Oh. So fitness isn’t sitting inside the bird. It lives in the match between the bird and a moment that could turn on it tomorrow.

The student walked in with a slogan and walked out holding a genuinely harder idea, and the bot never once corrected them. It only kept finding the next seam. Four rounds of that, and survival of the fittest stops being a phrase to recite and becomes a problem to think with.

How to Get It

The Depth Drill is already built and already running. There is nothing to assemble.

Play with the Depth Drill here

Hand it a concept from your course and explain that concept to it the way a student would, in your own words. It takes the explanation from there. One question at a time, for as many rounds as you agree to, it keeps finding the next place your understanding rests on something you have not actually looked at.

That is the whole student-facing experience: explain something you think you know, and let the bot show you the parts of it you have been walking past.

Below the fold for paid subscribers: the map of a single round, the instruction set behind the bot, an honest accounting of where its judgment comes from and how we keep it from drifting, how to set it up inside your own tools, and four ways to retune it.

Subscribe now

Read more

The first promise is that it should be able to deliver instruction directly. The prevailing hope is that AI can (or will soon be able to) explain a concept, answer a question, and provide information clearly and patiently. The basic idea is that AI becomes the tireless teacher; it never suffers from the exhaustion that eventually overtakes even the best human teacher.

The second promise is that it could serve as a Socratic tutor. Here AI is asking questions rather than handing over answers. Again, the aim is similar though: the goal is to draw understanding out of the student through dialogue, replicating the method of the philosopher who claimed to know nothing while somehow producing some of the most significant thinkers in Western history.

To this point (and I stand by it) AI can’t really deliver on either of these promises. Both direct teaching and Socratic questioning are key principles of education that AI is able to contribute to in interesting and novel ways, even if our current AI systems hardly live up to the hype of what they are supposed to do in this regard.

So in this essay I want to take a different tack. Let’s assume both promises are real and attainable. AI does elements of both with increasing fluency. Let’s give the bro-archy and ed tech the benefit of the doubt and assume they can build AI systems that provide on-demand Socratic questioning and supremely reliable content delivery.

Does fulfilling these two promises really deliver on the work of education itself? To me, at least, this is the more interesting question because those are pedagogical approaches that optimize for exactly the wrong thing: closure.

The Problem with Closure

In my early theological writing I developed a concept I called adventing, drawing on the liturgical season of Advent: the weeks of waiting and anticipation that precede Christmas in the Christian calendar. Advent is a space of possibility. It is characterized by longing and waiting. It is fundamentally a time defined by its incompleteness: by something hoped for but not yet arrived. And, it functions as Advent only so long as it stays open. The moment what is awaited arrives, something essential is lost. (You always knew Christmas ruined something...it just happens to be that what it ruins is the possibility of Advent).

Now, I should say more clearly, none of this is meant to indicate that arrival is bad. (Yes, Christmas is off the hook, again). But, because the quality of existence that belongs to the not-yet cannot survive its own fulfillment, adventing only works insofar as what it hopes for doesn’t completely fulfill that hope.

This is not a uniquely theological insight. Søren Kierkegaard understood this and claimed something similar when he said that certain truths cannot be directly communicated. They can only be occasioned.

Consider Either/Or, which Kierkegaard published in 1843 under the pseudonym Victor Eremita, the “victorious hermit” who claims merely to have found the manuscripts hidden in the drawer of a secondhand desk. The book sets two ways of living side by side and refuses to choose between them. The first belongs to an unnamed aesthete devoted to pleasure, novelty, and possibility; the second to a judge who defends marriage, duty, and the decision to bind oneself to a single life. Kierkegaard offers no verdict. The title is the whole argument: either, or. A reader who is handed the correct answer has not actually chosen, and for Kierkegaard the choosing is the entire point. The ethical life cannot be received as a doctrine. It has to be willed by the person living it.

This is what Kierkegaard meant by indirect communication, and he practiced it with extraordinary deliberateness, writing under a crowd of pseudonyms, constructing elaborate situations, manufacturing productive confusion instead of delivering clarity. The reader who receives a truth directly has only received information. Truth, in the sense that matters, has to be arrived at. It has to be undergone.

Plato understood this too, and he built it into the very form of his writing. The Symposium never speaks in Plato’s own voice. It reaches us secondhand, narrated years after the fact by Apollodorus, who had the story from Aristodemus, who was actually there: a chain of report that keeps the author offstage much as Kierkegaard’s pseudonyms kept him offstage in his own books. The occasion is a drinking party at the playwright Agathon’s house, where each guest takes a turn praising Eros.

When Socrates’ turn comes, he does not offer a theory of his own. He relays what he was once taught by Diotima, a priestess of Mantinea, and what she taught him was a myth. Eros, she said, was conceived at the feast for Aphrodite’s birth, the child of Poros (Resource) and Penia (Poverty). He inherits his mother’s need and his father’s cunning, and so he is forever poor, forever scheming after the beautiful things he lacks, never in secure possession of any of them. Desire, on this account, is a condition of being in between, of not-having, woven into the structure of the soul rather than a hunger that good fortune eventually fills.

What Diotima offers Socrates is not a definition of beauty but a staircase. She describes an ascent that begins with the love of a single beautiful body and climbs, rung by rung, to all beautiful bodies, then to the beauty of souls, then of laws and ways of life, then of knowledge, until at the summit something comes into view that can only be glimpsed and never grasped: Beauty itself, which does not come and go and cannot be owned. The dialogue does not hand the reader that vision. It stages the climb and leaves the reader to attempt it. Eros, genuine desire, is not satisfied by its object. It is constituted by longing. Fulfill it completely and you have not satisfied desire. You have ended it.

Education at its deepest level works the same way. It is a type of desire that cannot be directly communicated. The student who has truly been educated is not the one who got the answer but the one who has been given a longing, a capacity for wonder that expands as it meets more of the world. Adventing is the discipline of protecting that longing and wondering. You cannot hand someone a transformation. You can only build the conditions under which transformation becomes possible.

Or if you want to be a little more colloquial, “You can lead a horse to water, but you can’t make it drink.”

Why Direct Instruction Falls Short

Let’s start with direct instruction: AI explaining, answering, clarifying. It does not fail because it is inaccurate or unhelpful. (If anything, clear explanation is the one thing the current systems are genuinely good at.) It falls short because it delivers closure.

When a student asks a question and receives a clear, complete, well-organized answer, something happens that feels like learning but is not quite learning. The question gets resolved, and the discomfort of not-knowing is relieved. The result is nearly always that the space of possibility the question had opened is closed.

This is not always a loss. Some things worth knowing do not require transformation to know them. Facts, procedures, definitions: these can be delivered and received without significant cost. Direct instruction serves perfectly well here, and AI serves direct instruction very well indeed. (This is the part of the sales pitch that happens to be true.) The trouble begins only when we treat that transaction as the whole of teaching.

Because education, in the fullest sense, is the formation of a person. We could name this in all kinds of ways. It is the development of capacities; it is the cultivation of judgment; it is the awakening of what the thirteenth-century theologian Bonaventure called wonder. If you have been wondering about my use of wonder, I’m using this word intentionally. And, in deference to my former colleague Tyler Atkinson, please get it straight that wonder is not curiosity.

Curiosity wants to close. It wants to find out, to know, to resolve the question that opened it, and it is satisfied the moment the answer arrives. Wonder behaves differently. Wonder is content to remain open, to marvel, to be undone by what it encounters, to find itself enlarged rather than relieved by what it discovers. Curiosity drives toward the answer. Wonder is enlarged by the question.

Direct instruction, however sophisticated, produces curiosity at its best. It cannot occasion wonder, because it is built to answer, and answering, when it comes too quickly and too completely, forecloses the advent before the student has had time to live inside it.

Why Socratic Tutoring Fails

Now the Socratic tutor is the more interesting case, and the harder one to argue against, because it looks like it is already doing what I am asking for. It asks rather than answers. It follows the student’s thinking instead of leading it (or at least it is supposed to). On the surface, it holds the space open. (This is the version the demos love, and I understand why.)

But here is the catch. A convincing imitation can reproduce the form of a thing while missing the core that made the thing what it was, and the Socratic bot is a facsimile of Socrates in exactly that way. What made Socrates Socrates was not his method. (The method is the part you can copy, and it turns out to be the least important part.) It was his genuine openness to being transformed by the encounter. He was not performing ignorance. He was vulnerably present to the possibility that the person in front of him might occasion something in him he had not anticipated.

To harken back to some of my more recent writing about What AI Cannot Do, Socrates has something at stake that AI can never have. He had duration: a life of formation, of previous encounters that had shaped him, of commitments and questions he carried into every conversation and that every conversation acted back upon.

When Socrates questioned someone, he was not running a pedagogical procedure toward a destination he had already chosen. But, this is the best a Socratic tutoring bot can do. Instead, Socrates genuinely did not know where the exchange he was having would end. He opened himself to being occasioned, to having the conversation change him as much as it changed his interlocutor. This is why the dialogues so often end in aporia, in unresolved openness. Socrates did not withhold the answer. He did not have it, he wanted it, and the finding was always incomplete.

An AI Socratic tutor always has an end. Beneath the questions, it is always moving toward something: a correct understanding, a learning objective, a destination dressed up as discovery. It cannot be genuinely surprised. It cannot be changed by the encounter. It has nothing at stake, no duration, no self that hangs in the balance of the conversation.

In essence, AI can only perform openness while being built for closure.

Students feel this, even when they cannot name it. You can feel it yourself the next time a chatbot asks you a warm, curious follow-up: the warmth is real enough, but the curiosity is set dressing. The questions feel like a road already mapped. The dialogue feels like it is leading somewhere the bot already knows, because it is, and it does.

What Adventing Actually Looked Like

For several years I taught a course in political theology. It was not my area of specialization, which may be part of why it worked. (Teaching just outside your competence is frightening in precisely the productive way.) I came to the material with my own questions still live, tracing why theological commitments kept surfacing in civic life: why the language of ultimate concern kept showing up in arguments about zoning, schools, and water. We did not stay in the seminar room. We engaged directly with local and state politics, following live questions into places where I could not predict what we would find, and neither could the students.

The course drew, strangely, more students from outside religious studies than from inside it. An advanced theology class would fill with people who had no particular investment in theology and every investment in the questions it was asking. (Nothing reorders a theologian’s ego quite like a roomful of students who came for the politics and stayed for the ultimate concern.) And yet, this is what fit the shape of the work we were doing. The adventing was built into the course from the ground up, because the questions were genuinely unresolved for everyone in the room, including me.

What students carried out of that course was not a conviction that they could change what was happening around them. It was a determination to be heard. There was a recognition that participating in the conversation, to refuse the posture of the spectator, was in itself a good they could choose. They left with something closer to hope than what might traditionally be measured as a learning outcome: a sense of wonder for the possibilities of resistance and action that their more closed educational experiences had quietly trained out of them. Nobody handed them that. It arrived, when it arrived. And, for some that occasioning never came. But for everyone in the space, the course refused to close.

In my own teaching more broadly, the moments that mattered most were never the moments of clarity. They were the moments of productive irresolution: assessments that graded process rather than artifact, conversations I deliberately declined to wrap up, situations where I held back the answer I expected and waited to see what the student would produce instead.

What happened in those moments was something Bonaventure would have recognized as wonder: not curiosity satisfied but marvel deepened. The student became, in those moments, more genuinely other to me. Not more known, but stranger, more genuinely themselves, in ways I had not predicted and could not have produced. The student who recapitulates the expected answer confirms what I already knew. The student who restructures the problem in a way I had not imagined makes the world briefly larger, and in that enlargement something passed between us I can only call mutual formation. They were teaching me. No facts were exchanged. Something harder to name occurred.

Maurice Merleau-Ponty described the deepest form of learning as a kind of incorporation: understanding that does not stay at the level of concept but becomes flesh, that changes how a person moves through the world. The students in that theology course did not leave with a better concept of civic life. They left moving through civic life differently. That is education that transforms rather than informs, and it happens through occasions. Or to put it more formally, it happens through the sustained, disciplined refusal of closure and adventing.

What AI Can Actually Do

This is not the part where I tell you AI has no place in education. Its place is just more specific and more modest than its advocates claim, and more interesting than its critics allow.

If the goal is to occasion learning rather than deliver it, to hold the advent open rather than close it, then AI’s role has to be indirect by design. It is not the teacher. It is not even the Socratic interlocutor. It is closer to a set of conditions for an encounter that still has to happen between a human being and the thing they are trying to understand.

In the bot essays that will follow this piece over the next few weeks, I am trying to develop three tools built on this principle, each designed to occasion one of the three modalities of genuine learning: depth, novel capacity, and incorporation. None of them answers questions directly. None of them performs Socratic dialogue. Each works indirectly, creating pressure and space instead of delivering content, holding the advent open rather than rushing it toward its close.

They will never wonder. But built with enough care, they might hold the space in which a student begins to. Just let the advent stay open a little longer. What finally arrives in it was never ours to deliver, and that is the whole point.

Frontier models are designed to reduce cognitive load, and that utility is genuine. It means the underlying mechanics happen automatically. You just ask, and something highly articulate comes back. The output is remarkably coherent and fast.

But to make something this seamless also means its interface operates through hidden logic. Unfortunately, if you cannot see those seams, you cannot understand what is actually happening. The consequence of this is that you cannot make better decisions about how to deploy these tools strategically, and you certainly cannot start thinking like someone who builds with them rather than someone who merely consumes them.

LM Studio is where you go to see the seams. It is the control deck hidden behind the vending machine.

The Illusion of the Seamless Vending Machine

We have been conditioned over the last two years to treat artificial intelligence like an omniscient vending machine. You insert a prompt (your cognitive currency) and a fully formed product drops into the tray. You only need to know the end result, regardless of how the gears turned, how the refrigeration unit maintained the temperature, or how the supply chain sourced the ingredients. You just want your snack.

This illusion is powerful, but it comes at an enormous philosophical and practical cost. By accepting the black-box opacity of frontier models, we surrender control to automated systems for the sake of convenience. We begin to believe the myth that “The AI” is a singular, monolithic entity with a fixed personality and a generalized competence.

The Myth of the General-Purpose Oracle

You’ve probably heard the prevalent narrative that the future of work belongs to those who learn to “prompt” these massive, trillion-parameter models. The reality is a diverse ecosystem of specialized tools (a generalized oracle) that can be coaxed into doing anything if you just find the right magic words.

The reality is much messier, though. When we treat AI as a universal reasoning engine, we keep colliding with the boundaries of a configuration we cannot see. A mid-sized university’s admissions office tries to standardize how it evaluates transfer credits. The team takes a general-purpose frontier model and spends weeks engineering the perfect prompt, instructing it to extract course codes, credit hours, and syllabus descriptions and nothing else: no commentary, no assumptions.

It fails anyway. The model was tuned by its makers to be a helpful conversational assistant, so it keeps “smoothing out” the data. It adds filler (”Here are the transfer credits you requested!”), and when a syllabus description is ambiguous, it guesses a plausible course equivalent instead of flagging the field as uncertain and leaving it for a human to resolve.

You’re team starts thinking, “AI isn’t ready for data extraction.” But the model was just mismatched. The team deployed a conversational tool to do extractive work, and they had no access to the controls that would have changed its behavior. They were using a vending machine to do surgery.

The Cost of Hidden Parameters

Look at how badly humans police black-box systems that produce neat, confident output. Raymond Panko, who spent years cataloging spreadsheet errors, found that roughly 88% of the operational spreadsheets examined in field audits contained mistakes. Reviewers asked to audit spreadsheets seeded with known errors caught only a minority of them, even when they were warned in advance that errors were present.

The mechanism is what matters for AI. The auditors were defeated by presentation, not laziness. A spreadsheet that looks authoritative, with clean columns and totals that add-up correctly, stymies the scrutiny it most needs The actual logic is obscured by the interface, one step removed from view, and that single step is enough. When a frontier model returns a confident, well-formatted answer, we default to the same reflex. We cannot see the parameters driving the behavior, so we fall back on judging reliability by surface polish, a metric that fails to measure actual reliability.

The strategic lesson is direct. The first real skill of the AI era is refusing to accept this dynamic. That means moving from being a passive consumer of a hidden process to an operator who has the agency to see and change the process. Doing this requires abandoning the smooth but ultimately deceptive user interfaces to which we are quickly becoming accustomed.

The “Zero-Trust” Philosophical Shift

I call this the “Zero-Trust” standard of AI development. Zero-trust means exactly what it sounds like: trust nothing, verify everything. This doesn’t mean do all the work twice, though. In the context of AI operations, zero-trust means refusing to accept the default configuration of a black-box model. It means demanding visibility into the mechanisms of the intelligence you are putting to work.

When you cannot verify the temperature, the system prompt, or the training bias of a model, you are producing unverified and potentially manipulated outputs. You are letting the arbitrary choices made by engineers or the opaque nature of proprietary training data set the agenda. These are not trivial defaults, as they decide whether the model hedges or commits, quotes or invents. You were never granted control over the model parameters to appropriately deal with this.

When you shift to a zero-trust mindset, you stop asking “What can this AI do?” and start asking “What are the structural constraints of this specific model, and how can I manipulate them to guarantee a precise outcome?”

Setting Up the Control Deck

If frontier models are vending machines, LM Studio is the control deck. This free, cross-platform application allows you to download, manage, and run Large Language Models (LLMs) locally on your own hardware. Users maintain full autonomy through local hardware and are not reliant on any cloud platform. Doing this may require some technical literacy, but it is far more empowering.

When you open LM Studio for the first time, it does not look like a friendly chat window. It looks like an engineering dashboard. The complexity, which may feel overwhelming, is also the feature.

Confronting the Black Box

LM Studio is built on radical transparency. You do not learn how an engine works by reading about engines. You learn by analyzing the system while it runs. AI is defined by this reality: the understanding that matters arrives only once you start moving the parts

Installing LM Studio forces you to confront the physical reality of artificial intelligence. You are downloading gigabytes of data rather than talking to a cloud. The sheer size of the model, its “weights”—the actual neural network—downloading onto your hard drive is astounding. Watch your RAM usage spike as the model is loaded into your computer’s memory. “Tokens Per Second” generated in real-time, dictated not by server traffic in California, but by the thermal limits of your own CPU and GPU.

This physical grounding changes how you think about the tool. It dissolves the mystique through grounding. It reminds you that an AI model is software executing matrix multiplications. The model is a deterministic algorithm processing data, not a sentient entity. Running on your silicon makes you the final authority on how it behaves.

Data Sovereignty and the “Local” Advantage

Another, more critical reason to establish a control deck is Data Sovereignty.

When you query a frontier model, your data leaves your machine. It travels to a server farm, is processed, and the result is sent back. For standard queries, this is fine. Analyzing proprietary financial data, unredacted legal contracts, or sensitive student records protected by FERPA presents significant risks when sent to external servers.

You cannot use the vending machine. The risk of data exfiltration is too high.

LM Studio provides an in principle solution (it is not scalable to an enterprise solution) that solves this by running the inference entirely on your local hardware. You can physically disconnect your computer from the internet, and the model will still function. This is the practical manifestation of the Zero-Trust standard. You trust the system because you own the hardware it runs on. You are gaining architectural control and total data privacy.

The First Three Shapes of Intelligence

You must curate your local laboratory. Open the model browser in LM Studio. You will see thousands of models, many with names like “Llama-3-8B-Instruct” or “Mistral-7B-v0.2”. The nomenclature is structured to ensure clarity. The ‘8B’ or ‘7B’ denotes billions of parameters: the size of the neural network. Models under 7B typically run on integrated graphics, while larger models require dedicated GPUs.

For your first session, you only need to download three specific types of models, representing three distinct cognitive architectures.

1. A General Conversational Model
   This is the closest equivalent to the frontier models you are used to. Look for a recent, mid-sized instruct-tuned model (e.g., Llama 3 8B Instruct). These models are designed to be “Swiss Army Knives.” They can summarize, chat, brainstorm, and write code. They are generalists, optimized to be helpful and polite for exploratory thought, yet prone to unwanted verbosity in strict analytical tasks.

2. A Vision-Language Model (VLM)
   Download a model specifically tagged for vision capabilities (e.g., LLaVA or Qwen-VL). These models possess a completely different architecture, allowing them to process pixel data alongside text tokens. Having a local vision model gives you direct access to the architecture of what multimodal AI actually involves. You will learn to prompt an image as a dense package of data, moving beyond mere visual aesthetics.

3. A Reasoning/Math Model
   The shift becomes obvious. Download a model fine-tuned for step-by-step reasoning (e.g., a DeepSeek-R1 distill or a dedicated math model). These models are built to think methodically rather than to be chatty or polite. They prioritize structural integrity over narrative flow.

Why three? Because a model is not a general intelligence. It is a system with a specific shape. Run the same prompt through a generalist, a vision model, and a reasoning model, and the difference is not just three different answers. It is three different ways of thinking.

Breaking the Temperature Slider

After downloading your models, you must adjust the most critical setting in modern AI: Temperature.

Temperature is a hyperparameter that controls the randomness of the model’s predictions. Language models calculate the probability of the next token (a word or piece of a word) rather than “think” in sentences. The temperature dictates how the model chooses between “apple” (80% probability), “banana” (15%), or “car” (5%).

At a temperature of 0.0, the model is entirely deterministic. It will always pick the highest probability token (”apple”). It becomes rigid, precise, and highly repetitive. It produces only predictable, statistically probable text.

At a higher temperature, the model is allowed to roll the dice. It might select “banana” or even “car.” It becomes expansive, creative, associative, and prone to hallucination.

The consumer chat apps you use every day hide this slider. Their developer APIs expose it, but only engineering teams ever touch it. LM Studio puts it in plain sight, on the right side of the screen, the first time you open the app.

The Case Study: The Policy Extraction

Here is why that single slider separates a failed experiment from a working pipeline.

A nonprofit reviews a stack of compliance documents to pull out every clause about data retention. They start in the standard web interface of a frontier model, where the temperature is fixed at a default value optimized for general use: fine for drafting an email, wrong for legal extraction. The model begins inventing clauses that sound plausible but appear nowhere in the source, “helpfully” filling gaps that should have been left empty.

Now, imagine doing this on your Control Deck in LM Studio.

You load a highly capable, local model. You upload the first policy document. You ask: “Extract all sentences detailing the exact duration of data retention. Return only the exact quotes. Do not add commentary.”

The High Temperature Test (1.5):
First, intentionally break it. Crank the temperature slider to 1.5. Run the prompt. The model will likely spiral into incoherence. It might generate: “The data must be held for seven years because the winds of compliance blow strongly across the servers of time. Data is a fluid memory. Never delete.” It reaches, it associates, and it deconstructs. It has stopped extracting your document and started inventing from it, which is exactly the failure you want to witness on purpose so you recognize it when it happens by accident.

The Low Temperature Test (0.0):
Now, pull the slider down to absolute zero. Run the exact same prompt. The model becomes a scalpel, outputting exclusively: *”- ‘All user telemetry data shall be retained for a period not exceeding 90 days.’ - ‘Financial records must be kept in cold storage for seven fiscal years.’” Just the precise extraction. The low temperature setting suppresses randomness, ensuring the output matches the input exactly.

The Insight of the Operator

When you experience this contrast firsthand, the insight lands with force: Both temperatures serve different purposes; neither is objectively “better.”

High temperature is useful when you want the model to generate ideas, make unexpected connections, or brainstorm campaign slogans. It is the engine of creativity. By contrast, though, low temperature is mandatory when you want the model to summarize accurately, extract information precisely, or write functional code.

The frontier model you use every day has a temperature. It was just chosen for you. When you realize that you can control this parameter yourself, you transition from being a passive recipient of AI outputs to an active designer of AI behavior. You stop asking, “Why did the AI make a mistake?” and start asking, “Was the temperature appropriate for this specific cognitive task?”

The System Prompt and Context Window

Temperature is only one part of the equation. LM Studio also exposes two other components that frontier models often obfuscate: The System Prompt and the Context Window.

Controlling the “Soul” of the Model

The System Prompt is the set of foundational instructions given to the model before it even sees your user input. It is the architectural constraint that defines the model’s persona, its boundaries, and its primary directive.

In a frontier model, the system prompt is hidden and massive. It often includes thousands of words of instructions detailing how the model should avoid controversial topics, maintain a friendly tone, and refuse certain types of requests. You never see these. These invisible instructions constrain your prompts.

In LM Studio, the system prompt is a blank text box on the right-hand panel. You are the architect.

If you want the model to act as a rigorous academic editor, you do not need to politely ask it in every single message. You simply set the System Prompt: “You are an austere, highly critical academic editor. You will evaluate all subsequent text purely for logical consistency and evidentiary support. You will not offer praise. You will only output a numbered list of structural flaws.”

This changes the model’s basic posture. It transforms from a broad assistant into the specific tool you designed. You have set its disposition before it reads a single word of your input.

This is probably the skill that we teach people the most about prompt engineering. Give context (persona, task, format, outputs, etc.) in the system prompt to give the model the best chance to succeed. Yet, what we often don’t tell people is that there is already hidden context there, so you are constantly prompting against something that you don’t even see. Very rarely, in the modern chatbot landscape, are you dealing with sending the LLM a blank prompt. If you noticed between major version changes that a response suddenly “just got better”, some of that is likely due to these hidden instructions.

Managing the Context Window

The Context Window is the working memory of the model—how much text it can hold in its “brain” at one time before it starts forgetting earlier instructions. Frontier models boast massive context windows (hundreds of thousands of tokens), but they charge you for every token you use, and they often suffer from the “needle in a haystack” problem, where they forget information located in the middle of a massive document.

LM Studio allows you to explicitly manage the Context Window size. You can see exactly how many tokens your document consumes. You can watch the RAM allocate accordingly.

Chunking and RAG force you to become a better architect. The constraints of local hardware teach you to use Retrieval-Augmented Generation (RAG) rather than dumping a 300-page book into a massive context window and hoping the model figures it out: chunking the text into smaller, manageable pieces and feeding only This architectural discipline distinguishes professional pipeline engineering from amateur prompting.

The Architecture of Delegation

Experimenting with temperature, system prompts, and context window sizes, you will begin to notice something profound about the nature of these systems. A shift from seeing AI as a monolithic tool toward treating specific models as specialized participants in a collaborative process defines a core philosophical principle.

Deconstructing the “General” AI

The tech industry holds that efficiency and capability are driven by massive, centralized, general-purpose models. A single 1-trillion parameter model can do everything better than a smaller model.

But the models reveal a more complicated reality. When you test a massive generalist against a small, highly specialized local model, the specialist often wins on domain-specific benchmarks.

Consider a structural evaluation of a complex logic puzzle. If you ask a general conversational model to solve a multi-step scheduling problem with strict constraints, it will often confidently provide an answer that sounds correct but fails upon closer inspection. It relies on its vast pattern recognition to fabricate a “plausible-sounding” schedule, but it lacks consistent constraints.

Now load a local reasoning model in LM Studio and give it the same puzzle. It opens a <think> block and works the problem in the open: stating the constraints, testing combinations, backtracking when one fails. The output is slower and less charming, but more correct, because the model was built for deduction rather than conversation. The lesson is that the shape of the model must match the shape of the task. Frontier reasoning models reason this way too, but behind a hidden interface, so you rarely know which shapes of reasoning you are getting.

The Pipeline vs. The Prompt

When you understand the “shapes” of different models—that some are built for empathy, some for extraction, some for logic, and some for code—you stop trying to force one model to do everything.

Imagine you are building an automated system to process customer feedback. A novice user tries to dump all the feedback into a single prompt for a frontier model, asking it to translate, categorize, summarize, and draft a response. The result is a generic, messy output.

The operator who has spent time on the control deck designs an assembly line, routing each task to the model and temperature built for it:

This is the entire shift in one picture. You are orchestrating a set of specialized models toward a reliable result., sending the rigid logical work to deterministic nodes and the creative, human-facing work to generative ones.

Building Your Local Laboratory

None of this counts until you run it yourself. Reading about the control deck builds nothing; the value lives entirely in the hours you spend at the keyboard with a real document and a slider you can actually move.

Your time spent in LM Studio is the foundational work of building your local laboratory. You test your hypotheses, refine your system prompts, and understand the raw mechanics of the models before you ever deploy them into a production environment or an automated workflow.

The Blueprint for the Operator

Based on this architectural analysis, your next steps are clear.

First, establish your local sandbox. Dedicate two hours this week to downloading LM Studio. Procure a complex document from your own professional life—a strategy memo, a grant proposal, a technical manual.

Second, run the Parameter Stress Test. Load a general model. Set the temperature to 0.0, 0.7, and 1.5. Ask it to extract the three most critical vulnerabilities in the document. Document the differences in the outputs. Measure the model’s output variance against a known baseline.

Third, design your first micro-pipeline. Identify a recurring, tedious cognitive task in your workflow. Map out the distinct “shapes” of intelligence required to complete it. Is it an extraction task? A reasoning task? A creative generation task? Determine the optimal temperature and model type for each discrete step.

The advantage is not going to the people who know how to talk to a chatbot. It is going to the operators: the ones who understand the raw materials, who can see the seams, move the sliders, and assemble systems that are precise, reliable, and genuinely their own.

You build that capability one deliberate parameter at a time. The control deck is open.

Before any presentation I was going to give, whether a lecture, a keynote, or a faculty workshop, I would sit down and build an outline first. Detailed, structured, sometimes color-coded down to the sub-point. I could see the slides in my head before I ever opened PowerPoint. I knew what each one would say, roughly how it would look, the arc of the whole thing from the opening provocation to the closing turn.

And then I would spend four or five hours building the deck, and it would come out nothing like what I had imagined. The font choices fought me. The image I wanted didn’t exist. The animation that was supposed to reveal the argument one beat at a time instead revealed how tired I was at eleven at night. The deck that reached the audience was always a degraded copy of the one in my head.

The first time I fed one of those outlines into Gamma and watched it produce a fully realized presentation in under a minute, one that needed only one or two small adjustments before it was ready, I had one of those moments you don’t forget. It closed a gap I had been living with for years: the gap between what I could see and what I could make. The vision in my head and the artifact on the screen finally matched, and I hadn’t spent an evening losing the difference.

The Gap Between What You Can See and What You Can Make

Most people experience AI as a tool that helps them do things faster. You write a prompt, you get an output, you edit it, you move on. The AI is a very fast assistant sitting beside you, and you are still the one doing the work. You are still in the chair, still making every decision, still the bottleneck through which every task must pass.

That is a legitimate and valuable way to use these tools. I used them that way for the better part of a year, and the productivity was real. But it has a ceiling, and the ceiling is you. However fast your assistant types, you can only supervise one conversation at a time. The faster-assistant model makes you a quicker craftsman. It does not make you anything else.

What I want to describe is a different relationship, one where you stop being the person who does the work and become the person who designs the system that does the work. Your primary output is no longer the thing itself. It is the pipeline that produces the thing, running whether or not you are watching it.

I call this being a pipeline architect. The shift from AI user to pipeline architect is, I think, the most consequential transition available to knowledge workers right now. Most people haven’t made it. Most people don’t yet know it’s on the table.

The difference between the two is not subtle once you’ve felt it, so it is worth drawing the line clearly.

The bottom row is the one that matters. As a user, you sell your hours. As an architect, you sell your judgment, written down once in a form a machine can execute a thousand times.

What a Pipeline Actually Is, and Where Mine Lives

A pipeline is a sequence of steps where the output of one step becomes the input of the next, and at least some of those steps involve AI making decisions you do not supervise in real time.

That last clause carries the weight. A pipeline is more than a workflow. Plenty of people have workflows, and a workflow with a human approving every step is just a slower version of doing it yourself. A pipeline has AI participating in the decisions inside the flow, not just carrying the bags. Classifying. Scoring. Routing. Deciding what happens next while you are asleep or teaching or three tasks downstream.

Here is a concrete example from my own week.

I subscribe to far too many Substacks. I find a writer doing something interesting, I sign up enthusiastically, and I never unsubscribe. The result is an inbox where not everything deserves the same slice of my attention. Some essays are extraordinary and reshape how I think about a problem for a week. Some are good. Some are competent and forgettable. And some I would have been measurably better off never opening.

So I wrote a scoring guide: a rubric describing what I actually value in a piece of writing. Not vague preferences but specific signals. Does the writer anchor claims in named people and dated events, or float in abstraction? Is there an argument with a turn in it, or just a position restated five ways? Does the piece earn its length, or is it a tweet wearing a trench coat? I gave each signal a weight and a short description of what a high score and a low score look like in practice.

Then I built a pipeline that applies that guide to every Substack essay that lands in my email before I ever see it.

For the first month I spot-checked obsessively. I pulled essays it had scored high and asked whether I agreed. I pulled essays it had scored low and asked whether I had missed something the rubric couldn’t see. Twice I found a real disagreement, traced it back to a vague line in the scoring guide, and rewrote that line to be sharper. Then the spot-checking faded on its own. Not because I stopped caring, but because the scores had converged close enough to my own judgment that almost nothing I genuinely wanted was slipping into the folder I never open.

I had externalized my taste. I had taken something that lived only as a feeling in my reading and written it down precisely enough that a machine could apply it at three in the morning to an essay I hadn’t seen yet. Once I trusted that the externalization was faithful, I stepped back and let it run.

That is a pipeline. The decision about what deserves my attention now happens before my attention is ever spent.

The Principles I Learned the Expensive Way

Not everything is worth automating. Not everything should be automated. And plenty of tasks that look like obvious candidates turn out to be terrible ones. Here is the checklist I now run before I invest a single hour in building a pipeline, with the Substack system as the worked example.

Low stakes, low drama. The best first pipeline is one where failure costs almost nothing. My scoring system failing means a good essay sits in the wrong folder for a week. I did not begin by automating anything where being wrong carried real consequence: no client deliverables, no anything that touched another person’s money or trust. You will need that forgiveness while you are tuning, because early on the system will be wrong in ways you didn’t predict, and you want those wrongs to be cheap.

Failures should be loud. This is close to the first principle but distinct, and the distinction is the whole game. The direction of failure matters more than its frequency. A pipeline that fails loudly, that produces an obviously wrong output you catch at a glance, is one you can fix. A pipeline that fails quietly, that produces a subtly wrong output that looks correct, will erode your work for months before you notice. Before I build anything I ask one question: if this gets it wrong, will the wrongness announce itself, or will it hide? If it hides, I don’t build it.

Repetition is the threshold. I have a rough rule. I do not seriously consider automating a task unless it eats at least an hour of my day, or it is something I do regularly that costs three or four hours each time. The sweet spot looks like this: a job that takes me four hours every week, where the pipeline does it in thirty minutes. That ratio is what justifies the cost of building. One-off tasks almost never clear the bar, because the time you spend designing the system exceeds the time the system will ever save. The inbox triage qualified easily; it was a tax I paid every single morning.

Classify, don’t interpret. This is the principle I hold most firmly, and I traced its full reasoning in a recent essay on discernment. AI cannot truly interpret. It cannot bring duration, formation, and skin in the game to its encounter with a text the way a human reader can; it processes the input in front of it in the present tense and the transaction ends. But AI is extraordinary at the adjacent task: classification. Sorting. Scoring against a rubric. Routing by criteria. The best pipelines hand AI the classification work and keep the interpretive work for yourself. The moment you catch yourself asking a model to make a judgment that requires genuine understanding of context, relationships, or stakes, you have found a step that must stay human. My rubric scores essays. It does not tell me what they mean.

Use the right model for the right role. This one took me a while, and it has made more difference than any single prompt I have ever written. Different language models have characteristic strengths, and a mature pipeline casts them like a director casts actors instead of defaulting to one model for everything.

In my pipelines, Claude is almost always my Red Hat agent. Before I commit to building anything, I hand Claude my implementation plan and ask it to attack: find the failure modes, name the assumptions, tell me what I am not seeing. When I designed the Substack scorer, Claude caught a problem I had walked right past. My rubric rewarded specificity, which meant a dense, citation-heavy essay would reliably score high even when its argument was wrong. The system, Claude pointed out, would learn to surface confident, well-sourced essays regardless of whether they were any good, and I would slowly let my reading be steered toward a certain texture rather than a certain quality. I added a separate axis for that. I would not have seen it until months of subtly skewed reading had already happened.

Gemini is the workhorse. For the repetitive classification, the scoring, the ingestion work that happens at volume, Gemini carries the load without complaint and without drama. Running multiple models in conversation with each other, each doing what it does best, is itself a form of pipeline architecture. You are no longer using AI. You are directing it.

Why the Outline Stopped Being For Me

When I fed that first outline into Gamma and watched the deck assemble itself, the thing that changed was not only my evening’s workload. It was my relationship to my own vision.

I started outlining differently almost immediately. More ambitiously, because the cost of ambition had dropped. More precisely, because precision now paid off instead of evaporating at eleven at night. I began adding markdown formatting, structural cues, little bracketed notes about tone and emphasis that were no longer for me. They were instructions to the system. Somewhere in there the outline quietly stopped being a sketch and became a specification, and I became, without quite deciding to, someone who writes instructions for machines as a primary creative act.

That is a strange thing to notice about yourself. It is also, I think, where the most interesting work is happening right now for knowledge workers who are paying attention. You are not just getting faster at what you used to do by hand. You are becoming someone who designs systems that produce work at a consistency and a volume you could never sustain manually. The advantage no longer lives in any single output. It lives in the architecture, and architecture compounds while you sleep.

Where to Start, Which Is Smaller Than You Think

If you have never built a pipeline, begin smaller than your ambition wants to.

Find one task that meets the four tests above: low stakes, loud failures, real repetition, and classification rather than interpretation. Write down every step of how you currently do it, by hand, in order. Then look for the steps that are repetitive and rule-based, the ones where you are applying a standard rather than exercising judgment. Those are your candidates. The judgment steps stay with you.

Write the rubric. The scoring guide, the classification criteria, the standard, whatever form it takes for your task. Be specific to the point of discomfort. The precision with which you can articulate what good looks like sets the ceiling on how well the pipeline will ever perform, because the rubric is your taste made legible to a machine. A vague rubric produces a vague system that you will never quite trust and never quite step away from.

Then build the simplest version that runs end to end. Spot-check it obsessively for the first few weeks, the way I did. Tune the guide where you and the system disagree, since the disagreement almost always points at a sentence in your rubric that was softer than your real judgment. Spot-check less. Then, one ordinary morning, notice that you have not checked it in a week and nothing has gone wrong.

That is the moment you have become, quietly and without any announcement, someone who delegates to AI rather than someone who merely uses it. It is a different kind of professional than you were a month earlier, and it takes some getting used to.

It is also, I am fairly sure, exactly where the work is going.

The first is the conversation of the enthusiasts. These are the people who speak of AI consciousness, of superintelligence arriving imminently, of machines that will soon do anything a human can do and more. In this conversation, the question of what AI cannot do is already settled: nothing. It’s only a matter of time.

The second is the conversation of the resisters: the faculty member, the humanist, the skeptic who waves the whole thing away as a parlor trick. AI becomes nothing more than a bad facsimile of thought that is simply probabilistic autocomplete dressed up in a lab coat. It is just not worth serious engagement other than to denigrate the inevitability of the enthusiasts leading society astray and profiting at the same time.

Both positions are wrong. We know that; and, that’s not really all that interesting to claim. What has always struck me as odd in this polarizing debate, though, is that each side is wrong in the same way. Neither the enthusiast nor the resister has looked carefully at what actually happens when a human being does the thing they are arguing about.

Two Kinds of Time

But let’s take a long and winding path to my point (as that is my specialty). In this case, let’s do it through the Greeks who had two words for time that English collapses into one.

Chronos is the time of clocks. It is the steady, measurable passage of moments, one after another, indifferent to what happens in them. Schedules. Deadlines. The blinking cursor waiting for your next input.

Kairos names the moments that rupture ordinary succession with meaning. The birth of a child. A diagnosis that changes everything. A conversation after which you are not quite the person you were before it. Kairos moments do not just pass. They land. They leave a mark.

Joseph Campbell, in The Hero with a Thousand Faces, documented something structural about this kind of moment. Every myth worth the name begins with rupture. The ordinary world cracks open, and the hero is addressed by something. For a more contemporary example, think of every Pixar movie made in the past decade. They start with a collapse or rupture or (usually) death. These are Kairos moments and it is why they resonate so strongly with us.

What Campbell more formally called the “call to adventure” is always kairos in this sense: it does not arrive as a problem to be solved but as a summons to which the hero must respond with their whole self. What he didn’t analyze — because it wasn’t his interest — is the quality of that moment before the response. Frodo doesn’t calculate probability of success. Luke Skywalker doesn’t run a cost-benefit analysis. They find themselves already inside the call before they’ve consciously chosen it. Wall-E doesn’t question helping Eve complete her mission. The rupture precedes the decision. The response comes from a self that has been changed by the encounter itself.

Why should we start with this distinction in time? Because discernment happens in kairos time. The enthusiast’s argument doesn’t. “It’s only a matter of time” is not a rhetorical gesture but a chronos logic stated plainly. The enthusiast measures AI progress the way one measures a runner approaching a finish line: MMLU benchmark scores climbing, bar exam percentiles crossing human-average thresholds, chess ratings eclipsed on the way to Go ratings eclipsed on the way to whatever benchmark gets nominated next. The frame is linear and additive. Capability accumulates; timelines compress. The question of whether AI can do any given human thing becomes a question of what, how, and when. What is the best way to fix the destination? How should we measure the distance remaining to that destination? When can we predict the arrival such that it makes the greatest impact on our audience?

The resister’s argument runs in the same time, though. It even seems to run at the same speed, just in the opposite direction. Where the enthusiast watches the benchmarks climb and sees convergence, the resister watches each individual output get produced and sees sophisticated autocomplete — statistically plausible but hollow. The critique is delivered entirely in the present tense: in this moment, with this input, the machine produces X; compare X to what a trained human would produce; note the gap. Both enthusiast and resister are measuring outputs against a shared timeline, agreeing on what the destination looks like, disagreeing only about proximity. Neither asks what kind of event intelligence is. Both ask only whether a given output arrives at the right coordinates.

I think both approaches are running a production analysis: does AI currently produce what humans produce, or will it eventually? But interpretation, recognition, and discernment are undergone more than they are produced.

Something happens to the one who thinks, who discerns; they are changed by it. They bring to it a self formed by previous encounters, previous losses, previous interpretations that remade them. That formation accumulates only in kairos time that defies an additive logic. No benchmark scores or token predictions get you no closer to understanding whether AI can participate in something that can’t be linearly and additively achieved.

So let me name bias out of the gate. When I speak of discernment, I am drawing on the Christian theological tradition in which I was trained, where it is most fully understood in the context of vocation or of calling. In that tradition, discernment belongs to a different order than decision-making. You do not construct a call; you uncover it. And the uncovering, when it comes, feels less like an arrival than like a confirmation of something you somehow already knew.

Thomas Merton’s account of his vocation is one of the most precise descriptions I know of what this feels like from the inside. In The Seven Storey Mountain, published in 1948, he describes applying to the Franciscan order and being rejected — then later recognizing that rejection not as a failure of discernment but as part of it. The call didn’t change when the Franciscans said no. It got clearer because what he had taken for a destination turned out to be a waypoint. The call was working on him before he had the right name for it. So when he arrived at the Abbey of Gethsemani in December 1941, the recognition he felt was retrospective even in the moment. It is the feeling of having been on the way longer than one recognizes being on the way. That quality — recognition that stretches backward as a confirmation rather than a discovery — is the first mark of genuine discernment.

What Actually Happens

The first thing a phenomenologist notices about discernment is that the usual boundary between self and world becomes strangely unstable. In ordinary decision-making, I stand apart from my options and evaluate them. I am the subject; the choices are objects. I weigh them, compare them, select one. The self doing the weighing remains intact throughout.

Simone Weil gave a precise name for the quality of this experience in her essays collected in Waiting for God. She called it malheur — her translators render this as “affliction,” though the French comes closer to “wretchedness” or “misfortune,” and the difference matters, because Weil’s concept is more precise than the English allows. This is more than the suffering that we might first think of when hearing the English word affliction. Suffering is something that can be endured at a distance; you can watch it, manage it, and wait for it to pass. Malheur, though, combines physical pain, psychological anguish, and social degradation simultaneously. All of these need to be present for it to be genuine malheur. And this is what is so distinctive about Wei’ls use of the term. This sensibility tears the afflicted person out of their habitual situation. It uproots. The person subjected to malheur cannot remain who they were because they cannot feel this at a distance or wait for it to pass. The experience of malheur stamps itself, according to Weil, on the soul to its very depths in an indelible way.

For those in the know about discussions of vocation, this connection to malheur may feel a little odd. We often talk about vocation in happier terms; something more like where our talents meet the deep needs of the world or where our abilities are a gift to those around us. That seems like a far cry from the wretchedness of malheur.

What makes this relevant to discernment, though, is not the suffering itself but the structural effect. Malheur removes distance. In ordinary experience, we maintain a managerial relationship to what happens to us: we process, we categorize, we recover, we move on. Malheur ends that relationship. There is nowhere to stand that is not inside it and we cannot escape it. The afflicted person can no longer inhabit the position of the observer who takes notes and then leaves. They are left with only the position of the one to whom something is happening. They must endure.

The call to discernment arrives with that same structural demand. Not always painfully (though sometimes perhaps more painfully than we want to admit), but with the same refusal of distance. You cannot evaluate the call from across the room. The moment you try, you have already misunderstood what it is asking. Weil’s broader philosophy turns on the concept of attention: a sustained, non-possessive openness to what is actually there, rather than what we project onto it. Malheur, at its best, creates the conditions for that kind of attention by stripping away the habitual defenses we use to avoid seeing clearly. The person who has passed through affliction can no longer take refuge in comfortable abstractions. They have been made too specific by what they have undergone. We don’t seek suffering in some kind of masochistic vocation for Weil, but we are granted a certain clarity in the brutal honesty of malheur.

This is the connection I am tracing. Discernment requires the same quality of attention that malheur enforces: a presence to what is actually happening, without the protective distance of pure analysis. The call comes for you specifically, in your particular formation, at this particular moment in the accumulation of your history. It does not present itself as a general case. What strikes you, when it settles, is how thoroughly interior it feels: less something happening to you than something being uncovered in you. And in this sense, I would suggest that the clarity of vocation comes inextricably with an existential demand of malheur that stretches our experience of time and cannot be contained in the simple series of day to day events.

What AI Is Actually Doing

AI is doing something real. When a language model produces an analysis, a synthesis, a classification, something is genuinely happening that has value. I use these tools every day and they make my work better.

But there is a categorical distinction between what AI does and what discernment requires. Discernment requires duration: the accumulated history of a self that has been shaped by time, that has skin in the game. AI has none of this. It has no history in the sense that matters: no formation, no wounding, no call. It processes what is in front of it in the present tense, always. Every moment for a language model is chronos: measurable, uniform, without the capacity to land differently than any other moment. It has no kairos.

Consider what kairos actually requires. For a moment to land — to rupture ordinary time and leave a mark — there must be something there for it to land on. A sense of self with enough accumulated history that the new event can mean something in relation to what came before. Kairos is not a feature of the moment itself; it is a feature of the meeting between moment and self, a self that has been shaped by time. AI may have the moment if we interpret generously, but AI never has the self.

All of which means there is no it to be claimed by a kairos moment for AI. A language model cannot find itself already inside a call, because nothing has been accumulating. It processes the input in front of it, returns an output consistent with its training, and the transaction ends. Nothing carries forward into the next session. No sediment. No residue. No formation. Every conversation begins at zero.

The industry has noticed. Context windows have expanded from thousands of tokens to millions. Persistent memory features allow systems to store and retrieve user preferences across sessions. Agentic workflows write to and read from memory stores, accumulating notes between runs. Context engineering has become its own discipline: the careful construction of layered system prompts that prime the model with history, persona, and prior decisions before the conversation begins. These are genuine engineering achievements aimed directly at the problem of duration.

But context engineering produces a bigger block. The context window expands; the model processes more of it; the outputs become more attuned to the user’s history and preferences. What doesn’t change is the relationship between the model and that context. The information was retrieved, engineered, or stored by a system. The model didn’t live through any of it. It was never changed by it. It encounters the context the way a reader encounters a briefing document: as information to be processed, not as experience to be integrated.

The test for duration is not whether a system has access to past events but whether those events changed the perceiver. Merton wasn’t informed about his vocation; he was formed by it. The Franciscan rejection didn’t add a fact to his database. It worked on him. It changed how subsequent events could be perceived and what they could mean in relation to what had come before. In short, formation is not accumulated information; rather, it is changed perception. And, that is precisely what no expansion of the context window can produce. Even as the parameters increase and the context window ballons, the model doesn’t get deeper.

And yet, the expansiveness of these engineering feats makes the practical stakes of this distinction harder to see. A model primed with rich context about your institutional history, your communication style, your prior decisions produces outputs that feel more present. It is as if the model has become more attuned to you in a way that is a facsimile of the presence and duration required for discernment. As everything feels more specific and less generic in the responses of the AI, we forget that this is just a facsimile. And the distance from AI required to use it at its best is difficult to maintain. Every time I apologize to AI for forgetting to tell it something or I explain context it does not need to accomplish its task, I fall into this trap. The attunement offered by the engineering of an approximation of duration is real. The authenticity of presence is not. The context was constructed before the conversation began. It doesn’t emerge from the encounter; it frames it. And the more sophisticated the framing, the more tempting it becomes to mistake the frame for the thing it frames.

What AI does is probability reasoning at an extraordinary level. Given this input, what output is most consistent with the patterns in my training? That is genuine decision-making: sophisticated, often stunning, genuinely useful for an enormous range of tasks. The gap between that and discernment is categorical, though; it is not a capability deficit that more compute will close.

Why This Matters

Understanding this distinction is what allows us to use these tools well.

In January 2023, Koko — a peer mental health support platform operating within Discord — disclosed that it had run an experiment in which GPT-3 co-wrote responses to users in crisis. Roughly 4,000 users received AI-assisted messages without knowing it. By the platform’s own metrics, the experiment was initially a success: response times dropped by half and users rated the AI-assisted messages higher than purely human-written ones. Then Robert Morris disclosed what had happened. Users who learned their messages were AI-generated stopped rating them well. Morris reported the experience stopped feeling right once people knew — not because the advice had gotten worse, but because the source had been revealed. The same words, rated better by every surface metric, rated lower once the origin was known. What stopped working wasn’t the content. It was the absence of the thing that makes one person’s words about suffering carry weight to another person in the same condition: that the words came from someone who has been in the dark, who carries that in their body, who brought their duration to the conversation and was willing to be affected by what you said.

If you mistake what AI does for discernment, that is to say if you assume it is genuinely interpreting, genuinely understanding in the full hermeneutic sense, you will give it tasks that require a self formed by time, and you will be confused or misled by what comes back. You will mistake fluency for wisdom. You will outsource the things that most need to remain yours. And likewise, if you dismiss AI as a bad facsimile of thought, you will miss the very real and very powerful thing it actually is. You will refuse a useful tool out of a misunderstanding of what the tool is for.

The question worth sitting with — and I mean sitting with in the kairos sense, with the weight it deserves — is which of the things you are currently doing actually require discernment, and which ones only felt that way because no one had built a tool to do them yet.

That question, I suspect, will be more unsettling than either end of the spectrum is prepared for.

I was trying to work through an idea (something about the difference between judgment and pattern recognition), and I knew I’d read something relevant. Several things, probably. But I couldn’t remember where, or when, or exactly what the argument was. I just had that feeling of knowing that I knew something without being able to get to it.

That feeling is one of the most frustrating things about reading a lot. The more you save, the more you have. But having something and being able to think with it are very different things.

If you’ve been following this series, you’ve been building toward something without necessarily knowing it. The first bot gave you a way to classify and capture Substack posts into a structured reading index: a plain text file called reading-index.jsonl with one line per article. The second bot gave you a clear-eyed description of your own writing voice. This third bot completes the picture.

Subscribe now

You paste in your reading index, and instead of just searching it like a database, the bot interviews you first. It asks what you’re trying to think through. It follows up with a question or two to sharpen the direction. And then it goes into your index and comes back not just with topically related articles but with conceptually related ones: including entries that might complicate or be in tension with your thinking in useful ways.

The interview step is the whole game here. A search bar matches your words to other words. This bot tries to understand what you’re actually trying to figure out before it looks. That’s a meaningfully different thing.

https://box.boodle.ai/a/@ReadingYourMind

This bot works on its own; you don’t need the first two essays in this series to use it, though all three work together in interesting ways. When you’re ready, paste in whatever reading list you have: the reading-index.jsonl from the first essay if you’ve built one, a Readwise export, a Notion table, a plain list with notes. If you also have a voice document from the Writing Style Analyzer, paste that in at the start too. Then let the bot lead.

The full instruction set, the logic behind it, and four ways to hack it are below the fold for paid subscribers.

Read more

They possess vague intuitions about their work. They can tell you if they lean toward the cerebral or the punchy, the formal or the colloquial. But if you demand a precise, technical breakdown of their linguistic DNA, akin to the autopsy a master editor or a seasoned writing coach would perform, they fall silent.

This isn’t a lack of self-awareness; it is a matter of proximity. Style is an invisible architecture. You are too close to the scaffolding to see the shape of the building. You have been writing this way for so long that your idiosyncrasies have become your baseline, much like an accent remains imperceptible to the speaker until they encounter a stranger.

The process is straightforward: you feed it two or three samples of your work, such as blog posts, newsletter drafts, essays, or whatever represents your actual output, and you define the trajectory of the writer you intend to become. The engine parses these samples to produce two distinct assets: a style profile that deconstructs your structural patterns, and a voice document that captures the essence of your unique resonance.

Think of the style profile as the diagnosis and the voice document as the mirror.

Combined, they move you beyond mere “vibes.” They provide a high-resolution map of your tendencies. This map serves as a document you can study, a brief you can hand to a collaborator, or a North Star to return to when your prose begins to drift into generic territory. Try it out yourself. To begin, gather two or three samples of your writing within the specific genre you aim to master. Do not curate them for perfection; curate them for authenticity. They do not need to be your best work, but they must be genuinely yours.

The Writing Style Analyzer

How to set it up in detail

Further down, for paid subscribers, you will find the complete instruction set encapsulated in XML tags, a structural diagram mapping the dual-output logic, and four distinct methods for extending the engine. If you’re a paid subscriber and implemented the subagent system I started with in “The Digital Graveyard”, the pattern will be immediately recognizable. If you missed that one, just check it out here:

And…don’t forget to subscribe so you can see the last installment of this little bot series!

Subscribe now

Read more

It is a sprawling, meticulously formatted repository of dead links, unread PDFs, and Substack posts I saved over the past year because I convinced myself I was “investing in my mind.”

It is the intellectual equivalent of buying a gym membership and expecting to get fit by staring at the plastic card in your wallet. We have access to more information and ideas than we could access in a lifetime, and so it makes sense that our first impulse is to archive that material. This is what many of us were trained to do within academia. We are the professional organizers and curators of what matters in our field. The problem is that saving something with an outmoded organizing system for its structural DNA is just hoarding with better intentions.

The rub lies in the cognitive tax of cataloging. When you are mid-read, you have exactly zero spare attention to think about where a piece belongs. You just want to capture the spark before it evaporates. So you toss it onto the pile, promising to file it away “this weekend”—a mystical period of infinite productivity that exists only in our imaginations.

This is where standard AI tools let you down. Ask a generic LLM to summarize a piece, and it hands you back a dry, bulleted compression that flattens the author’s argument. It strips out the voice, ignores the structure, and treats every document like a high-school book report. There is a reason we don’t like reading high school book reports: they are just a dumb, often stylistically overfit, compressor.

What you need is a cognitive filter. You need a system that understands how the author is thinking before it records what they said.

https://box.boodle.ai/a/@CognitiveFilter

You paste in a Substack post (either the URL or the raw text but make sure it actually reads the text if you give it a URL) and the engine performs a structural audit. It does not just ask “what is this about?” It asks: “what is this piece trying to do?”

Specifically, it classifies the argument into one of four distinct intellectual gears:

1. Factual/Empirical: The piece makes claims about what is true and how a system works.

2. Conceptual/Definitional: The piece redefines or reframes what something means.

3. Practical/How-To: The piece provides a repeatable, sequential recipe to achieve a specific outcome.

4. Philosophical/Values: The piece makes an argument about what matters and why.

This classification is the difference between a functional vault and a digital junk drawer. When you search your database six months from now, you are rarely searching for “that post about AI.” You are searching for “the conceptual argument that reframed AI as a partner rather than a tool.” Those are entirely different intellectual operations. By capturing the cognitive category at the moment of ingestion, you build a retrieval system designed for active thinking, not passive storage.

How to set it up

Below the fold, you will find the complete system prompt engineered with strict XML tags, a structural diagram mapping the logic, and a detailed breakdown of the cognitive mechanics under the hood.

I have also mapped out four advanced ways to hack this engine—including a terminal-native CLI setup using local developer agents like Claude Code or Cowork to bypass web interfaces entirely.

The complete, copy-paste prompt, the logic map, and four ways to hack it for localized CLI workflows are below the fold for paid subscribers.

Subscribe now

Read more

This is a lie we all agree to tell each other. That interaction isn’t engagement; it’s a mechanical transaction. It’s the bare minimum requirement to prove the student still possesses a pulse. The discussion board, as currently designed in 95% of higher education courses, is a graveyard of compliance. It requires students to perform a highly stylized simulation of academic discourse, stripped of all actual human friction. And now, generative AI has called our bluff. It can produce that exact, hollow simulation faster, cheaper, and with better grammar than the exhausted student at 11:47 PM.

The panic sweeping through universities isn’t actually about cheating. It’s about exposure. The AI didn’t break our pedagogy; it merely revealed that the pedagogy was already broken. If a machine can effortlessly pass your assessment, your assessment was testing mechanical compliance, not human cognition. We can no longer hide behind text-based busywork. We must redesign our asynchronous courses around verbs that require a physical body, a specific history, and a name.

There is a second layer to this crisis that the cheating panic is conveniently obscuring. While administrations deploy detection tools aimed at students, they are simultaneously deploying algorithmic management tools aimed at faculty. LMS dashboards track login frequencies, response times, and engagement rates. Predictive analytics flag instructors whose student outcomes underperform. Automated systems generate performance metrics from data points that were never designed to measure teaching quality. Faculty aren’t just navigating a broken pedagogy; they’re navigating a surveillance architecture that penalizes them for taking the time to redesign it. Anticipatory compliance — the cognitive work of predicting and satisfying an opaque evaluative system — drains the exact bandwidth required to fix the problem it’s purportedly monitoring.

What follows is a strategic blueprint. These are not minor tweaks to your syllabus; they are structural replacements for the standard discussion board. They are designed to be entirely AI-resilient not by blocking the technology, but by rendering its capabilities irrelevant to the core task.

Pattern 1: The Asynchronous Studio

Stop asking students to write summaries. Start asking them to build artifacts. The Asynchronous Studio model shifts the deliverable from a block of text to a visual, structural representation of knowledge. We don’t want a 500-word essay on the differences between two theoretical models; we want a node-and-edge system map drawn on a whiteboard, photographed, and uploaded.

Why does this work? Because while AI can generate the text of a system map, translating that abstract output into a spatial, visual logic requires human synthesis. It requires the student to make physical choices about proximity, hierarchy, and connection. It forces the abstract into the concrete. The studio model also demands vulnerability. A messy whiteboard sketch with arrows crossed out and redrawn is a forensic trail of cognition. An AI produces a pristine final output; a human produces a history of revisions. Grade the history, not just the output.

When a student presents their map — often via a short screen-recording where they point to specific nodes and narrate their logic — they are embodying the knowledge. They are attaching their voice, their physical presence, and their specific cognitive struggle to the material. This is an un-simulat-able event. It raises the floor of engagement and makes the counterfeit impossible.

The student who photographs a whiteboard they copied from an AI-generated system map has still had to choose how to draw it in physical space. That physical act creates something the AI didn’t make: a specific spatial interpretation. A professor can see the handwritten nature, the revision marks, the idiosyncratic layout choices. If a student presents a perfectly typed, zero-revision map, that is its own forensic finding. The format exposes the shortcuts it cannot hide.

The studio model is most powerful in text-heavy disciplines — policy analysis, philosophy, sociology — precisely because those fields have the strongest incentive for students to default to AI-generated prose. A whiteboard sketch of a Foucauldian power analysis is more cognitively demanding than a 500-word essay on it, not less, because the student must translate from a discursive grammar into a spatial one. Deploy this where you least expect it to work.

Pattern 2: The Erased Peer Thread

The standard peer-reply prompt (”Respond to two classmates...”) is the most heavily counterfeited interaction in modern education. It is practically begging for automation. The Erased Peer Thread disrupts this by demanding synthesis over simple reaction. Instead of replying to individuals, the student is tasked with reading the entire thread of the week’s conversation, pulling out the three most dominant themes, and then explicitly identifying the one critical perspective that the entire cohort missed.

This is what we call Negative Space Synthesis. The AI can easily summarize what was said. It struggles profoundly to identify the localized, specific context of what wasn’t said by this particular group of human beings. To succeed, the student must use the AI’s summary as a baseline, and then push past it. They must say: “The AI summary notes we all focused on policy implementation. But looking at our actual posts, none of us mentioned how this impacts our specific demographic in the Midwest. That’s our blind spot.”

This completely inverts the value of the discussion board. The posts themselves are no longer the final product; they are the raw data for a higher-order analytical task. The student becomes an auditor of their own community’s blind spots. This requires a level of contextual awareness and relational intelligence that an LLM simply does not possess.

The faculty member’s role shifts from respondent to curator. Instead of grading 30 individual posts, they receive 30 audit reports identifying the cohort’s collective blind spots. These reports surface the actual topology of the class’s understanding at a glance, which is more pedagogically useful than reading 30 versions of the same argument with slight variation. The discussion board stops being a performance venue and becomes an object of shared inquiry.

The second-order effect on students is equally significant. Being asked to identify what the cohort missed forces students to read each other’s posts with genuine analytical attention rather than performing reaction. They cannot produce the audit report without actually reading the thread. Engagement stops being a word they use to describe the activity. It becomes the activity itself.

Pattern 3: The Relational Corkboard

If the discussion board is a linear timeline of disconnected thoughts, the Relational Corkboard is a spatial map of collision. In this pattern, students don’t write self-contained essays. They contribute single, hyper-specific artifacts — a photo from their workplace, a scanned primary document, a recorded interview snippet — to a shared digital space like a Miro board or Padlet.

The assignment isn’t to post the artifact; the assignment is to draw the connections. Student A must visually link their artifact to Student B’s artifact, providing a specific, localized rationale for why these two pieces of reality interact. “My photo of the zoning notice connects to your interview with the local business owner because...” That sentence is the assignment.

This is impossible to automate because the variables are entirely localized and contingent. The AI cannot pre-compute the connections between a specific zoning notice in Ohio and a specific interview in California. The knowledge is created live, in the friction between students’ unique, embodied realities. The course content becomes the lens through which they analyze each other’s worlds, rather than a static text they all passively consume.

When grading the Relational Corkboard, the instructor evaluates the quality and specificity of the rationale, not the artifacts themselves. Vague because-statements (”they are both about local governance”) indicate surface-level engagement. Specific because-statements (”they both document the moment an abstract regulatory category hits a specific human decision under economic pressure”) indicate genuine contact between the materials and the student’s theoretical vocabulary. The word “because” is where the grade lives.

The corkboard evolves across the semester as a collective artifact. Each week’s contributions don’t disappear; they accumulate into a growing map of the cohort’s collective reality. By week ten, the board is a semester-long record of how a specific group of humans at a specific moment thought through a specific set of problems. That artifact cannot be replicated, purchased, or AI-generated. It is, literally, a historical document of this cohort’s intellectual life.

Pattern 4: The ‘Show Your Math’ Protocol

When students inevitably use AI to draft their initial thoughts — and they will, and they should — we must capture that interaction. The ‘Show Your Math’ protocol requires students to submit not just their final deliverable, but the specific prompt architecture they used to generate their baseline, the AI’s output, and a detailed Autopsy Report of where the AI failed.

The grade is determined entirely by the Autopsy Report. The student must demonstrate where the AI hallucinated, where it flattened a complex nuance, or where it failed to account for a specific context discussed in week three’s lecture. We are no longer testing their ability to generate text; we are testing their ability to critically audit a machine’s logic against a rigorous academic standard.

This is the ultimate realization of the Zero-Trust approach. We do not trust the AI’s output, and we do not ask the student to trust it. We ask the student to dismantle it. By making the AI the subject of the critique rather than the hidden author of the submission, we drag the entire process into the light. The machine is a baseline, not a ceiling, and the student’s value lies in the rigorous, human application of skepticism.

The Autopsy Report has a specific structure to enforce. Students must identify (a) where the AI hallucinated or fabricated, (b) where it flattened a specific nuance the course material requires, and (c) where it failed to account for something discussed in an earlier week of the course. That third category is the most demanding and the most valuable: it requires the student to hold the full arc of the course in mind simultaneously and apply it as a critique of the machine’s output. It cannot be faked without doing the work.

The ‘Show Your Math’ protocol also builds a skill that will outlast the course. The student who has written ten Autopsy Reports over a semester has developed a specific epistemic capacity: the ability to identify where probabilistic output meets the limit of its own training. That skill is transferable and professionally valuable in a way that no summary or discussion post ever was. They leave the course knowing how to use AI correctly — not as an answer machine but as a starting condition.

Pattern 5: Asynchronous Triage

Stop treating every student communication as equally urgent. They aren’t. Deploy AI to continuously scan incoming posts, emails, and submissions for semantic markers of urgency, distress, and deep conceptual confusion. The AI’s role here is not to respond — it is to prioritize. The faculty member receives a sorted queue: the student in academic crisis at the top, the logistics question at the bottom.

The cognitive release valve this creates is immediate. Faculty stop expending finite attention on the inbox as an undifferentiated mass and start directing that attention toward the students who need human intervention most. In a course of 80 students, the difference between triaging Monday morning and responding to the highest-urgency cases Monday morning is the difference between presence and performance. The AI doesn’t replace the intervention. It makes the intervention findable.

One constraint is non-negotiable: do not route triage outputs to auto-responses. The moment an AI-generated reply replaces a faculty reply, you’ve reinstated the Proxy view through the back door. Triage is for human decision-making, not human replacement.

Students in academic crisis rarely announce it. They use language like “I’m not sure I understand” or “I keep getting lost” combined with submission patterns that suggest late-night, last-minute work. The AI triage tool learns to flag these combinations — linguistic distress signals paired with behavioral data — and surfaces them before the student disappears from the course entirely. Early intervention at week three is categorically easier than rescue at week ten.

The triage system also reveals patterns the individual instructor cannot see. When three students in different time zones all flag confusion on the same concept in the same week, the triage report surfaces that pattern. The instructor didn’t receive three scattered emails to parse individually; they received a single signal: this concept is failing this cohort. That’s the difference between an inbox and a diagnostic instrument.

Pattern 6: The Drafting Scaffold

Faculty burnout in asynchronous courses is disproportionately driven by the cognitive exhaustion of generating individualized feedback at scale. The blank page for each student is a discrete cognitive load event. Multiply it by 40 submissions and the evening is gone before the thinking begins.

Deploy AI to generate draft feedback frameworks — grounded strictly in the faculty member’s rubric and pre-approved examples — for each submission. The faculty member’s task is not to accept the draft. Their task is to audit it, inject pedagogical voice, and add the relational specificity the AI cannot synthesize: the reference to week three’s discussion, the callback to the student’s professional context, the observation about where their thinking has developed since midterm.

The AI defeats the blank-page problem. The faculty member defeats the impersonality problem. The combined output is faster than writing from scratch and warmer than anything a token-prediction engine could produce alone. A useful test: if the faculty member’s edits are minimal, the feedback wasn’t worth sending.

Building the scaffold correctly matters as much as using it. The draft the AI generates must be rubric-grounded, not free-form. If the AI generates feedback that scores well on the rubric but has no relationship to the specific student’s actual work, it produces technically acceptable feedback the student cannot act on. The faculty member must pre-configure the AI with the rubric, with the week’s specific learning outcomes, and with examples of what good feedback looks like in this context. The quality of the scaffold depends entirely on the quality of the inputs.

When faculty have cognitive budget freed from generating content-level feedback from scratch, they can spend it on the relational register. The callback to the student’s professional context. The observation about growth since midterm. The question that pushes the student’s thinking one step further. Students receive feedback that is structurally complete because of the AI and personally meaningful because of the faculty member. That combination is more useful than either component produces alone.

Pattern 7: Dynamic Resource Adaptation

Most asynchronous courses are static. Faculty design materials in August and watch students struggle with the same module in November that students struggled with last year, because there’s no feedback loop early enough to intervene. AI can close that loop.

Deploy predictive modeling to track cohort-level progression through asynchronous materials. When a significant percentage of the class is stalling at the same point — failing a module, clustering on the same wrong answer, dropping engagement in the same week — the system flags the instructor before the exam reveals the damage. The instructor records a targeted micro-lecture, three to five minutes, addressing the specific misconception. Pushes it to the course.

This is Teaching Presence at scale, deployed at the moment of maximum utility, without requiring one-on-one remediation. The AI cannot write the micro-lecture. The faculty member cannot detect the pattern at 80-student scale without the AI. Neither produces the outcome alone. That partnership is the point.

The micro-lecture format matters. Three to five minutes, not fifteen. One specific misconception, not a general module review. Students who are not confused about this concept can skip it. Students who are confused need precisely this, not a full re-lecture. The specificity is the feature. A faculty member who produces a broad “let me review chapter four” video is not responding to the diagnostic signal; they are defaulting to the safe option because specificity requires reading the signal accurately.

Over multiple semesters, the adaptation data becomes institutional knowledge. The points where cohorts stall are not random. They reflect genuine conceptual difficulty in the curriculum design. A faculty member who has three semesters of triage data showing that students reliably fail to connect the theoretical framework in week six to the applied cases in week seven doesn’t have a student problem — they have a curriculum sequencing problem. The AI’s cohort-level diagnostics, accumulated over time, are a form of curriculum research that currently requires formal course evaluation to produce. Dynamic adaptation makes that research continuous and automatic.

The Governance Prerequisite

These patterns can be built. They will not sustain themselves. The reason AI implementation in higher education keeps producing surveillance instead of support isn’t that the technology is irredeemably hostile — it’s that the governance structures shaping deployment are controlled by the wrong people. Vendors bake “engagement” metrics into LMS dashboards without defining what engagement means pedagogically. Administrators deploy productivity tools without asking what productivity means in a teaching context. Faculty are evaluated by algorithmic schemas they had no hand in designing and no formal process to contest.

Participatory governance is not a soft recommendation. It is the architectural prerequisite for every pattern in this document to function as intended rather than be weaponized by the institution’s monitoring apparatus. Standing co-governance bodies — faculty, instructional designers, IT staff, students — must possess actual authority over the algorithmic schemas that govern their institutions. Not advisory roles. Decision-making authority over what gets tracked, how it gets weighted, and what triggers an intervention.

The data infrastructure itself needs to be redesigned as a subject-preserving system: multiple overlapping categories instead of reductionist risk scores; narrative fields that allow faculty and students to contextualize what quantitative data cannot capture; formal contestation mechanisms so that an algorithmic flag can be challenged rather than silently accepted as a verdict. When an AI flags a student as “at risk,” that flag is a prompt for human inquiry, not a verdict. Build the architecture to enforce that interpretation, or the patterns above will eventually serve the surveillance infrastructure instead of the students.

What contestation looks like in practice: when a student is flagged as “at risk” by a predictive algorithm, there must be a direct, accessible mechanism for the flagged individual to add context, correct factual errors, and have the flag re-evaluated by a human with pedagogical authority. Not an appeal to a committee that meets quarterly. An immediate, low-friction process. Without that mechanism, the flag becomes a verdict. With it, the flag remains what it is: a probabilistic estimate generated by a system that doesn’t know this person.

Governance is not a one-time design decision. The algorithmic schemas that govern an institution’s AI tools will drift as vendors update their products, as institutional priorities shift, and as the student population changes. The co-governance body must have a regular review cadence — quarterly at minimum — with authority to demand transparency from vendors about what changed and why. An institution that establishes governance once and considers the problem solved has not established governance. It has established the appearance of governance, which is more dangerous because it forecloses the scrutiny the problem requires.

The Imperative of Implementation

These patterns are not theoretical. They are structural blueprints ready for immediate deployment. The 18-month committee review process for pedagogical change is a luxury we no longer have. Every semester we delay, we are training thousands of students that compliance is more valuable than cognition, and that a simulated presence is an acceptable substitute for a human life.

Audit your syllabus. Find every verb that can be executed by a machine in a vacuum — “summarize,” “describe,” “respond” — and replace it with a verb that requires a physical body and a specific history: “map,” “audit,” “connect,” “dismantle.” The future of the university depends entirely on our ability to distinguish between a generated output and a human event. Build the event.

Start with one pattern, not seven. The faculty member who attempts to implement all seven patterns simultaneously will implement none of them well. Each requires different preparation, different rubric infrastructure, different student onboarding. Pick the pattern that fits the learning outcome where you most often feel like you’re reading compliance rather than cognition. Deploy it for one semester. Document what breaks. Iterate from there.

Build peer infrastructure, not just personal practice. The greatest implementation failure in pedagogical innovation is the lone-adopter problem. A single faculty member deploying the Erased Peer Thread in one section, surrounded by colleagues running standard discussion boards, will produce students who treat the anomalous course as an outlier requiring extra effort rather than a model for how learning works. These patterns require a cluster of adopters who can cross-reference implementation experiences, share adaptations, and collectively negotiate with administration for assessment structures that accommodate forensic grading. The pedagogy is social. The implementation must be too.

The measure of success is not completion rates. The standard metric for asynchronous course quality is completion and satisfaction — neither of which measures cognitive engagement. A student who completes every assignment at compliance level is not a success story. A student who produces a single Autopsy Report that genuinely identifies where a language model failed against a specific theoretical standard has demonstrated more rigorous thinking than a student who submitted twenty hollow discussion posts. Redesign what you count before you start counting.

Instructors who teach asynchronously know this shape. They have learned to value it. They have built rubrics around it — the hesitant prose that wanders before it arrives, the named specificity that signals genuine contact between abstract theory and lived reality. For two decades, this shape functioned as a reliable signal of authentic intellectual presence.

Then, beginning roughly in late 2022, instructors began receiving posts that looked exactly like it, generated in forty seconds by a system that had read enough graduate seminar discussions to know what authentic intellectual struggle sounds like from the outside. The signal was not corrupted. It was replicated. And that replication is not a technical problem. It is a structural inversion of what authenticity means as a pedagogical category, and the dominant institutional responses to it have made the problem worse by misdiagnosing it.

The Neurocognitive Architecture of the Crisis

The reason this crisis is structural rather than superficial lies one level beneath pedagogy, in the mechanics of how the brain maintains contact with reality. The Predictive Processing framework — the predominant paradigm in contemporary cognitive science — describes the brain not as a passive receiver of sensory data but as a perpetual prediction machine. Before a single stimulus arrives, the brain has already generated a hierarchical model of what it expects to encounter. It then resolves the discrepancy: the gap between what it predicted and what it actually received. Learning, attention, presence — all of these are forms of prediction error management.

In a synchronous classroom, the instructor operates inside a dense field of high-precision feedback. Micro-expressions, posture shifts, the ambient sound of a room that is confused or confident — these signals resolve prediction errors continuously and unconsciously. The brain recalibrates in real time. None of this requires deliberate effort. The environment does the work.

The asynchronous environment severs this entirely. When a faculty member posts an assignment into a discussion board, they launch a series of top-down predictions into a sensory void. The response — if it comes — arrives hours or days later, decontextualized, stripped of every modality that would allow precision weighting. The brain cannot close its loops. It keeps generating cognitive load to manage the uncertainty long after the teaching has ended. This is not metaphorical exhaustion. It is a measurable neurocognitive burden: the computational cost of a mind unable to resolve its own predictions.

The Abstraction Habituation Model takes this to its most disturbing conclusion. Sustained high-level abstract work — inferring student comprehension without visual cues, designing curricula for hypothetical future interactions, communicating through text interfaces that flatten every signal — neuroplastically adapts the brain to default to abstract processing. The neural networks that support somatic grounding and psychological recovery weaken through disuse. The faculty member who is most expert at asynchronous teaching is, paradoxically, the one whose capacity to recover from it has been most thoroughly eroded. The system burns its best practitioners fastest.

Into this already-depleted cognitive environment, institutions then introduce algorithmic management. The LMS tracks login frequency, response times, and engagement rates. Automated dashboards feed opaque evaluative models. Faculty develop what organizational researchers call anticipatory compliance: preemptively adjusting their behavior to satisfy an algorithm whose rules they cannot fully derive. They alter their syllabi. They generate superficial discussion posts because a quota exists for it. The cognitive burden shifts from pedagogical innovation to algorithmic pacification. This is not a side effect of the institutional response. It is the response, working exactly as designed.

Understanding the crisis this precisely changes the prescription. The problem is not that students are cheating. The problem is that we built an entire assessment architecture on prediction-error signals that a generative model can now produce at zero cost. The question is not whether the student wrote the post. It is whether the architecture was ever capable of reaching the student at all.

The Arms Race With No Exit

The institutional response to AI-generated academic work has followed a consistent logic: identify the authenticating signals, protect them, verify them, detect their absence. This logic feels responsible. It is the same logic that built plagiarism detection tools in the early 2000s, and those tools worked well enough, for long enough, to become infrastructure. So the playbook repeated itself: detection tools retooled for AI, proctoring software expanded into cameras and keyloggers and browser lockdowns, assignment prompts redesigned to demand localized detail that AI, in theory, could not fabricate. The theory is that if you can name the thing you’re protecting, you can protect it.

The theory is sound. The practice dissolves on contact with its own premise. Every time educators name a signal of authentic human presence, they are, in the act of naming it, providing a specification for a training target. “Write with hesitations.” “Include a personal anecdote.” “Reference a specific local event.” These instructions do not outsmart the generative model. They prompt it.

The arms race cannot be won on detection’s terms because the same generative capacity that produces counterfeit signals also produces counterfeit absences of those signals. There is no second-order authenticating mark that could not eventually become a first-order generative target. Naming the thing you want is sufficient to produce an approximation of it, and approximations improve with every iteration of the model.

What the arms race framework misses is that it is fighting over the wrong variable. The question “is this human?” is, under generative AI, increasingly intractable. The question “where is the human in relation to what AI would have generated?” is tractable. Replacing the first question with the second does not require new detection technology. It requires a reframing of what the assignment is for.

The arms race carries a secondary damage that its architects rarely acknowledge. When institutions invest their structural resources in detection and surveillance — LMS dashboards monitoring faculty behavior, proctoring infrastructure aimed at students, AI detectors generating false positives — they redistribute the cognitive budget available for reimagining pedagogy. Faculty spend their finite attention managing compliance on both ends: their own and their students’. The framework consumes the bandwidth that would otherwise fund its successor.

Making the Counterfeit Mandatory

The institutional reflex has been to deploy AI as a surrogate — something that stands in for the student’s thinking, for the instructor’s feedback, for the human whose absence needs to be disguised. Call this the Proxy view. It is architecturally bankrupt, because a token-prediction engine cannot bear pedagogical responsibility. The alternative is the Ensemble view: AI as a bounded cognitive artifact, surfacing what is otherwise invisible, in the service of a human who remains the authoritative agent. Every recommendation that follows operates from that distinction.

The student’s first task is to read that output carefully. Their second task is to find the places where it sounds like everyone and no one. The flattened analogy. The hedge that applies to every case. The moment of apparent vulnerability that resolves too cleanly. The student does not evaluate the AI output as good or bad writing. They audit it as a map of what thinking looks like when it has been averaged across all prior instances of this type of thinking.

Their actual assignment is to produce something that diverges from that map in ways they can specifically account for. Not random divergence. Accountable divergence. The idiosyncratic detail they chose because it came from their Tuesday, not from a generalized Tuesday. The theoretical connection they made that the model did not make because it required knowing something about their specific cohort, their specific institution, their specific relationship to the material.

The graded artifact, under this method, is not the final post. It is the documented record of the divergence: the annotated version of the AI baseline with the student’s marginalia explaining exactly where they departed and why, followed by the piece they actually wrote.

A skeptical practitioner will immediately raise the second-order problem: what stops a student from generating the baseline, then generating the divergence, then generating the annotated marginalia, all in sequence? Nothing, fully. The counterfeit-of-the-counterfeit is possible. But producing a convincing second-order counterfeit requires understanding the structure of the first-order counterfeit well enough to simulate diverging from it, which requires engaging with the AI output as a diagnostic instrument. The method raises the floor of required cognitive engagement even if it cannot build a ceiling above it. It does not solve the problem. It relocates it to a level where the student’s intellectual investment becomes a more necessary condition of the output.

Mapping the Absent: A Theory of Negative Space

There is a philosophical implication in this method that most practitioners implementing it will not have named explicitly. When we require students to identify where the AI baseline fails to capture their specific intellectual contribution, we are defining humanness negatively and dynamically rather than positively and statically.

We cannot enumerate in advance what authentic contribution looks like, because any positive description we provide becomes a generative specification. But we can define authentic contribution as whatever a given model, given a given prompt, systematically fails to produce. That definition does not require us to know the shape of humanness in advance. It derives the shape from the residue left behind by the machine’s most complete attempt to approximate it.

The negative space is not a fixed object. It is model-specific and prompt-sensitive. Different systems, different temperatures, different training corpora produce different baselines, and the residue they leave behind shifts accordingly. The diagnostic instrument is a calibrated sample, not a ruler, and instructors using this method should treat multiple baseline samples across models and formulations as producing a more reliable profile of the space the human needs to inhabit.

Even with that qualification, the counterintuitive consequence holds: improving AI models are not the enemy of this pedagogy. They are its continuously improving calibration instrument. A more capable model leaves a smaller, more precise negative space behind it, which means the space it does not fill is more specifically human. The educator does not need to chase the frontier of AI capability. The frontier of AI capability refines the definition of what they are trying to cultivate.

Think of the early cartographers mapping the globe. The blank spaces on their maps — the terra incognita — were not failures or signs of incompetence. They were the precise limits of verified observation, named and bounded so that navigators knew exactly where the known world ended and the undocumented world began. The AI baseline operates on the same logic. It maps the known, statistical, historical territory flawlessly. The blank space it leaves behind is the exact domain where the student’s specific, embodied history must navigate. Instruct them to sail off the edge of the machine’s map.

Omnipresence as Scaffold

The anti-rubric method addresses counterfeiting. A related structural problem persists alongside it: the eradication of the verb. When AI can generate the product instantaneously, the process that was supposed to produce the product is no longer the path of least resistance. The question is whether the pedagogy can reconstruct the necessity of the journey.

Simultaneous Constraint Formalization offers an architectural answer. The AI holds the complete structural, theoretical, and formal constraint-space of the assignment in continuous suspension. Every rule, framework, citation format, and contextual requirement is available to the AI simultaneously, without the student needing to maintain any of it in working memory. The student’s entire available cognitive load is freed for the singular act of embodied, located, particular engagement with the material. We must design our courses to leverage this partnership explicitly, reinvesting the cognitive friction previously spent on formatting and basic synthesis heavily into embodied contact.

A legitimate objection must be named here. In many disciplines, holding multiple frameworks simultaneously in working memory is not separable from the intellectual act. The difficulty of the simultaneous constraint is the learning. Offloading it to AI in those contexts does not free the student for deeper engagement. It removes the friction that produces depth. This framework is not a general theory of cognitive offloading. It is a claim about a specific category of learning outcomes: those that require the student to bring a generalized framework into genuine contact with an irreducibly particular reality, where constraint-maintenance and the act of contact are genuinely separable cognitive tasks. For that category, the redistribution holds.

What the schema calls “the touch” is a precise description of the intellectual act that the architecture is designed to make necessary: bringing the abstract into real contact with the singular, the located, the bodied. The AI holds the matrix of possibilities flawlessly. The student provides the irreplaceable point of contact. We do not evaluate the scaffolding; we evaluate how the student lives within it — whether they merely occupied the structure the AI built, or whether they remodeled it, broke down its walls, and forced it to accommodate their specific reality.

This arrangement has a theoretical name. Distributed Cognition — the framework that recognizes cognitive processes as distributed across people, tools, artifacts, and environments — describes exactly this relationship. The AI is not replacing the student’s thinking. It is acting as a cognitive artifact within a distributed system: holding specific computational functions so that the human node can concentrate its irreplaceable capacity on the tasks that require a body, a history, and a stake. The system is not impoverished by the distribution. It is more capable than either component would be alone.

What the Touching Is

The framework’s critics will eventually arrive at the following objection, and it is serious enough to deserve a direct answer. If authentic human intellectual contribution is defined as whatever AI fails to generate, then the framework is not a theory of human flourishing in education. It is a theory of productive obsolescence: as AI improves, the gap it leaves behind narrows, and the domain of authentic human contribution shrinks with it. On this reading, the framework is not a defense of the human. It is a managed retreat.

The objection has force precisely because it correctly identifies that this framework defines human intellectual contribution relationally — always in reference to what AI produces — rather than absolutely. That relational definition does seem to make the human derivative of the machine. The concern is not irrational. But it arises from a conflation that deserves unpacking: the difference between defining something by what it is and calibrating our instruments to detect what it is. A telescope does not define a star; it reveals one. The objection mistakes the instrument for the definition, and that mistake leads it to the wrong conclusion about what the framework is actually claiming.

The argument does not say that authentic contribution is the gap. It says that the gap is the diagnostic instrument through which the authentic contribution becomes legible to assessment. These are different claims. The first would make humanness parasitic on AI’s limitations. The second makes AI’s output a mirror that reflects what was already present in the human subject but was previously invisible to the grading apparatus.

The positive account of what that human subject brings is recoverable from the schema’s structure. What the student provides, in every one of the learning outcomes, is locatedness. The discussion post that matters is the one that comes from a specific body in a specific place on a specific Tuesday, with a specific history of relationships and a specific set of stakes in the outcome. The theoretical connection that the AI does not make is the one that requires knowing what it felt like to be in that hallway, on that day, with that particular disagreement unresolved. This is not a gap in the AI’s capability. It is a description of what embodied, temporally located, relationally embedded consciousness is.

Merleau-Ponty described perception as fundamentally motored: we do not apprehend the world from a neutral vantage point but from within a body that is already engaged with, already in contact with, already structured by its relationship to the things it perceives. What the schema calls “the touch” is this insight operationalized as a grading criterion. The student’s irreducible contribution is not their knowledge of the abstract framework. It is their situated, bodily, temporally particular act of bringing that framework into contact with a reality that only they inhabit.

AI does not inhabit a reality. It processes a corpus. The difference is not one of degree. It is categorical. A language model has no Tuesday. It has representations of Tuesdays, distributed across its training data, averaged into a statistical structure that knows what Tuesdays tend to produce but has never been in one. The student who writes from inside their Tuesday is not adding color to a framework the AI could have provided. They are performing the only act the framework cannot perform on its own: contact with the actual.

This is why the framework’s validity is not contingent on AI’s limitations. If a future model could generate a convincing simulation of “this specific Tuesday, this specific hallway, this specific disagreement,” it would not be performing the same act as the student. It would be constructing a plausible fiction of that act. The distinction between contact and its simulation is not detectable by output comparison alone, which is precisely why the framework relocates assessment away from the output and toward the documented process that precedes it. The student’s annotated version history, their raw voice memos, their timestamped observations: these are not better outputs. They are traces of an irreducible ontological condition. The student was there. No model is anywhere.

The Delay Was Never the Deficiency

Presence — in the neuropsychological sense — is the state of perceived successful agency: the moment when the brain’s predictions about its environment are confirmed, and prediction error collapses. It is not a feeling. It is a computational event. In a synchronous setting, it happens constantly and unconsciously. In an asynchronous setting, it must be deliberately constructed. And the only material available to construct it with is accumulated time — evidence that a mind was actually here, wrestling with this, before it replied.

Among the learning outcomes that distinguish asynchronous formats, Relational Weaving carries the most radical reframing of what the format is for. Relational Weaving is not a social activity grafted onto an academic one. It is the intellectual act of carrying another person’s incomplete idea into your own week — sitting with it, noticing where it surfaces in unrelated contexts, letting it accumulate the texture of lived time before you respond to it. The apparent structural weakness of asynchronous learning — the temporal stretch, the delay between messages, the absence of the immediate social feedback loop that keeps synchronous discussion honest — is precisely the resource that a deliberate pedagogy of care can leverage. The format’s most criticized feature is the one that is most difficult to replicate.

Temporal Flattening commodifies human interaction by making it instantaneous. The AI can generate a response to a peer’s argument in two seconds that mimics the relational warmth of someone who has thought about that argument for three days. The flattening erases the temporal signal that, in embodied communities, marks genuine investment: the fact that someone carried your idea with them into the rest of their life before responding.

The counter-move is not to artificially slow responses. It is to make the temporal investment visible and graded. When a student records an audio note four days after a peer’s initial post, references the specific turn in that peer’s argument they have been sitting with, and connects it to something they noticed in an unrelated context that week, they are performing something AI cannot generate: the proof of accumulated time, the demonstration that the idea was present in a mind that was also present in a body, living a life.

This is only possible if students are genuinely inhabiting the interval between posts rather than treating the forum as a box to check before the deadline. That requires course design that makes the interval legible as a site of learning rather than a waiting period between submissions. It requires assignments that ask not only what the student thinks but when they thought it, what they were doing when the idea landed, what other context it collided with. The temporal architecture is a resource, but it only functions as one if the course structure forces students to use it — and that forcing requires deliberate design choices the instructor must make before the semester begins, not accommodations they can make once engagement has already failed.

What This Framework Cannot Do

The schema’s full logic depends on instructors having the capacity and institutional support to assess cognitive exhaust rather than polished product. Most grading rubrics are built to evaluate what students produce, not the documented trace of how they produced it. Retooling toward forensic assessment requires not just a different rubric but a different theory of what the assignment is for, and institutional cultures that have spent decades optimizing for legible, comparable, auditable outcomes will resist that retooling with structural force.

It also requires students who have been prepared to understand why the mess is the point. A student trained across years of schooling to hide their drafts, smooth their uncertainty, and present only the polished result will not automatically understand that the annotated record of their struggle is what the instructor is after. The framework does not install itself.

This is a theoretical framework developed from a carefully constructed schema, not a research program. The empirical questions remain open. Whether the anti-rubric method measurably increases authentic intellectual engagement, whether forensic grading produces the relational outcomes the schema predicts, whether the temporal enactment of care actually builds the cohort fabric it theorizes: these are testable claims that have not been tested at scale. The argument made here is structural. Its validity is a separate question from its efficacy, and conflating the two would be a disservice to both.

The institutional infrastructure works against this framework in specific and predictable ways. The LMS dashboards that grade faculty by response time and engagement metrics are calibrated for exactly the kind of legible, auditable interaction the framework is trying to replace. An instructor who grades the annotated divergence instead of the polished essay is producing assessment artifacts that don’t fit neatly into completion-percentage dashboards or automated grade-book audits. The governance structures most likely to resist forensic assessment are the same ones already deploying algorithmic management to enforce the old paradigm. Implementing this framework without attending to that governance layer is designing a pedagogy that will be quietly strangled by the infrastructure it inhabits.

Finally, the framework assumes that students have lives complex enough to generate productive contact points. The student who works thirty hours a week, who is managing a family crisis, who is cognitively depleted by the time they log in — their Tuesday may not be theoretically generative in the way the framework needs it to be. A well-designed application will account for this: not by lowering the demand for locatedness, but by helping students recognize that a difficult, exhausted, fractured Tuesday is itself specific enough to produce the divergence that matters. The student who writes “I couldn’t engage with this the way I wanted to, because of what’s happening at home, and here is what that interruption revealed about the framework’s assumptions” has produced a more rigorous contact-event than the student who performed engagement they didn’t feel. That is a design challenge, not a philosophical exemption.

AI’s Completeness Is the Condition, Not the Threat

The deepest contribution of this framework is not a set of techniques. It is a reframing of what AI’s growing capability means for education. Under the dominant paradigm, AI’s improvement is the escalating threat: the more capable the model, the more of human intellectual work it can replicate, and the less the educational system can verify that any given output emerged from a human mind. That framing turns every model release into a crisis — a new ceiling that the detection infrastructure must race to reach before students do. It makes institutions permanently reactive, permanently behind, permanently engaged in a remedial posture toward technology that is not going to slow down to accommodate their committee cycles.

Under this framework, that logic inverts. The more completely AI maps the space of the probable, the more precisely it delimits the space of the irreducibly human. The best version of a generative model is, in this account, the most useful diagnostic instrument for humanness that has ever been built. Not because it narrows what humans can contribute, but because it makes the contours of that contribution legible for the first time with the precision of a negative.

The institutional implication follows directly. Institutions that operate from this reframing stop procuring detection infrastructure and start investing in assignment design capacity. The question shifts from “can we tell if the AI wrote this?” to “have we built the assignment so that only a located human can complete it?” These are different resource allocations, different institutional conversations, and a fundamentally different theory of what the university is for. The first assumes the human is the variable to be verified. The second assumes the human is the irreducible constant around which the curriculum must be designed.

The map does not eliminate the territory it cannot represent. It reveals it. Every expansion of AI’s capability is, from this angle, a more complete map — which means a more precise revelation of the territory that lies beyond it. The educator’s task is to make that territory the address of the course. Not the course about AI, not the course that accommodates AI, but the course whose curriculum is constituted by the contact with what AI cannot reach — the specific, the located, the Tuesday that only one person in the room has ever lived. That course is not a retreat from the technology. It is the most rigorous possible engagement with what the technology has finally made visible: the irreducible fact of being somewhere, in a body, at a time, with stakes.