Your AI Got Smarter. Your Setup Did Not

Most AI setups grow the same way. The model does something wrong, you write a rule. It skips a step, you write another. After a year you have rules files, project notes, memories, skills and saved prompts, all written to make an older model behave.

Then the models get smarter, and the rules stay exactly where they were.

This is a practical guide to cleaning that up. Three steps, three prompts you can copy, and a short list of what to keep. I ran it on my own setup this week, and my main rules file came out at less than half its original length without losing a single boundary I care about.

Why old rules turn against you

Older models needed handholding. They skipped steps, forgot things and gave up early, so we wrote instructions that told them how to work, step by step, often in capital letters. Newer models reason for themselves. The same instructions now replace their judgment with yours, and yours was tuned for a weaker model.

Anthropic says this plainly in its own prompting guide. If your prompts pushed older models to be more thorough, dial that guidance back. Where you once wrote "CRITICAL: You MUST use this tool", write "Use this tool when". Verification steps carried over from older prompts should be removed rather than rewritten, because the newer models already check their own work.

The structure below comes from Actionable AI's guide Make Your AI Smart Again. Audit, cut and retool, then change how you prompt from here on. The prompts are my versions of theirs, adjusted after using them.

Step one: audit before you touch anything

The temptation is to start deleting. Resist it. The rules that annoy you are not always the expensive ones, and you will cut the wrong things. Ask the model to read everything first and rank it.

Read my entire setup: every rules file, project file, memory note,
skill and saved prompt.

For each instruction, tell me:
1. Does it describe HOW to do the work instead of WHAT the work is?
2. Was it written for an older model, and does it now slow you down
   or limit your reasoning?
3. Does it contradict another instruction somewhere else?
4. Is it a fact that is no longer true?
5. Is it doing real work, and should it stay?

Rank everything by how much it costs the quality of your output.
Do not change anything yet.

Question four is my addition. The original guide does not ask it, and I would not skip it.

What to look for

Most people expect the problem to be method: too many "first do this, then do that" rules. Those are real, but they are rarely the most expensive part. The audit usually surfaces four kinds of problem.

Method. Instructions that describe the steps instead of the result. "Open the file, read it twice, then write a summary in three bullets" tells the model how to think. "I need a summary I can read in ten seconds" tells it what done looks like, and lets it find the best way there.

Habits from weaker models. Remind me at the start of every session. Repeat the rule because once is not enough. Double check everything before you answer. These made sense when models lost track of things halfway through a task. Now they are noise the model has to obey.

Contradictions. A setup written over months ends up disagreeing with itself. A project note allows something your global rules forbid. A skill does automatically what another file says to do only on request. The model is not ignoring you. It is obeying two versions of you at once, and you cannot predict which one wins.

Stale facts. A product description that changed, a tool you no longer use, a price that moved. A stale fact is worse than a bad instruction, because the model has no reason to doubt it. It builds on top of it with total confidence.

When I ran the audit, the contradictions and stale facts cost more than all the method rules combined. That is the part I would not have guessed on my own.

Step two: cut, then rewrite what is left

Using the audit, do two things.

First, delete everything that is not needed. Show me what you removed
and one line on why.

Second, rewrite what is left so it works with a model that reasons on
its own: state the outcome, state the hard boundaries, state what good
looks like, and stop describing the method.

Show me the before and after of every file side by side. Change nothing
until I approve it.

Two things make this step safe. First, do not delete anything for real. Move removed rules into an archive folder that never loads, so any cut is one move away from coming back. Second, review every file side by side, old version on the left and new version on the right, and approve one file at a time. It is slower, and it is the only way to trust the result.

A typical rewrite looks like this. Before:

Keep replies short. Never write more than six lines. Do not explain
your reasoning. Do not list options. Check the length before sending.

After:

A good reply is as short as its content allows. A status update is
three or four lines. Analysis I ask for gets the length it needs.

The first version works for status updates and quietly damages everything else, because it cuts the caveats out of analysis you actually need. The second describes what good looks like and lets the model decide. A limit decides for the model. A description of good lets it decide, and it usually decides better.

What stays

Trimming does not mean trusting the model with everything. Keep the facts it cannot guess and anything that cannot be undone.

• Your customers, your prices, your voice and your constraints. No model can infer these, however smart it gets.
• Anything irreversible or outward facing: what it may send, spend, deploy, delete or publish. Put these in one short section, call it hard boundaries, and make every item say to ask you first.
• Rules with a real reason behind them. If a rule exists because something went wrong once, keep it, but cut it down to one line that says what to do, not the story of why.

The test is simple. Remove the method, keep the context and the boundaries.

Step three: prompt the new way

A trimmed setup only helps if you stop rebuilding the old habits one prompt at a time. The guide ends with a four layer structure worth using for any real task.

GOAL: [the finished outcome, not the next step]

RESEARCH: Before you start, find the best approach for this and tell me
what you picked and why.

INTERVIEW: Ask me whatever you need to know. One question at a time.

GOOD LOOKS LIKE: [one real example of the finished thing]

The layer people skip is the last one, and it does the most work. A list of adjectives like direct, friendly and confident describes a voice. One real paragraph you wrote shows the model what that voice sounds like. If you want output in your style, paste your own writing, not a description of it.

Research feels strange at first, because for years we told the model how to solve things. Ask it to find the best approach and defend it instead. Sometimes it picks the one you had in mind. Sometimes it finds a better one, and you would never have seen it if you had written the method into the prompt.

Your setup should shrink as the models improve

Most people treat their AI setup like a codebase that only grows. Every bad afternoon adds a rule, and nobody deletes one, because who knows what it was protecting.

I think that is backwards. Every new model should make your instructions shorter. If yours keep getting longer, you are still managing a model that no longer exists.

Run the audit, and read the ranking before you touch anything. The rules you worry about are probably cheap. The contradictions and the stale facts are where the cost hides.