祝融说。

In many AI tool interfaces, the "clear session" or "start new conversation" button is designed to be inconspicuous. Most users see it as a simple "reset" feature, only used when they want to switch to a completely new topic.

This is a huge misunderstanding.

For the professional AI collaborator, this button is not a "reset key"; it is the "context guillotine" hanging above every conversation. It is not a passive feature, but a core weapon that must be used actively and with clear strategic intent -- though clearing also carries a rebuilding cost, and the five hard standards in this chapter exist precisely to weigh that cost.

Mastering the use of /clear is a key step in elevating yourself from passively "correcting" AI to actively "managing" AI's cognitive state. It represents a profound realization: acknowledging and respecting the fragility and danger of context. A contaminated context is a hundred times more terrifying than no context at all. Because the former will continuously and silently mislead AI, producing code that seems correct but is actually toxic.

In this chapter, we will completely change your view of "clearing the session." You will learn that it is not a sign of failure, but a professional, efficient "cognitive hygiene" habit that safeguards the long-term health of your project. You will master the timing and method of activating the "guillotine," and how to instantly rebuild a cleaner, more focused, and more powerful new context at minimal cost after "severing."

6.1 When Must You Clear the Session? (Five Hard Standards)

Activating the "context guillotine" cannot be based on feelings. It needs to be built on a set of clear, executable rules. Overusing /clear reduces efficiency, but not using it when needed buries huge technical debt.

Here are five "hard standards" I have summarized from countless real-world battles. When any of these trigger, you must, immediately and without hesitation, clear the current session. Please internalize them as instincts.

Standard One: When AI Starts "Circular Reasoning" (Falling into "Confirmation Bias")

This is the most common and most telling signal.

• Manifestation: You have clearly pointed out a fundamental flaw in AI's solution, but in subsequent rounds, it does not propose new alternatives. Instead, it continuously "patches," "rationalizes," and "supplements" the original wrong solution. It tries to convince you that its original idea was correct and just needs some "fine-tuning."
• Specific conversation pattern:
• You: "This scheme hard-codes permissions on the frontend. It has poor extensibility."
• AI (Round 1): "You are right. To improve extensibility, we could extract the role list into a separate configuration file..." (Still frontend hard-coding)
• You: "No, I mean the permission check should be done on the backend."
• AI (Round 2): "I understand. Then we could have the frontend request a complete permission rules JSON from the backend on startup, and then dynamically generate routes on the frontend..." (Falling into the disastrous "making things worse" pattern from Chapter 2)
• Trigger cause: The conversation history keeps reinforcing the same mistaken assumption, making the model more likely to continue along the established path. This is a context-conditioning effect and should not be equated directly with confirmation bias in human psychology.
• Why clearing is worth considering: Further corrections may still be diluted by the old context. Clearing and rebuilding the session from the minimum necessary facts is often a low-cost escape. Branching, rollback, or explicit context selection can serve a similar purpose when the tool supports them.
• Action: Once you recognize that AI has been addressing the same core issue for more than two consecutive rounds without presenting any substantial new ideas, only "patching" the old one, immediately execute /clear.

Standard Two: When the Task Focus Undergoes a "Major Shift"

• Manifestation: You have just completed a relatively independent, complex task module (e.g., finished the entire backend API development for the user authentication system) and are about to start a completely new, largely unrelated module (e.g., starting development on the frontend article display page).
• Specific scenario:
• You and AI spent 50 rounds of conversation debugging the JWT issuance, refresh, and validation logic. This conversation history is filled with details about encryption algorithms, HTTP headers, and database user table structures.
• Now, your next instruction is: "OK, backend authentication is done. Now let us work on the frontend article list page, which needs to support infinite scroll loading."
• Trigger cause: Most of the old context is noise for the new task. Details about JWT do not help with implementing infinite scroll; instead, they consume AI's precious "attention" bandwidth and increase the risk of "false correlation." It might unconsciously use a variable name that appeared in the backend authentication logic in the frontend code.
• Why you must clear: Keeping a context filled with unrelated information is like asking a marathon runner to immediately participate in a weightlifting competition without rest or changing gear. The sweat, tired muscles, and running rhythm are not just unhelpful for weightlifting -- they are entirely burdensome. We need AI to "clear its mind" and enter the new track in the best possible state.
• Action: Whenever a major functional chapter ends and you are about to start the next one, proactively execute /clear for a "mental reset."

Standard Three: When You Finally Find the "Root Cause" After a Long Debugging Session

• Manifestation: You and AI have engaged in a long, painful tug-of-war over a bizarre bug. You have tried a dozen methods, added a large number of debugging logs, and the conversation history is filled with wrong guesses and failed attempts. Finally, you (usually the human) have a flash of insight and discover the deeply hidden root cause (e.g., the timing of a variable's async update was off).
• Specific scenario: To fix an "intermittent" UI flickering problem, your conversation with AI lasted two days. You discussed React's rendering cycle, CSS stacking context, the browser's event loop... and finally discovered that an upstream component was triggering a global state update at an inappropriate time.
• Trigger cause: This two-day conversation history is a junk-information dumping ground. The overwhelming majority of it consists of discarded, wrong exploration paths. If you continue forward carrying this garbage, AI may be contaminated by one of those former "wrong assumptions" in subsequent work.
• Why you must clear: We need a fix based on "correct attribution," not one based on a "chaotic exploration history." Keeping the exploration history is like a detective, after solving a case, still keeping all the wrong clues and innocent suspects in the office. It only hinders him from writing a clear closing report.
• Action: The moment you find the root cause of the bug, record your finding in CHANGELOG.md, then decisively execute /clear. In the new session, your first sentence should be: "We found that the root cause of problem XX is YY. Now, based on this reason, please provide the most direct and concise fix."

Standard Four: When AI's Response Quality Takes a "Cliff-Like Drop"

• Manifestation: Early in the session, AI's answers are fast and accurate. But as the conversation grows longer (usually beyond several dozen rounds), you visibly feel it getting "dumber." Its answers become slow, verbose, unfocused, and it even frequently forgets constraints you mentioned just minutes ago.
• Specific scenario:
• AI starts rephrasing your question after every query you make.
• The code it generates starts violating conventions agreed upon early in the conversation (e.g., starting to use the any type again).
• The solutions it gives contradict answers from just a few rounds ago.
• Trigger cause: Context overload. AI's "attention mechanism" is being overwhelmed by the overly long conversation history. It cannot effectively allocate weights in the vast token sequence to identify what is currently most important. Long-context research (e.g., Lost in the Middle, arxiv.org/abs/2307.03172) shows that models use information in the middle of the context least effectively -- one manifestation of the "needle in a haystack" problem we mentioned earlier.
• Why you must clear: At this point, AI is like a computer about to run out of memory. All operations become extremely sluggish and error-prone. Trying to continue inputting instructions is like frantically hitting keys on a frozen computer -- meaningless. The only solution is to "reboot."
• Action: When you subjectively feel that the communication cost with AI has non-linearly and significantly increased in recent rounds, trust your intuition and immediately execute /clear.

Standard Five: When You Yourself "Cannot Think Clearly" and Need to Reorganize Your Thoughts

• Manifestation: Sometimes, it is not AI that is confused, but ourselves. When exploring an extremely complex problem, our own thinking can get muddled. We forget what the initial goal was, or we get led astray by some technical detail.
• Specific scenario: To implement a complex animation effect, you and AI discussed Bezier curves, matrix transformations, the Web Animations API... Two hours later, you find yourself completely lost in the mathematical and API details, forgetting that this animation was originally just meant to make a button's click feedback "a bit more interesting."
• Trigger cause: The current conversation flow has led you down a "rabbit hole." You need to step back, return to a higher, more macro perspective, and re-examine the problem.
• Why you must clear: Without clearing the session, you and AI will be bound by the current "thinking inertia" and continue digging deeper into this rabbit hole. Clearing the session is a powerful "psychological ritual" that forces you to pause, take a step back, and rethink: "What problem am I really trying to solve? What is the most important goal?"
• Action: When you feel like you are "overthinking," proactively use /clear to interrupt yourself. Then, in the new session, re-describe your core goal in one or two of the simplest, most essential sentences. This often leads you to find a simpler, more direct implementation path instantly.

6.2 How to Instantly Rebuild Context by "Re-Feeding Documents + Latest Log"

The courage to "sever" comes from our confidence in the ability to "rebuild." If clearing the session always meant starting from zero every time, the cost of this operation would be too high.

Fortunately, the "architectural constraint" system we built in Part 2 is precisely designed for this moment. Those three core documents (AGENTS.md, ARCHITECTURE.md, CHANGELOG.md) are our "one-click restore system" for AI's brain.

The process of rebuilding context is not a cumbersome manual process, but a standardized, repeatable, highly efficient "startup ritual."

The "Three-Step" Context Rebuilding Method

After each /clear, your next instruction should strictly follow the three-step structure below. This structure is designed to restore AI's identity, knowledge, and memory in the most efficient order.

Step One: Identity and Rule Injection (Who am I? What must I follow?)

The goal of this step is to instantly load the core contents of AGENTS.md and ARCHITECTURE.md, setting the role and global constraints for AI.

• Core action: Copy and paste the core contents of these two documents directly into the input box. For AI tools that support file upload, you can directly upload the files.
• Instruction template:

[PASTE CONTENT OF AGENTS.md & ARCHITECTURE.md HERE]

Acknowledge and Internalize: You are to act as the Senior Engineer defined in the agent directives. All your subsequent responses must strictly adhere to every rule, constraint, and architectural principle outlined in the documents above. This is a hard reset; forget all previous conversations. Confirm that you have fully assimilated this context.

• Why it works: This step instantly "specializes" a general-purpose, "factory-default" AI into a domain expert dedicated to your project. Its brain is programmed with "hard-coded" rules about the tech stack, design patterns, and absolute prohibitions. This is the foundation for all subsequent correct behavior.

Step Two: State and Memory Recovery (Where did we leave off?)

AI has its identity and knowledge, but it does not yet know the "current" state of the project. This step uses CHANGELOG.md to quickly bring it "up to speed."

• Core action: Open your CHANGELOG.md file and copy the latest 2-3 log entries. Note: you do not need to copy everything, just the most recent ones most relevant to the current task.
• Instruction template:

Project Status Update: Here is the latest progress from our CHANGELOG.md. This is our current state.

[PASTE LATEST 2-3 ENTRIES FROM CHANGELOG.md HERE]

Based on this log, our immediate next step is [Explicitly state the "Next Step" from the last log entry].

• Why it works: CHANGELOG.md provides an extremely condensed, noise-free "memory snapshot." It tells AI: "We have completed A, B, and C. We are now about to start D." This prevents AI from guessing the current task and stops it from repeating already completed work. It focuses AI's attention like a laser on the single problem that needs solving right now.

Step Three: Action Instruction Issued (Now, what do we do?)

The first two steps are "preparation." This step is the true "action." After AI confirms it has loaded its identity and memory, you can issue specific, executable task instructions.

• Core action: Give the first specific action you want AI to execute. This action should be small and clear.
• Instruction template:

Action: Let's begin. Create the file [file_path] and provide the initial boilerplate code, keeping all established rules in mind.

• Why it works: A clear, starting instruction gives AI a clear "entry point," allowing the new session to begin smoothly. It avoids open-ended questions (like "What do you think we should do?"), thereby reducing uncertainty.

A Complete Example Integrated:

(You just pressed the /clear button)

Your first message:

# AI Agent Directives: Project "Phoenix"
This document defines your role... [Content of AGENTS.md]

# Project "Phoenix" - Architecture Document
This document is the Single Source of Truth... [Content of ARCHITECTURE.md]

Acknowledge and Internalize: You are to act as the Senior Engineer defined in the agent directives. All your subsequent responses must strictly adhere to every rule, constraint, and architectural principle outlined in the documents above. This is a hard reset; forget all previous conversations. Confirm that you have fully assimilated this context.

---

Your second message (after AI confirms):

Project Status Update: Here is the latest progress from our CHANGELOG.md. This is our current state.

2023-10-27
- Implemented: User authentication endpoints (`/login`, `/register`) are complete.
- Decision: Frontend will store the JWT in `localStorage`.
- Next Step: Begin work on the frontend login page.

Based on this log, our immediate next step is to begin work on the frontend login page.

---

Your third message (after AI confirms again):

Action: Let's begin. Create the file frontend/src/pages/LoginPage.tsx and provide the initial boilerplate code, including a basic form with email and password fields.

This process may seem more "cumbersome" than asking a question directly, but trust me, this 30-second "investment" will save you the next 30 minutes or even 3 hours of back-and-forth wrangling with a cognitively confused AI.

This multi-turn example illustrates the structure of the re-priming flow: inject the documents first, then sync the state, then issue the action instruction. (Note: this is a teaching demo. In practice, file-level context injection or tool integration may replace the multi-turn confirmations -- adapt to the capabilities of your tooling.)

6.3 Avoid Turning Conversations into "Junk Heaps"

Having learned to "sever" and "rebuild," we also need to master an everyday, preventive skill: how to keep conversations "clean" from the start, thereby reducing the frequency of needing to use the "guillotine."

A conversation becomes a "junk heap" often because we unconsciously dump large amounts of low-quality, unstructured, misleading information into it.

Here are three key habits for keeping your conversations "tidy":

Habit One: Speak with "Code," Not with "Feelings"

AI is a master of code, but not a mind reader. Avoid using vague, subjective language to describe problems.

• Bad habit (junk information): "This button looks kind of ugly. Make it look nice." ("Ugly" and "nice" cannot be quantified by AI. It might randomly change the color, which is most likely not what you want.)
• Good habit (effective information): "Critique: The current button's padding is too small, and the color contrast is not enough. Action: Please apply the following CSS changes to the button: padding: 8px 16px;, background-color: #007bff;, color: white;"

Habit Two: Provide "Minimum Reproducible" Context, Not "All" Context

When AI needs to modify a file, a common mistake is to throw the entire project or the code of dozens of files at it. This violates the "minimum cognitive unit" principle from Chapter 5.

• Bad habit (junk information): (Pastes code from 5 components) "After the user clicks this button, the list does not refresh. Help me see why."
• Good habit (effective information): "I encountered a state update problem. Here are the three key parts involved:

1. State definition (in useStore.js): [Paste the zustand store code snippet]
2. The component triggering the update (in Button.jsx): [Paste the Button component code snippet]
3. The component that should respond to the update (in List.jsx): [Paste the List component code snippet] Problem: After clicking the Button, the List component does not re-render. Please analyze the interaction between these three pieces of code and find the cause."

By proactively "preprocessing" and "focusing" the context for AI, you greatly reduce its cognitive burden and significantly improve the accuracy of its problem localization.

Habit Three: Separate "Decision Process" from "Final Conclusion"

In conversations, we often engage in exploratory discussions with AI, like comparing the pros and cons of two approaches. This "discussion process" is valuable, but it should not be mixed with the "final execution" instructions.

• Bad habit (junk information): After a long analysis of the pros and cons of using Redux vs. Zustand, directly say: "OK, let's use it then. Start writing code." ("It" is ambiguous, and the preceding lengthy analysis is noise for the subsequent coding.)
• Good habit (effective information):

1. (First, have a thorough discussion...)
2. Make a clear decision summary: "Decision: We have decided to use Zustand for state management due to its simplicity. This decision is final for this project."
3. (Optional) Update the document: Record this decision in ARCHITECTURE.md.
4. Issue a clean action instruction: "Now, let's implement the user store using Zustand. Create a new file stores/userStore.js..."

This habit ensures that your conversation history is filled with clear, traceable "decision points," rather than a tangled mess of "brainstorming records."

In summary, keeping a conversation clean is like keeping a kitchen clean. Clean as you go (use precise language), categorize and process (provide focused context), and regularly take out the trash (summarize decisions, not retain processes). A clean kitchen allows you to cook more delicious meals; a clean conversation allows you and AI to build more robust software.

[Operations Card] Four Steps to Quickly Restart After /clear

Think of this card as the checklist a fighter pilot must go through item by item before takeoff. Every time you press /clear, strictly follow this procedure.

Golden Rule:

Never start a new, important task in a session you have judged to be "toxic." The cost of a restart is far lower than the long-term cost of patching and repairing on a wrong foundation.

Mastering the art of the "context guillotine" means you have mastered the switch to control AI's cognitive flow. You are no longer passively troubled by AI's "hallucinations" and "forgetfulness." You have become a controller capable of actively shaping, purifying, and resetting its "thinking environment." This is a qualitative leap from "conversing with AI" to "designing conversations with AI."