45 Rule Files Were Making My AI Worse

JLJeff Liu··2 min read

After months of building with AI agents, the pile had grown. Custom rules, workspace knowledge, skill files, honestly, probably too much stuff. 45 rule files telling my AI how to behave. Naming conventions. Code patterns. Anti-patterns. Deployment checklists. Security gates.

Forty-five files.

And the AI was getting worse.

It wasn't broken, but the output was getting sloppy in ways I couldn't pin down. It would confidently reference a file path that didn't exist anymore. It would apply a pattern from one rule while ignoring a contradicting rule three files later. Code that technically followed the instructions but missed the point entirely.

I kept adding more rules to fix the problems the other rules were causing. Classic.

The measurement

Then I actually measured it. Each session was loading roughly 170KB of rule context, about 25,000 tokens, before I even said anything.

That's like handing someone a 50-page employee handbook and then asking them to fix a bug. They skim. They miss stuff. And whatever they don't see, they guess.

There's a well-known psychology concept called Miller's Law. Working memory can only hold about four to seven things at once before it starts dropping stuff. Context overload isn't just an AI problem. It's a human one.

I think that's what hallucination actually is a lot of the time. Not the AI being dumb. Just the AI drowning in your instructions and filling in the gaps.

What I actually cut

So half of them had to go.

Not randomly. Every rule file got the same questions. Is it contradicting another rule? Is there fragmentation, two files saying similar things slightly differently? Is it actually reducing hallucination risk, or just making me feel like I covered my bases?

If it was redundant, it got cut. If two rules overlapped, I merged them. If a file was longer than 5KB, it got split into smaller pieces that only load when relevant.

45 files became 30. 170KB became 72KB. ~25,000 tokens saved per session.

The output quality improved immediately. Not because the rules were bad, but because fewer rules meant the AI could actually follow the ones that mattered.

The lesson that keeps repeating

At some point, more structure just becomes more noise. The governance I built to prevent mistakes was creating new ones. The fix wasn't better rules. It was fewer of them.

The rule cleanup saved me about three days of accumulated drift. Not bad for deleting files.

Keep reading

Building a Commit Guard for AI Agents That an Adversary Can't Slip Past

I gave a coding agent a guard that checks every commit lands in the repo and branch I intend. My 417 tests were all green. Then I hired a second agent to break it, and it walked through two holes the green suite never thought to check.

Read

Graph Engineering Makes Agent Failure Legible, Not Agents Reliable

A video making the rounds argues graph engineering supersedes the loop-based agent pattern. After building multi-agent systems, I think the loop-versus-graph framing asks the wrong question. Topology decides whether you can SEE a failure, not whether one happens. Reliability lives in the deterministic checks at the edges, not in how you wire the agents.

Read

Claude Desktop vs Cowork vs Code: A Beginner's Roadmap to Which One to Use

Claude Desktop, Cowork, and Code look interchangeable. The real difference is what survives when the session ends, and that decides which one to build in.

Read

Remote-Controlling AI Coding Agents From Your Phone: What's Real, What It Costs, and Where It's Going

For fifty years, controlling a computer meant sitting at it. AI coding agents broke that. Here''s how I drive my agents from my phone, what it actually costs, the local-vs-cloud distinction, and why this turns you from an operator into a conductor.

Read

Running Multiple AI Coding Agents in Parallel: A System for Safe, Self-Merging PRs

Running several AI coding agents on the same repo turns into a coordination problem fast. Here's the system I built to keep them isolated, review each other's work, and merge their own pull requests safely.

Read

Why I'm Building AI Education for Kids

I didn't think I'd hear back from Runway. Then this morning, I got accepted into their Builders program. Reflecting on why this mission is personal, and how we can ensure kids don't get left behind in the AI era.

Read

AI Native, Human First

You can outsource thinking and execution to AI. But you cannot outsource understanding. Real learning and proactive groundwork are first-class survival skills in the AI era.

Read

Using AI Without Losing Your Humanity

Everyone has access to the same AI tools now. So what sets you apart is no longer how much content you can generate. It's whether it makes people feel something, and whether you can use AI without losing your humanity.

Read

How I Built a Publishing Stack for AI Search

People are finding things through ChatGPT and Perplexity instead of Google. I built a pipeline that handles the optimization for that automatically. Here's how it works.

Read

Building Systems, Then 10x the Output

At Zeta Global, my team gave me room to figure things out. I tried to do the same for the people who came after me, from responsive templates to training engineers across time zones.

Read

Why I Let AI Fight With Itself Before I Ship Anything

When I build with one AI for too long, the output starts drifting, confident but incomplete. A second model catches what the first one misses. Here's the two-pass process I use now.

Read

How I Turned My AI's Mistakes Into Guardrails

I added Husky because of an anti-pattern. CI because of an anti-pattern. PR requirements because of an anti-pattern. None of it came from reading best practices. It came from breaking things and writing it down.

Read