Why I Keep the AI's Rules to Ten Pages
My AI operating system runs nine subsystems, and its rulebook is capped at ten pages. Every new rule has to beat an old one to get in. Adding rules never gave me more control; ranking them did.
The Page Limit Rule: What the Operator to Builder Transition Taught Me About Context Engineering
Somewhere in the middle of my operator to builder transition, I built myself a boss. It's a rulebook: one file that governs how my AI operating system behaves, what it may decide alone and where it has to stop and ask. That file has a hard page limit, and the limit has done more for the system than any rule written inside it.
This is a piece about context engineering, though it didn't start as one. It started as a mess of my own making, and I want to walk through the mess first, because that mess is where most builders are standing right now.
The Rulebook That Kept Growing
When I moved from running operations inside large businesses to building my own systems, I brought one habit with me: when something breaks, write a rule. That habit served me for fourteen years inside Rs.200 Cr to Rs.1000 Cr operations. A vendor payment went wrong, so the firm added an approval step; a dispatch slipped, so it added a checkpoint. The binder grew, and the thick binder was proof that someone was managing.
So when I started running my consulting work on a personal operating system, with nine subsystems doing real work every day, I did the same thing. An agent saved a report in the wrong folder, so I wrote an instruction about folders. A draft went out sounding nothing like me, so I wrote three instructions about voice. A scheduled task failed without telling anyone, so I wrote a rule about failing loudly.
Each rule made sense on its own, and every one of them solved a real problem from a real bad day. Six weeks in, the rulebook had roughly doubled, and the system was getting worse.
Why More Rules Made the System Dumber
The mechanism is plain once you see it. Each rule I added was an instruction for one situation and also a charge on every future decision the system made.
An AI agent reads its standing rules the way a new employee would read the whole company handbook if they were made to read all of it, every morning, before doing anything. Twenty pages of instructions means twenty pages competing for attention on a task that needed three of them, and the task gets buried under the preamble.
Then the contradictions started. A rule I wrote in March about formatting conflicted with a rule I wrote in May about keeping things short. I couldn't see the conflict, because I never read the whole book in one sitting. The system read it in one sitting every time, and on every task it had to settle the argument somehow, without saying how.
The failure didn't look like disobedience; it looked like mush. Outputs became average and decisions became hesitant. The system was following my instructions, and there were simply too many of them for it to do anything well.
The Old Frame I Had to Drop
My old frame was the operator's frame: more rules equals more control. It's the thinking behind every thick SOP binder in every founder-led company I've worked with, and it fails for the same reason in both places, because it treats rules as free.
In a human organisation, every policy costs reading time, training time and time spent handling exceptions. People pay that cost by ignoring the binder without saying so, which is why the thickest rulebooks tend to sit in the companies with the loosest real discipline.
In an AI system the cost is worse, because nothing gets ignored. Every rule takes up working memory the task itself needed, and the full cost is collected on every single run.
Context is a budget, and that's context engineering in one line. Prompt engineering asks how to phrase an instruction. Context engineering asks a harder question: of everything I could tell the system, what earns a place in it at all?
The Page Limit Rule
So I set a ceiling: the rulebook has a hard page limit, and right now that limit is ten pages. Ten isn't a magic number. A fixed number forces a discipline that good intentions never do.
The rule that matters is the rule about rules: every rule I add has to earn its place, and past the ceiling something old gets cut. That changed my own behaviour more than the system's, because adding a rule became expensive. Before I write a new instruction, I now ask whether the last failure really came from a missing rule or from a bad rule already in the book. About half the time, the honest answer is that the fix is a deletion.
The rulebook now turns over like an investment portfolio. Positions get reviewed, weak holdings get sold, and nothing stays in just because it has always been there.
What Counts Against the Limit
One distinction keeps the ceiling workable: not everything counts against it.
Reference material sits outside the limit, including playbooks, templates, past decisions and data, and the system loads it only when a task needs it. The page limit applies to standing rules, the instructions every subsystem reads before every task on every run.
A library can be large, but a constitution has to stay short. The moment I let reference material creep into the standing rules, the cost comes back, so the line between the two is itself one of the ten pages.
The Same Pattern in Founder-Led Firms
I keep meeting the human version of this in founder-led companies. Nobody ever deletes a policy, the approvals matrix only grows, and exceptions multiply, because the fastest way through a thick rulebook is to go around it.
Then one day the founder notices that the best people ask for exceptions more often than they ask for direction. The binder nobody reads has turned into the operating model nobody follows.
The founder's instinct is to write a clearer binder, when the fix is usually a shorter one. If every policy had to justify itself again against a fixed space once a quarter, most companies would find that half their rules were written for one bad day in 2022 that never came back.
How I Run the Review
The review sits in a fixed monthly slot of thirty minutes, enforced by the calendar. I read the whole book from top to bottom in one sitting, the way the system does, and that one habit finds contradictions faster than any tool I've tried.
Each rule has to answer three questions out loud. What incident created you? Have you been used since? What would break if you left? A rule that fails all three is cut on the spot, and a rule that half-fails gets merged into a neighbouring rule, which is where most of the shrinking comes from.
The first review cut four rules and merged six into two, and nothing broke. The second review cut three more, and still nothing broke. Somewhere around the third review I stopped being afraid of deletions, and looking back, that was the real milestone in my operator to builder transition: trusting the structure enough to carry fewer rules.
The Principle
A limit on the number of rules is the strongest rule in the book. A fixed space forces the rules into a ranking, while unlimited space means none of them has to matter.
The page limit didn't make my system more obedient. It made me more honest about what the system actually needs to know, and that honesty is what the system really runs on.
If you're building your own operating system, for a business or for an AI, start with the ceiling before you write the rules. I write about how I run mine at anjanipandey.com