# The context engineering rules just changed. Here's what to delete.
**作者**: AI Guides
**日期**: 2026-07-29T13:47:52.000Z
**来源**: [https://x.com/free_ai_guides/status/2082463119742320825](https://x.com/free_ai_guides/status/2082463119742320825)
---
Anthropic deleted 80% of its own AI instructions.
Nothing broke.
The instructions you wrote for your AI project are probably carrying the same dead weight, and this guide is the audit that helps you remove it.
Anthropic engineer Thariq Shihipar just published what the company learned building for its newest models.
They removed over 80% of Claude Code's system prompt and measured no loss on their coding evaluations.
If Anthropic's own instructions had that much dead weight in them, yours almost certainly do. You did not write them badly. You wrote them for a model that has since been replaced.
One finding matters more than the rest. Past a certain point, adding context stops helping and starts hurting.
Knowing what to remove is a skill worth having.
This audit works on any assistant with an instructions box, a memory setting, or an uploaded file. No code needed.
## What's Inside
→ Why your instructions are aging badly, and what three independent teams found
→ The 4-Layer Context Audit, the framework you can run today
→ The Delete Test, four questions per instruction
→ 4 copy-paste prompts that run the audit for you
→ The mistakes that show up most often
→ Where this audit does not apply
## Why Your Instructions Are Aging Badly
Context engineering is the practice of managing everything the model sees besides your prompt.
Your standing instructions, its memory of you, your uploaded files, and the tools it can reach are now the largest levers on output quality you control without switching tools.
Shopify CEO Tobi Lütke first described it as the art of providing all the context for the task to be plausibly solvable by the LLM. Andrej Karpathy backed the term within days.
Anthropic formalized context engineering in September 2025.
And in less than a year, they’ve deleted most of the context they include.
The word they used for the cut is unhobbling. The constraints existed to stop older models doing dumb things.
Newer models have better judgment, so those constraints stopped protecting anything. Now they are just instructions the model reasons around before it can start your actual task.
Anthropic found this in their own transcripts.
One rule said leave documentation as appropriate. Another said do not add comments.
Both sat in the same request. The model had to resolve that before it could start.
You almost certainly have a version of this in your own setup, written months apart, quietly arguing with itself.
They are also not the only ones to land here. There is a pattern emerging, and three independent teams arrived at it from different directions.
Chroma measured the underlying behavior. In research published July 14, 2025, Kelly Hong, Anton Troynikov and Jeff Huber tested 18 large language models across Anthropic, OpenAI, Google and Alibaba.
They found that models do not all use their context in the same way, and that performance grows increasingly unreliable as input length grows.
Manus hit the same wall from the tools side while building a production agent. Their expanding toolkit made the agent worse at choosing, not better equipped.
Different problems had the same conclusion. For frontier models, more context does not mean better output.
Which sets up the part that gets missed.
Context windows grew past a million tokens at the same time the best practice became using less of them.
The biggest constraint is attention.
## The 4-Layer Context Audit
Anthropic published six shifts in how they now build context. The audit below acts on the three that apply to instructions you already have.
Most people audit one layer of four, which is why cleaning up your instructions alone rarely fixes the problem.
The layers run in the order of how visible they are. Layer 1 is the file you wrote yourself. Layer 4 is the one nothing on screen ever tells you about.
Layer 1: Standing Instructions
What it is. The text that goes in with every single request.
Custom instructions in ChatGPT, project instructions in Claude, a system prompt in any API tool, a CLAUDE.md file, the instructions field in a custom GPT or Gem.
Why it's a growing problem. This layer only ever grows.
The assistant does something irritating, you add a line to stop it, and that line stays forever. Nobody ever opens the file to remove something.
A year of small corrections produces a document that argues with itself.
What to cut.
→ Instructions telling the model to be helpful, accurate, thorough, or professional, because those describe default behavior
→ Rules that only fire in a situation you stopped encountering
→ Either half of any two rules that contradict, keeping the one you actually meant
What to keep. The specific and surprising.
Your team calls the customer object Account even though the table is users. You need dates in ISO format because your finance system rejects everything else.
Anthropic's own guidance is to spend your words on the specific traps in your work, rather than on obvious facts the model can work out by looking.
What you notice after. The assistant stops hedging between two styles.
Responses get more decisive, because there is one instruction to follow instead of two competing ones.
Layer 2: Memory
What it is. What the assistant saved about you between sessions, without being asked.
Why it's a growing problem. You never wrote it, so you never review it. It accumulates silently and feeds into every conversation you have.
Where to find it.
→ Claude. Settings, then Capabilities, then Memory. Entries are grouped by category, and each one can be edited or deleted individually.
→ ChatGPT. Settings, then Personalization, then Manage memories. Every saved fact is listed with its own delete control.
What to cut.
→ Anything from a job you left, a project that shipped, or a tool you stopped using
→ Preferences you have since changed
→ Duplicate entries saying nearly the same thing
What you notice after. The assistant stops referencing work you no longer do.
Stale memory is worse than no memory, because the model treats it as current.
Layer 3: Knowledge And Files
What it is.Uploaded documents, connected drives, project knowledge, reference material a retrieval system searches.
Why it's a growing problem. Volume feels like thoroughness here.
Ten documents feels more rigorous than two, so nothing gets removed and versions pile up beside each other.
What to cut.
→ Superseded versions above all, because if the June draft and the final both sit in the same project, the model has no reliable way to know which one you mean
→ Documents uploaded for a single question months ago
→ Near duplicates that differ by a paragraph
That first one is the expensive one. The model will sometimes answer from the outdated version with complete confidence.
What to keep. The current version of anything you reference repeatedly.
If a project needs a lot of reference material, split it into separate documents by topic rather than one long file. The assistant then pulls in only what a given task needs, which is the same principle as the audit itself.
What you notice after. Fewer answers that are almost right.
Most retrieval failures are the system finding the wrong document rather than the model reasoning badly, which is why this layer produces the most visible jump in quality.
Layer 4: Tools And Connectors
What it is.Everything that lets the assistant take an action instead of just answering.
Connectors and integrations, custom GPT actions, plugins, Claude skills, MCP servers, anything you clicked enable on.
Why it's a growing problem. Enabling a tool costs one click and nothing ever prompts you to review it. People accumulate connectors the way they accumulate browser extensions.
Why it costs more than the other layers. Every enabled tool describes itself to the model on every request, before you have asked for anything.
Ten unused connectors means ten descriptions competing for attention in each conversation.
This is the layer where the cost is invisible, because nothing on screen shows it happening.
The failure it causes. Manus, whose entire product is an agent, found that a growing toolkit degraded performance.
The model reaches for a tool when it should have answered directly, or picks the near-miss tool when two do similar jobs.
If your assistant has started running a search on questions it could answer from what it already knows, this layer is a likely cause.
What to cut.
→ Anything you have not used in a month
→ Either of two tools doing the same job, keeping the one you trust
Re-enabling takes seconds, so cutting costs you almost nothing.
What to keep. What you use weekly, and anything a workflow depends on.
What you notice after. The assistant reaches for tools less often and picks correctly more often.
The Delete Test
Dead weight does not sit quietly. It shows up as hedged answers, wrong tool choices, and instructions that get partly ignored.
Length is not your problem yet. The research behind this shift measured degradation in the tens of thousands of tokens, far past anything sitting in your instructions box.
Conflict is your problem today. Two rules pointing different ways cost the model work at any size, which is why Anthropic's own example was a contradiction rather than a word count.
So for each instruction, four questions.
1. Is it still true?
Was this written for an older or weaker model? Does it name a version, a limit, or a capability that has since changed?
2. Does it conflict with anything else?
Does another instruction, in any of the four layers, point somewhere different?
Conflicts cost the most, because the model resolves them before starting your work.
3. Would a competent new hire need telling?
If someone capable joining your team would already know it, the model does too. This is the fastest cut you will make.
4. What breaks if it goes?
Name the specific failure it prevents. If you cannot, it is not load-bearing.
Cut on any of those four. Keep what is specific, current, and surprising.
Two of those get acted on differently, which is worth saying before you start deleting.
Obvious instructions and dead conflicts can go immediately, because you can see the problem on the page. Anything you suspect is an obsolete workaround gets pulled for a week first, then restored if quality drops.
## 4 Prompts That Run The Audit For You
These four prompts run the audit end to end.
One finds your contradictions. Two separates real preferences from obsolete workarounds. Three reveals which instructions were never doing anything. Four rewrites what survives as an outcome instead of a process.
Work through them in order, on any assistant and any project. By the end, your assistant is working from instructions that all point the same way.
Prompt 1: The Conflict Finder
Start here. This finds the instructions fighting each other, which is the most expensive problem and the least visible one.
You paste your standing instructions and get back a ranked list of contradictions.
```
You are an editor who specializes in finding contradictions in
written instructions.
Context: the text below is the standing instruction set I give an
AI assistant. I have added to it over time and never removed
anything from it.
Your job: find every pair of instructions that could pull toward
different actions on the same task.
Be thorough. Read the whole set first, then check each instruction
against every other one, including ones far apart in the text.
For each conflict:
- Quote both instructions.
- Describe a specific situation where they collide.
- Say which one I most likely meant to win.
Then list any pairs that are redundant rather than conflicting.
If an instruction is too ambiguous to judge, say so and explain
what is unclear.
Output:
1. Conflicts, most frequently triggered first.
2. Redundant pairs.
3. The one conflict to resolve first, with a sentence on why.
My instructions:
[PASTE HERE]
```
What you get back. Usually three to six genuine conflicts, most of them written months apart.
Resolve the top one by deleting the instruction you did not mean. Adding a third rule to settle the argument is how the file got this way.
Prompt 2: The Obsolescence Check
This separates what you actually want from what you were compensating for.
Preferences stay. Workarounds for limitations that no longer exist are the bulk of what you will delete.
Note that this prompt names the workarounds rather than claiming expertise about them. Telling a model what to look for beats telling it who to be.
```
You are reviewing an instruction set to find rules that are no
longer needed.
Context: the instructions below were written for an AI assistant
over a period of time. Some encode genuine preferences. Others
were written to compensate for things models used to get wrong,
such as rambling, inventing facts, ignoring formatting, or
skipping steps in reasoning. Those compensations often survive
long after the problem stops happening.
Your job: sort every instruction into PREFERENCE or WORKAROUND.
A PREFERENCE describes how I want things done and would still
matter with a perfect model.
A WORKAROUND exists to prevent a specific failure. Common shapes include telling the model to think step by step, instructing it
not to make things up, capping length to stop rambling, demanding
a format it now produces anyway, or repeating an instruction for
emphasis.
For each workaround, name the failure it was written to prevent.
Go instruction by instruction rather than summarizing.
Where you cannot tell whether a failure still happens, mark it
UNCERTAIN and say what I would need to test.
Output: a table with columns for the instruction, its type, the
failure it prevented, and your recommendation of keep, test
removing, or uncertain.
My instructions:
[PASTE HERE]
```
What you get back. A table sorted into keep and test.
Work the test column one instruction at a time. Remove one, use the assistant normally for a few days, put it back if quality drops.
Prompt 3: The Obvious Test
This asks the assistant to report which of your instructions are actually changing its behavior.
Most people are surprised by how much of their instruction set describes things the model would have done anyway.
```
You are the AI assistant that receives the instructions below.
Context: I want to know which of these change what you produce and which describe what you would do by default.
Your job: judge each instruction honestly on that basis.
Mark each one:
- CHANGES BEHAVIOR, and state how your output differs with it
versus without it.
- NO EFFECT, meaning you would do this by default.
- UNCLEAR.
Be honest about NO EFFECT even where an instruction sounds
important. General quality words such as thorough, accurate,
professional and helpful usually belong there.
Where an instruction mixes both, split it and judge each part.
Output:
1. The three lists.
2. A trimmed instruction set containing only what changes behavior.
3. The percentage of the original you would cut.
My instructions:
[PASTE HERE]
```
What you get back. Three lists, a trimmed version, and a percentage.
Treat the trimmed version as a candidate rather than a replacement. Read it before adopting it, because the model sometimes marks a genuine constraint as default behavior.
Prompt 4: Rules To Outcome
This is the rewrite that follows the audit.
It converts step-by-step process rules into a description of the finished result, which is the exact change Anthropic made to their own prompt.
```
You are a technical writer who converts process documentation into outcome specifications.
Context: the rules below tell an AI assistant how to do something
step by step. Current models handle the route themselves when they understand the destination, so I want to describe the result instead.
Your job: work out what result these rules were trying to produce,
then describe that result directly.
Write the replacement as three things: what the finished output
looks like, what it must contain, and what would make it wrong.
Keep every genuine constraint, including anything covering safety,
permissions, legal requirements or factual accuracy. Those stay
explicit.
Where you cannot work out what a rule was for, list it separately
and ask me.
Output:
1. The outcome description that replaces the rules.
2. What you removed and why it was safe to remove.
3. Any rule whose purpose was unclear.
My rules:
[PASTE HERE]
```
What you get back. A shorter instruction set describing a destination rather than a route.
Anthropic's own version of this change is the clearest example available.
Their old prompt listed process rules about comments and documentation. The replacement tells the model to write code that reads like the surrounding code, matching its comment density, naming, and idiom.
One sentence, covering situations the rules never anticipated.
## The Mistakes That Show Up Most Often
Mistake 1: Confusing less context with no context.
Irrelevant and conflicting context hurts. Relevant context still helps enormously.
The fix. Judge a cut by whether output got worse, not by how much shorter the file is.
Mistake 2: Auditing once.
This accumulates continuously, because every annoyance produces a new rule and nothing produces a deletion.
The fix. Schedule it. Once a quarter, or whenever a model you depend on gets a major update.
Mistake 3: Deleting the specific notes and keeping the vague ones.
People cut the detailed technical notes because they look fussy, then keep the general guidance because it sounds important.
That is backwards. The detailed note is the only part the model could not have worked out alone.
The fix. Run Prompt 3 before cutting anything by hand.
Mistake 4: Adding a rule for every mistake.
This is the habit that creates the problem. One bad output produces a permanent new line.
The fix. Before adding a rule, check whether an existing instruction caused the behavior. Conflicts produce more errors than missing rules do.
## Where This Audit Does Not Apply
Four situations where you should leave things alone.
Small and local models. Everything above assumes a current frontier model.
Smaller models, older models, and most models running on your own machine still need their scaffolding. If you do audit one, test removals on the model you actually use rather than trusting a finding from a lab.
A setup you built last week. Auditing solves accumulation, and nothing has accumulated yet. You would be second-guessing decisions you can still remember making.
Safety, legal, and permission constraints. Anything specifying what the assistant must not do, what needs approval, or what it cannot access stays explicit regardless of how capable the model becomes. Those are not scaffolding.
Output you are already happy with. If your assistant produces what you want, this is optional maintenance rather than a fix. Run it when quality slips or after a model update.
## Start Here
Ten minutes, three steps.
1. Copy Prompt 1 into whichever assistant holds the instructions you want to audit.
2. Where the prompt says PASTE HERE, drop in your standing instructions. Your ChatGPT custom instructions, a Claude project, or a CLAUDE.md file.
3. Read the conflicts it finds, then delete one side of the top one. Choose the instruction you did not mean.
That is the whole first session.
Conflicts are the right starting point because they are the most expensive problem and the one you cannot see by reading your own file.
You wrote both instructions. Both looked reasonable on the day.
Only the collision between them causes trouble, and that collision shows up in output you have already accepted as normal. Which is why it can sit there for a year without you noticing.
Once that is done, work outward through the layers. Memory next, since you have never reviewed it.
Your instructions are not a record of everything you know about your work. They are the short list of things the model cannot work out on its own.
You have the audit and the four prompts. The only variable left is whether you run them on your own setup or keep paying for instructions written for a model that no longer exists.
Save this and run the audit again the next time a model you rely on gets a major update. That is when the dead weight comes back.
I'll keep this updated as the guidance changes.
Follow @free_ai_guides for the updates ❤️
Subscribe to my free newsletter and get one AI superpower every week: http://aisuperpowers.substack.com
## 相关链接
- [AI Guides](https://x.com/free_ai_guides)
- [@free_ai_guides](https://x.com/free_ai_guides)
- [5.5K](https://x.com/free_ai_guides/status/2082463119742320825/analytics)
- [@free_ai_guides](https://x.com/free_ai_guides)
- [http://aisuperpowers.substack.com](http://aisuperpowers.substack.com/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [9:47 PM · Jul 29, 2026](https://x.com/free_ai_guides/status/2082463119742320825)
- [5,534 Views](https://x.com/free_ai_guides/status/2082463119742320825/analytics)
- [View quotes](https://x.com/free_ai_guides/status/2082463119742320825/quotes)
---
*导出时间: 2026/7/30 10:08:57*
---
## 中文翻译
# 上下文工程规则刚刚变了。以下是需要删除的内容。
**作者**: AI Guides
**日期**: 2026-07-29T13:47:52.000Z
**来源**: [https://x.com/free_ai_guides/status/2082463119742320825](https://x.com/free_ai_guides/status/2082463119742320825)
---
Anthropic 删除了其 80% 的 AI 指令。
没有任何问题发生。
你为你的 AI 项目编写的指令可能也承载着同样的死重，而本指南就是帮助你将其移除的审查方案。
Anthropic 工程师 Thariq Shihipar 刚刚发布了该公司在构建其最新模型时的所学所得。
他们删除了超过 80% 的 Claude Code 系统提示词，并测量显示其编码评估结果没有任何损失。
如果 Anthropic 自身的指令中都有如此多的死重，你的肯定也有。并不是你写得很差，而是你为一个已经被取代的模型编写了它们。
其中一个发现比其他的都重要。超过某一点后，添加上下文不再起到帮助作用，反而开始造成伤害。
知道该删除什么是一项值得拥有的技能。
这项审查适用于任何带有指令框、记忆设置或上传文件的助手。无需编写代码。
## 内容概览
→ 为什么你的指令老化严重，以及三个独立团队发现了什么
→ 4 层上下文审查，你今天就可以运行的框架
→ 删除测试，针对每条指令的四个问题
→ 4 个复制粘贴的提示词，为你自动运行审查
→ 最常出现的错误
→ 本审查不适用的情况
## 为什么你的指令老化严重
上下文工程是管理模型除了你的提示词之外看到的所有内容的实践。
你的常驻指令、它对你的记忆、你上传的文件以及它可以触达的工具，现在是你在不切换工具的情况下控制输出质量的最大杠杆。
Shopify CEO Tobi Lütke 首先将其描述为提供所有上下文的艺术，以使任务能够被大语言模型合理解决。Andrej Karpathy 在几天内支持了这一术语。
Anthropic 于 2025 年 9 月正式确立了上下文工程。
而在不到一年的时间里，他们删除了大部分包含的上下文。
他们用来形容这次删减的词是“解除束缚”。这些限制的存在是为了阻止旧模型做蠢事。
较新的模型具有更好的判断力，所以这些限制不再起到保护作用。现在它们只是模型在开始你的实际任务之前需要绕过推理的指令。
Anthropic 在他们自己的记录中发现了这一点。
一条规则说“适当地保留文档”。另一条说“不要添加注释”。
这两者出现在同一个请求中。模型必须在开始之前解决这个矛盾。
在你自己的设置中，几乎肯定也有一个版本，写于相隔数月的时间里，在静静地自相矛盾。
他们也不是唯一得出这一结论的团队。一种模式正在浮现，三个独立团队从不同方向得出了相同的结论。
Chroma 测量了底层行为。在 2025 年 7 月 14 日发布的研究中，Kelly Hong、Anton Troynikov 和 Jeff Huber 测试了来自 Anthropic、OpenAI、Google 和阿里巴巴的 18 个大语言模型。
他们发现，模型并不都以相同的方式使用其上下文，并且随着输入长度的增加，性能变得越来越不可靠。
Manus 在构建生产级代理时从工具方面碰到了同样的墙。他们不断扩展的工具包使得代理在选择时变得更差，而不是装备更好。
不同的问题得出了相同的结论。对于前沿模型而言，更多的上下文并不意味着更好的输出。
这就引出了容易被忽略的部分。
上下文窗口增长到了超过一百万个 token，与此同时，最佳实践变成了使用更少的上下文。
最大的限制是注意力。
## 4 层上下文审查
Anthropic 发布了他们现在构建上下文的六个转变。下面的审查适用于其中三个与你已有指令相关的转变。
大多数人只审查四层中的一层，这就是为什么仅仅清理你的指令很少能解决问题。
这些层级按其可见性的顺序排列。第 1 层是你自己编写的文件。第 4 层是屏幕上没有任何内容告诉你的那一层。
第 1 层：常驻指令
它是什么。随每个请求一起输入的文本。
ChatGPT 中的自定义指令、Claude 中的项目指令、任何 API 工具中的系统提示词、CLAUDE.md 文件、自定义 GPT 或 Gem 中的指令字段。
为什么它是一个日益严重的问题。这一层只会增长。
助手做了一些令人恼火的事情，你加了一行来阻止它，那一行就永远留在那里。没有人会打开文件来删除某些内容。
一年时间的小修小补会产生一份自相矛盾的文档。
删除什么。
→ 告诉模型要乐于助人、准确、详尽或专业的指令，因为那些描述的是默认行为
→ 只在你不再遇到的情况下才会触发的规则
→ 任何两条相互矛盾的规则中的一半，保留你真正想要的那一条
保留什么。具体且令人意想不到的内容。
你的团队将客户对象称为 Account，尽管表名是 users。你需要 ISO 格式的日期，因为你的财务系统拒绝其他所有格式。
Anthropic 自身的指导是，把你的话用在工作中的具体陷阱上，而不是模型可以通过观察看出的明显事实上。
之后你会注意到什么。助手停止在两种风格之间摇摆。
回复变得更加果断，因为只有一条指令需要遵循，而不是两条相互竞争的指令。
第 2 层：记忆
它是什么。助手在会话之间保存的关于你的信息，无需你主动要求。
为什么它是一个日益严重的问题。你从未编写过它，所以你从未审查过它。它在静默中累积，并输入到你进行的每一次对话中。
在哪里找到它。
→ Claude。设置，然后是能力，然后是记忆。条目按类别分组，每一条都可以单独编辑或删除。
→ ChatGPT。设置，然后是个性化，然后是管理记忆。每一个保存的事实都列有自己的删除控件。
删除什么。
→ 来自你离开的工作、已发布的项目或你停止使用的工具的任何内容
→ 你后来改变偏好的设置
→ 说着几乎相同内容的重复条目
之后你会注意到什么。助手停止引用你不再做的工作。
陈旧的记忆比没有记忆更糟糕，因为模型将其视为当前信息。
第 3 层：知识与文件
它是什么。上传的文档、连接的驱动器、项目知识、检索系统搜索的参考资料。
为什么它是一个日益严重的问题。在这里，数量给人一种详尽的感觉。
十份文档感觉比两份更严谨，所以没有任何东西被删除，版本在彼此旁边堆积。
删除什么。
→ 首先是被取代的版本，因为如果六月草案和最终版本都位于同一个项目中，模型没有可靠的方法知道你指的是哪一个
→ 几个月前为了单个问题上传的文档
→ 仅相差一段语的近似重复文档
第一点是最昂贵的。模型有时会以完全的信心根据过时的版本进行回答。
保留什么。你重复引用的任何内容的当前版本。
如果一个项目需要大量参考资料，请按主题将其拆分为单独的文档，而不是一个长文件。然后助手只提取给定任务需要的内容，这与审查本身的原则相同。
之后你会注意到什么。几乎正确的答案变少了。
大多数检索失败是系统找到了错误的文档，而不是模型推理糟糕，这就是为什么这一层能产生最明显的质量飞跃。
第 4 层：工具与连接器
它是什么。所有让助手采取行动而不仅仅是回答的东西。
连接器和集成、自定义 GPT 操作、插件、Claude 技能、MCP 服务器，任何你点击启用的东西。
为什么它是一个日益严重的问题。启用工具只需点击一下，没有任何东西会提示你审查它。人们像积累浏览器扩展一样积累连接器。
为什么它比其他层代价更高。每个启用的工具都会在每个请求上向模型描述自己，在你要求任何事情之前。
十个未使用的连接器意味着在每次对话中有十个描述在争夺注意力。
这是成本不可见的层，因为屏幕上没有任何内容显示这种情况正在发生。
它导致的失败。Manus，其整个产品就是一个代理，发现不断增长的工具包会降低性能。
模型在应该直接回答时伸手去拿工具，或者在两个工具做类似工作时选择了那个差之毫厘的工具。
如果你的助手开始针对它已经知道答案的问题运行搜索，这一层可能是原因。
删除什么。
→ 你一个月内没使用过的任何东西
→ 做同样工作的两个工具中的任何一个，保留你信任的那个
重新启用只需几秒钟，所以删除几乎没有任何成本。
保留什么。你每周使用的东西，以及任何工作流依赖的东西。
之后你会注意到什么。助手减少了对工具的伸手频率，并且更频繁地正确选择。
## 删除测试
死重不会静静地待着。它表现为摇摆不定的回答、错误的工具选择以及被部分忽略的指令。
长度目前还不是你的问题。这一转变背后的研究测量了数万个 token 的性能下降，这远远超出了你指令框中的任何内容。
冲突是你今天的问题。两条指向不同方向的规则在任何规模下都会消耗模型的工作量，这就是为什么 Anthropic 自身的例子是一个矛盾而不是字数统计。
所以对于每条指令，四个问题。
1. 它仍然是真的吗？
这是否是为旧模型或较弱模型编写的？它是否命名了一个后来已更改的版本、限制或能力？
2. 它与任何其他东西冲突吗？
在四个层级的任何一个中，是否有另一条指令指向不同的地方？
冲突的代价最大，因为模型在开始你的工作之前必须解决它们。
3. 能干的新员工需要被告知吗？
如果一个有能力加入你的团队的人已经知道这一点，模型也知道。这是你能做出的最快的删除。
4. 如果删除它会破坏什么？
说出它阻止的特定失败。如果你做不到，它就不是承重的。
根据这四点中的任何一点进行删除。保留具体的、当前的、令人意想不到的内容。
其中两个的处理方式不同，在你开始删除之前值得说明一下。
明显的指令和死冲突可以立即删除，因为你可以看到页面上的问题。任何你怀疑是过时的变通方法的指令，先拉取一周，如果质量下降再恢复。
## 4 个为你自动运行审查的提示词
这四个提示词端到端地运行审查。
第一个发现你的矛盾。第二个将真正的偏好与过时的变通方法区分开来。第三个揭示哪些指令从未起过作用。第四个将幸存的内容重写为结果而不是过程。
按顺序在任何助手和任何项目上处理它们。到最后，你的助手将根据所有指向同一方向的指令工作。
提示词 1：冲突查找器
从这里开始。这会找到相互对抗的指令，这是代价最高且最不可见的问题。
你粘贴你的常驻指令，并得到一个按排名排列的矛盾列表。
```
You are an editor who specializes in finding contradictions in
written instructions.
Context: the text below is the standing instruction set I give an
AI assistant. I have added to it over time and never removed
anything from it.
Your job: find every pair of instructions that could pull toward
different actions on the same task.
Be thorough. Read the whole set first, then check each instruction
against every other one, including ones far apart in the text.
For each conflict:
- Quote both instructions.
- Describe a specific situation where they collide.
- Say which one I most likely meant to win.
Then list any pairs that are redundant rather than conflicting.
If an instruction is too ambiguous to judge, say so and explain
what is unclear.
Output:
1. Conflicts, most frequently triggered first.
2. Redundant pairs.
3. The one conflict to resolve first, with a sentence on why.
My instructions:
[PASTE HERE]
```
你得到的结果。通常有三到六个真正的矛盾，其中大部分是相隔几个月写成的。
通过删除你并非本意的指令来解决排名靠前的一个。添加第三条规则来解决争论正是文件变成现在这个样子的原因。
提示词 2：过时检查
这将你真正想要的内容和你一直在补偿的内容区分开来。
偏好保留。针对不再存在的限制的变通方法是你将要删除的大部分内容。
请注意，此提示词命名了变通方法，而不是声称对它们有专业知识。告诉模型要寻找什么比告诉它要成为谁更好。
```
You are reviewing an instruction set to find rules that are no
longer needed.
Context: the instructions below were written for an AI assistant
over a period of time. Some encode genuine preferences. Others
were written to compensate for things models used to get wrong,
such as rambling, inventing facts, ignoring formatting, or
skipping steps in reasoning. Those compensations often survive
long after the problem stops happening.
Your job: sort every instruction into PREFERENCE or WORKAROUND.
A PREFERENCE describes how I want things done and would still
matter with a perfect model.
A WORKAROUND exists to prevent a specific failure. Common shapes include telling the model to think step by step, instructing it
not to make things up, capping length to stop rambling, demanding
a format it now produces anyway, or repeating an instruction for
emphasis.
For each workaround, name the failure it was written to prevent.
Go instruction by instruction rather than summarizing.
Where you cannot tell whether a failure still happens, mark it
UNCERTAIN and say what I would need to test.
Output: a table with columns for the instruction, its type, the
failure it prevented, and your recommendation of keep, test
removing, or uncertain.
My instructions:
[PASTE HERE]
```
你得到的结果。一个分类为保留和测试的表格。
一次处理一条指令来处理测试列。删除一条，正常使用助手几天，如果质量下降则放回去。
提示词 3：明显性测试
这要求助手报告你的哪些指令实际上改变了它的行为。
大多数人对他们的指令集中有多少内容描述了模型反正会做的事情感到惊讶。
```
You are the AI assistant that receives the instructions below.
Context: I want to know which of these change what you produce and which describe what you would do by default.
Your job: judge each instruction honestly on that basis.
Mark each one:
- CHANGES BEHAVIOR, and state how your output differs with it
versus without it.
- NO EFFECT, meaning you would do this by default.
- UNCLEAR.
Be honest about NO EFFECT even where an instruction sounds
important. General quality words such as thorough, accurate,
professional and helpful usually belong there.
Where an instruction mixes both, split it and judge each part.
Output:
1. The three lists.
2. A trimmed instruction set containing only what changes behavior.
3. The percentage of the original you would cut.
My instructions:
[PASTE HERE]
```
你得到的结果。三个列表、一个精简版本和一个百分比。
将精简版本视为候选者而不是替代品。在采用之前阅读它，因为模型有时会将真正的约束标记为默认行为。
提示词 4：规则到结果
这是审查之后的重写。
它将逐步的过程规则转换为对完成结果的描述，这正是 Anthropic 对其自身提示词所做的确切更改。
```
You are a technical writer who converts process documentation into outcome specifications.
Context: the rules below tell an AI assistant how to do something
step by step. Current models handle the route themselves when they understand the destination, so I want to describe the result instead.
Your job: work out what result these rules were trying to produce,
then describe that result directly.
Write the replacement as three things: what the finished output
looks like, what it must contain, and what would make it wrong.
Keep every genuine constraint, including anything covering safety,
permissions, legal requirements or factual accuracy. Those stay
explicit.
Where you cannot work out what a rule was for, list it separately
and ask me.
Output:
1. The outcome description that replaces the rules.
2. What you removed and why it was safe to remove.
3. Any rule whose purpose was unclear.
My rules:
[PASTE HERE]
```
你得到的结果。一个描述目的地而不是路线的更短的指令集。
Anthropic 自身的这一更改版本是目前可用的最清楚的例子。
他们旧的提示词列出了关于注释和文档的过程规则。替换版本告诉模型编写与其周围代码相似的代码，匹配其注释密度、命名和习惯用法。
一句话，涵盖了规则从未预料到的情况。
## 最常出现的错误
错误 1：将较少的上下文与没有上下文混淆。
不相关和冲突的上下文会造成伤害。相关的上下文仍然有很大帮助。
修正方法。通过输出是否变差来判断删减，而不是根据文件变短了多少。
错误 2：只审查一次。
这会持续累积，因为每一个烦恼都会产生一条新规则，而没有任何东西会导致删除。
修正方法。安排时间。每季度一次，或者每当一个你依赖的模型获得重大更新时。
错误 3：删除具体笔记并保留模糊笔记。
人们删去详细的技术笔记，因为它们看起来很挑剔，然后保留一般性指导，因为它听起来很重要。
这反了。详细笔记是模型无法独自弄清楚的唯一部分。
修正方法。在手动删除任何内容之前运行提示词 3。
错误 4：为每个错误添加一条规则。
这是造成问题的习惯。一个糟糕的输出会产生一条永久的新行。
修正方法。在添加规则之前，检查现有指令是否导致了该行为。冲突产生的错误比缺失规则更多。
## 本审查不适用的情况
你应该保留原样的四种情况。
小型和本地模型。以上所有内容都假设是一个当前的前沿模型。
较小的模型、较旧的模型以及大多数在你自己的机器上运行的模型仍然需要它们的脚手架。如果你确实审查了一个，请在实际使用的模型上测试删除，而不是信任实验室的发现。
你上周建立的设置。审查解决的是累积问题，而还没有任何累积。你将会在猜测你仍然记得做出的决定。
安全、法律和权限约束。任何指定助手必须不做什么、需要什么批准或它不能访问什么的内容，无论模型变得多么能干，都应保持明确。那些不是脚手架。
你已经满意的输出。如果你的助手产生了你想要的结果，这是可选的维护而不是修复。当质量下降或模型更新后运行它。
## 从这里开始
十分钟，三个步骤。
1. 将提示词 1 复制到任何保存你想要审查的指令的助手中。
2. 在提示词说 PASTE HERE 的地方，放入你的常驻指令。你的 ChatGPT 自定义指令、Claude 项目或 CLAUDE.md 文件。
3. 阅读它发现的冲突，然后删除排名靠前的冲突中的一方。选择你并非本意的指令。
这就是整个第一次会话。
冲突是正确的起点，因为它们是代价最高的问题，也是你无法通过阅读自己的文件看到的问题。
两条指令都是你写的。在写的那一天，它们看起来都是合理的。
只有它们之间的碰撞才会造成麻烦，而且这种碰撞出现在你已经接受的输出中。这就是为什么它可以在那里呆一年而你没有注意到。
一旦完成，向外处理各个层级。接下来是记忆，因为你从未审查过它。
你的指令不是你关于工作的所有知识的记录。它们是模型无法独自弄清楚的事情的简短清单。
你有了审查方案和四个提示词。剩下的唯一变量是你是在自己的设置上运行它们，还是继续为不再存在的模型编写的指令付费。
保存这篇文章，并在下一次你依赖的模型获得重大更新时再次运行审查。那是死重回来的时候。
我会随着指导方针的变化不断更新此内容。
关注 @free_ai_guides 以获取更新 ❤️
订阅我的免费新闻通讯，每周获得一项 AI 超能力：http://aisuperpowers.substack.com
## 相关链接
- [AI Guides](https://x.com/free_ai_guides)
- [@free_ai_guides](https://x.com/free_ai_guides)
- [5.5K](https://x.com/free_ai_guides/status/2082463119742320825/analytics)
- [@free_ai_guides](https://x.com/free_ai_guides)
- [http://aisuperpowers.substack.com](http://aisuperpowers.substack.com/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [9:47 PM · Jul 29, 2026](https://x.com/free_ai_guides/status/2082463119742320825)
- [5,534 Views](https://x.com/free_ai_guides/status/2082463119742320825/analytics)
- [View quotes](https://x.com/free_ai_guides/status/2082463119742320825/quotes)
---
*导出时间: 2026/7/30 10:08:57*