Overview
A new model shipped. The usual move is to add configuration: instructions tuned to its quirks, procedures for its new features, work reassigned that the old model could not handle.
The day Fable 5.1 arrived, I did the opposite. Half a year of accumulated instructions, cut in half in one day.
Scaffolding built for a weak model becomes dead weight on a strong one.
This is not a matter of taste. The numbers are below.
Scaffolding quietly outweighs the building
Rulebooks grow one failure at a time.
Run AI agents on real work and every mistake tempts you to add a line. “Verify on the actual device before declaring done.” “Look at other people’s edits before overwriting a shared file.” “This client spells it this way.” Each line is correct. All of them are. That is why none get deleted. After six months there were more than 150 of them.
By July, half the context window was gone before the conversation started.
Always-loaded instructions had reached 156KB. Open a session and roughly half the window was already consumed; a few exchanges later, compaction kicked in. I trimmed the three biggest files from 110KB to 36KB and bought some time. By late August the always-on load was back at 28,000 tokens. Cut it, and it regrows, because the structure itself is the cause: every failure produces another line.
Scaffolding is shaped for the model that needed it.
Those 150 case rules are a map of where the agent tripped before. A model with weak judgment falls into the same hole without the map. Hand the whole map to a model with strong judgment and it spends the window reading the map instead of thinking about the job.
What stayed, what got thrown out
One test: does this line apply every single time?
Lines that apply every time stay. Lines that only matter for one client, one screen, one past failure come out of the always-on load. They can be pulled in when needed. That sorting alone took always-on instructions from 37,000 tokens to under 13,000.
Memory got the same test. Of four memory systems, two were alive and in use. The rest were charging read costs and returning nothing. Per-agent memory had swollen too; the largest was 515KB and every one is now under 30KB. Unused tool connections and skills came out as well.
What dropped was compaction frequency and the hours spent writing rules. Output quality did not drop.
Killing AI-sounding prose without a banned-word list
The same principle applied to writing discipline.
AI prose announces itself. “It is important to note.” “To summarize the above.” “I hope this helps.” I wanted it gone. The obvious fix is to paste a banned-word list into every character’s instructions. Thirty characters, thirty copies of the same list.
I did not do that. A banned-word list is scaffolding again. Six months later I would be holding 150 banned words and writing this article a second time.
The norm handed to the model fits on one card. Vocabulary checking lives outside the model.
The model gets only “how to write,” kept short. It does not get a list of “what not to write.” Counting banned words is inspection, not judgment, and inspection is a machine’s job. Split the roles and the rulebook stops growing.
The next day I audited every character’s instructions. Not one old habit needed fixing for the new model. What turned up was human clutter, all of it. The rot was on the human side, not the model’s.
Instructions multiply when you do not trust the model
A thick rulebook is evidence that you do not trust the model.
Six months ago a note in my backlog read: “Research says oversized system prompts hurt. Worth testing.” It sat there as a seed. This week I collected on it. Always-on load down to a third, output quality unchanged. What dropped was compaction frequency and the hours spent writing rules.
When the next model arrives, I will cut again.
Adding is easy. One line per failure and you feel safe in the moment. Cutting is hard. You have to decide which lines are no longer needed, and that means estimating how much judgment the other side now has. That decision is the part that stays human.
This is what inventing systems together with AI actually means. Systems are not something you keep adding to. As the partner grows, you let go of the same amount.