I Ran a Recursive Language Model on Myself

Post 2 of 2. Post 1 Last month I wrote about what I thought could've been better in a recent AI work group I facilitated. Here I'd like to propose a solution.

The post I published last month was produced using the technique I failed to use when I needed it most.

A recursive diagnostic interview. AI asked me questions; I did the thinking. AI, with me in the loop, synthesised the structure.

The post was about not outsourcing your thinking to AI. It was made through a process of not outsourcing my thinking to AI. What's worth writing about is why that process worked and why it would work for you too. The explanation turns out to be stranger than just "do your own thinking first."

Writing about the problem turned out to be the solution to the problem.

The Paper

In 2025, Alex Zhang, Tim Kraska, and Omar Khattab at MIT published a paper called Recursive Language Models (arXiv:2512.24601). I came across it and immediately was reminded of this excellent paper that introduced verbalized sampling: in it the authors give some practical suggestions on how to prompt for more diverse responses. I wrongly assumed that Recursive Language Models was similar in scope, so I immediately began trying to understand how it might improve my own prompting.

The paper is not intended to help with prompting though. The core idea is that standard single-pass LLM processing degrades on complex tasks because it tries to handle too many things simultaneously. Inspection, decomposition, analysis, synthesis: all happening in one forward pass, contaminating each other.

They propose staged cognition. The model peeks at structure first, forms a strategy, then executes it in phases. Each phase stores its results explicitly before handing off to the next. Exploration happens separately from synthesis. Intermediate findings are held as discrete objects rather than immediately blended.

The results were seriously impressive. On complex reasoning and long-context tasks, the staged approach consistently outperformed single-pass processing by meaningful margins. The paper is technically dense, but the principle is surprisingly human: performance degrades when you try to do everything at once.

The Translation

This paper isn't about prompting. But the architecture it proposes maps closely onto how humans can improve their own thinking, which makes it an effective prompting strategy anyway.

None of the steps describe something machines do that humans can't. Staged cognition. Inspect before acting. Store intermediate results explicitly. Separate exploration from synthesis. These are descriptions of what good problem externalisation already looks like when humans do it well. It's what a good editor does when they read a draft: read for gist first, strategy, then line-level work. It's what a good doctor does: symptom inventory before diagnosis. It's what a decent lesson plan does: clarify objectives, identify resources, then design activities.

The reason LLM training produced these principles is precisely because LLM training data reflects human cognition at scale. The techniques that make LLMs more reliable are legible in the data of humans being reliable.

What this means practically is that you can run these techniques on yourself. The recursive interview pattern I used to write Post 1 is, structurally, a direct application of staged cognition. It worked for exactly the same reason staged cognition works for language models: it prevented me from trying to explore, analyse, and synthesise all at once.

What Actually Happened

The process had four phases, in this order.

BEHAVIOUR. What actually happened at the session in sequence. My classroom, two C-shapes of desks facing the smart screen, blinds open, natural light. I had two laptops running — work laptop with the presentation, home laptop with Claude Code open so I could reference the analysis I'd prepared. A colleague arrived five minutes early and I stopped rehearsing to chat with him, because I already knew four more minutes of prep wasn't going to change anything. Then: toggling between screens during delivery, losing my place, going off-script when a participant was mid-task and finding that the off-script moment was the first time anything landed.

FRICTION. Where did it break, slow down, or feel wrong? This required more work than narrating behaviour. The friction wasn't just "the script didn't work." It was locating where the translation layer appeared: the real-time cognitive overhead of converting someone else's phrasing into something speakable while simultaneously reading the room. One problem, not two. These had to be found separately before they could be understood as connected.

HIDDEN ASSUMPTIONS. What was I treating as fixed that maybe wasn't? This is the phase most people skip, including me, until it was explicitly named as a phase. When I put the presentation together, my own nerves kept me from seeing I'd assumed "the AI's output looks polished, therefore it's better than my instincts" as a background premise rather than a choice. I've done this before in other contexts. When I'm uncertain, I reach for something that looks finished instead of trusting what I actually know. I'd noticed the presentation had no objectives, no roadmap. I thought: maybe I just don't understand how professional facilitation works. My instincts were right. I overrode them anyway. That assumption (deference to polish under conditions of low confidence) became more visible when the phase forced me to look for it.

REDESIGN CRITERIA. What would better actually look like, in practice? Not "be more confident" or "do my own thinking first." Those are instructions that float free of anything actionable. What would it look like, specifically, on the afternoon of the next session?

The AI didn't do this thinking. It asked the questions that structured the phases. I answered them. After each set of exchanges, it reflected back a working model of what I'd said and asked me to correct it. I corrected it. The draft emerged from that material.

The difference between this and a normal "help me process this experience" prompt is architectural. Most prompts invite the AI to synthesise before exploration is complete. This one enforced a hard boundary between the two. That hard boundary is reinforced by the user because it will not move on until you have agreed that it got the previous stage right.

A Reframe I Needed

A consultant in one of my AI communities made an observation that was quite helpful. I'd been thinking about the session primarily in terms of time: the preparation took too long, the delivery felt rushed, I didn't say the thing I meant to say at the end. He pointed out that time was less the bottleneck than cognitive load.

The problem was that the more I prepared, the less prepared I felt because the preparation was not actually adding to the complexity. Polishing material you haven't digested just gives you shinier material to struggle with.

This reframe clarifies what the recursive interview actually does. It reduces cognitive load at the point of delivery by forcing the heavy cognitive work into the preparation phase. Staged cognition is about moving processing cost to where it can be absorbed without causing performance degradation.

Someone else in the same community mentioned that they'd codified fifteen books as a kind of advisory council, structured reference points for specific types of problems. Same principle applied differently. The strategic use of a thinking framework before you need to think under pressure. Reconnaissance, as the paper would call it.

The Cheat Code Model

Most prompt-engineering content is built around a fantasy: that somewhere there is a prompt containing the "right" sequence of words that produces reliably excellent output with very little input. This is akin to cheat codes in video games. Put in the right input, receive the right output.

The problem is that this model puts the AI in the driver's seat. You're a passenger in your own learning. That's fine for things that don't require deep thinking. For anything that matters, the people who get good at using AI are the ones who build things with it and report back on what broke. The people who can show some scar tissue. The people who read frameworks about prompting are learning something more like a vocabulary than a flexibly performed skill.

Recursive prompting is structurally different. The AI's job is to structure your thinking, not replace it. It asks questions. You answer them. It reflects back what you said. You correct it. The output quality depends primarily on the quality of what you bring to the exchange rather than the cleverness of the prompt. Which is, incidentally, exactly what I said in Post 1 and then failed to do in the session I wrote Post 1 about.

The clickbait version of this distinction is: "vending machine prompting vs. sparring partner prompting." I am resisting the urge to put that in LinkedIn broetry.

The more useful framing is this: a sparring partner makes you do the work. That's the point. A good sparring session leaves you more tired, not less. It takes time, it isn't instantaneous. What it produces is understanding rather than mere polish. Understanding that survives the moment when the script isn't in front of you.

Run It Back

The strange thing about the paper is where the prompt lives. Not inside the model. Outside it, stored as a variable in a Python environment. The AI only sees metadata about its own context. It writes code to probe that context, decompose it, and call itself recursively on smaller pieces. They turned the thinking process into an external program the AI runs on itself.

(There's a great deal of writing out there about how next-token prediction is fundamentally not the same as thinking. I'm not opening that can of worms.)

My move is to rehumanise it. Take the programmable form and run it back on a person — AI holding the structure, you holding the thinking. Exploration stops contaminating synthesis. That's the whole trick.

What This Doesn't Solve

I ran the structured interview. I did the thinking. The post came out well. I think it came out well; you read it and can disagree.

What the process didn't do is remove the need for that discipline the next time. There's no prompt that installs a habit. The recursive interview is a tool I know exists and have at times forgotten to use. Whether I remember to reach for it the next time I'm preparing something unfamiliar, under time pressure, with the confidence-crutch loop ready to activate is a behavioural question and one that to some extent AI can't really help with.

What I can say is that the distinction between doing your own thinking and letting AI do it for you now has a familiar texture it didn't have before. I know what it feels like to arrive somewhere through your own cognition, because I did it, and I know what it felt like when I didn't. This is the scar tissue of learning how to use AI to amplify your thinking.

There's something of Ted Chiang's Exhalation in this — dismantling your own apparatus just enough to see how it works, and writing down what you see. The version of ready I'm aiming for is when the thinking has already happened, so I can walk into the room without the script having amplified what I already know I am capable of by scaling up my imagination of what I thought was possible. I am getting into rooms I never would have tried to get into before. Being in the room itself is still my job. I haven't quite mastered it, yet.

The recursive prompter pattern used to produce Post 1 is available as a standalone skill in the Folding Thoughts tools section, a ready-to-paste prompt structured around the four phases described above.