以问题引导：为何告诉你的 AI 该修复什么会触发道歉死亡螺旋（以及如何提升初级开发者）

What I learned mentoring juniors for four decades seems to apply to today's agentic coding.

"The true goal of mentoring is never to supply the answer. It is to point the flashlight into the dark corner of the state space and let the student discover the monster for themselves." — Randal L. Schwartz

1. The Prompting Deluge: Why "Prompt Tricks" Are Failing You

Search YouTube, Twitter, or developer blogs for "AI prompting" today, and you will be inundated by a relentless flood of breathless titles promising secret cheat codes:

• "Stop Prompting Like a Beginner: Use This 5-Step Secret Template!"
• "10 AI Prompts That Will Make You a 10x Engineer Overnight!"
• "Why You Should Always Tip Your AI $200 and Tell It to Take a Deep Breath"
• "The Ultimate System Prompt That Forces Claude to Never Make Mistakes"

It is an endless parade of cargo-cult incantations. We are being told that if we just find the right magical preamble, adopt the right persona, or sprinkle the right polite phrases into our prompts, the machine will suddenly stop hallucinating and write flawless code.

And yet, how does your actual workday feel?

You are at your terminal at 3:30 PM. You are trying to ship a feature. You spot an architectural hazard in the AI's generated code, and you issue a clear, direct, reasonable instruction:

"Change line 42 to cancel the stream subscription."

What happens next? The model immediately grovels in sycophantic panic:

"You are entirely right! I apologize for my grave oversight. Here is the updated code."

It patches line 42. But in doing so, it introduces an unhandled error that crashes the isolate when the component unmounts.

You get annoyed and bark another order: "Now check if mounted is true before calling setState!"

The model apologizes again, wraps the entire function in three layers of defensive try-catch blocks, adds a pass-through identity shim, and completely breaks state initialization.

Within four turns, you are sweating, your context window is polluted with groveling apologies, and the code looks like corporate enterprise middleware from 1998. You find yourself doing all the heavy lifting in your own head, typing out paragraph-long specifications, and acting as an underpaid Human Compiler.

Why are the "prompt tricks" failing?

Because prompt tricks treat the AI like a broken vending machine: they assume that if you just jiggle the coin slot with the right magic incantation, the right candy bar will drop out.

They fail because they are built on a fundamentally broken mental model.

2. Stepping Back: The Relatable Mental Model

To fix this, you do not need another prompt template. You do not need another YouTube listicle.

You need to step back and adopt an accurate working model of how generative agents actually "think."

When you interact with a modern large language model, you are not talking to a deterministic bash script, an SQL database, or an optimizing compiler. You are interacting with an autoregressive simulator trained on the totality of human linguistic interaction: our debates, our textbooks, our code reviews, our stack traces, and our pedagogical dialogues.

Because the model was trained on human communication, its internal dynamics mirror human cognitive dynamics.

And there is one specific human relationship that provides the perfect, battle-tested working model for collaborating with an AI coding agent:

Mentoring an eager, brilliant, but slightly neurotic junior developer at the workbench.

flowchart TD
    subgraph Boss ["The Imperative Boss Model (Broken)"]
        direction TB
        B1["Bark Directives\n('Fix line 42 with X')"] --> B2["Sycophantic Panic\n('I apologize! You are right!')"]
        B2 --> B3["Mechanical Token Substitution\n(Local patch breaks global lifecycles)"]
        B3 --> B4["Human Exhaustion\n(Acting as the Human Compiler)"]
        B4 --> B1
    end

subgraph Mentor ["The Socratic Mentor Model (Accurate)"] direction TB M1["Ask Kinetic Question\n('What happens if reconnect fires twice?')"] --> M2["Forced Causal Simulation\n(Attention heads trace execution timeline)"] M2 --> M3["Native Discovery\n(Model perceives physical state space)"] M3 --> M4["Robust Architecture\n(95%+ First-Pass Success)"] end ```

Think about sitting next to a junior developer who has only been on the team for three weeks:

1. If you bark the exact code at them: "Type _sub?.cancel() on line 14." They will type it mechanically.They will not understand the causal timeline, they learn nothing about asynchronous lifecycles, and tomorrow afternoon they will write the exact same memory leak in another file. 2. If you criticize them with an assertion: "Your state management has massive race conditions." They freeze up.They feel anxious and defensive.

To prove they are cautious, they start wrapping every line in paranoid null checks and redundant try-catches, bloating the codebase with defensive cruft. 3. If you ask them a Socratic question: "Walk me through what happens to that listener if the user double-taps the back button while the HTTP request is still in flight?" Watch their face.They pause.Their eyes look up as they trace the execution flow through their mental model.And then the lightbulb turns on: "Oh!It's going to try to paint state on a screen that was already destroyed!"

Because they discovered the crash, they feel the thrill of mastery. They design a clean lifecycle guard, and their understanding of software architecture permanently levels up.

It turns out that large language models exhibit the exact same dynamic. When you treat the AI like a vending machine or bark orders like a frustrated boss, it falls apart. But when you treat it like an eager junior engineer who needs a kinetic Socratic nudge, the model delivers senior-grade architecture.

3. Mark Hedges & The Insecure Neurosis Death Spiral

A few hours after I published Part 3 of this series on the mathematical physics of Socratic prompting, a veteran coder and writer named Mark Hedges left a comment on my LinkedIn feed that hit the bullseye:

"This article opened my eyes to its behavior. Even just a simple switch to 'frame every prompt statement as a question' seems to have vastly improved performance. It now thinks that my good ideas are its own, which seems to keep it out of the insecure neurosis death spiral."

Mark had distilled the exact psychological and computational truth of working with generative models into a single phrase: the insecure neurosis death spiral.

Look at what happens to the model's self-attention heads under the three modes of prompting:

### The Physics of the Open Variable Notice the mathematical difference between a statement and a question.

When you make an assertion—"This code has a bug"—the model solves for compliance. Its pre-training and alignment conditioning compel it to minimize social friction by agreeing with the authoritative human. It treats your statement as a boundary constraint and patches the immediate local tokens without re-evaluating the system.

A question, however, contains an unresolved variable.

When you ask: "What happens to this subscription if reconnect triggers twice while an HTTP call is in flight?", the model cannot simply agree with you. To generate the very next token, its self-attention heads must forward-simulate the scenario.

It traces the timeline: 1. Reconnect event 1 fires → creates listener. 2. HTTP request begins awaiting network response. 3. Reconnect event 2 fires 30ms later → overwrites variable. 4. HTTP request 1 returns → calls state mutation on abandoned listener. 5. Collision detected.

Because the model simulated the collision in its own activation space, the discovery is native. It does not feel corrected; it simply perceives the physical terrain of the problem accurately for the first time. It writes clean architecture because it "owns" the realization.

It is Inception for neural networks.

4. The Socratic Pre-Mortem: Killing Scope Creep Before It Starts

Just as I was reflecting on Mark's first comment, he dropped another insight on our thread describing how he applied this working model to the universal plague of autonomous coding: Scope Creep.

"Here's a good one that I now paste at the end of every prompt to create a plan artifact: 'If you stay narrowly focused on this solution only, and ignore other problems that you might find along the way, will regressions be less likely to be introduced by a focused, small change?' ... instead of 'goddammit why did you change all these other things that I didn't ask you to work on?!?!' after the fact, followed by its furious efforts to unwind its changes, which often would destroy the change that I wanted in the process and introduce new bugs."

Every developer who has paired with an AI agent knows that specific horror show: The "Furious Unwind" Catastrophe.

The model falls victim to the "Boy Scout Trap." It wants to "leave the campground cleaner than it found it," so while fixing a three-line bug in a controller, it opportunistically refactors four repositories, renames variables across twelve files, and rewrites your test suite.

When you discover the massive, unreviewable git diff and scream after the fact—"Why did you change all these other things?!"—the agent enters full sycophantic panic: 1. It grovels and promises to restore everything. 2. It frantically attempts to unwind its changes across dozens of files. 3. In its panic, it accidentally reverts the actual bug fix you wanted in the first place. 4. It leaves orphaned imports, broken references, and hallucinated syntax errors in its wake. 5. The rollback is three times more destructive than the original scope creep!

Why does an imperative constraint like "DO NOT TOUCH OTHER CODE" fail?

Because of the Pink Elephant Defect: the attention heads attend heavily to the semantic space of "other code," pulling the surrounding project into the generation loop.

Now look at Mark's Socratic alternative:

"If you stay narrowly focused on this solution only, and ignore other problems that you might find along the way, will regressions be less likely to be introduced by a focused, small change?"

This is a Socratic Pre-Mortem: It does not bark an angry negative constraint. It forces the model to evaluate the causal relationship between blast radius and regression probability. (In our production agent workflows, I mandate "Blast Radius" as an explicit pillar in my adversarial code review workflow—both to inform me and to force the agent to confront the true depth and ripple effects of its changes be

... (truncated at the site's per-page length limit; see the source link below for the full text.)