How I Organize Global and Project Rules
What every agent should follow everywhere goes global; what only matters to one project stays in that project. A rule gets added when a problem keeps coming back, a skill when a task really needs finer guidance.

As I mentioned before, after GPT-6 came out I did a cleanup and deleted every rule and skill I had added.
Since then I've added things back only when I actually needed them. It's been a while, so here is what I've added so far and how I organize global and project rules.
I used to dump all my rules and skills into the global scope. After the cleanup I decided to separate global from project, to keep irrelevant content out of the context as much as possible.
What I want the agent to follow in every situation goes global. What only matters to the current project goes into that project.

01 Global Rules
My global rules are roughly these:
Be clear and concise. If one sentence is enough, don't use two.
Answer simple questions quickly; think deeply about complex ones.
Don't append a question to the end of every reply just to keep the conversation going. Ask only when you really need to.
Before searching the web or exploring local files, clarify the question and estimate the scope, output size, and cost of delegating. Hand it to a sub-agent only when that clearly saves time or reduces the main agent's context usage.
One or two rounds of web search, or one to three local checks, usually just do it directly. Three or more rounds of web search, about five or more local steps, or work involving repeated searching, cross-file exploration, or lots of material, consider delegating. Judge by the task's scope, not the repository's size; the numbers are only a guide.
Give sub-agents a clear goal, and only run independent tasks in parallel. Return a short conclusion with sources: links for web pages, paths and line numbers for local files. Don't stuff raw content or long logs back into the main context, and don't delegate further just because of these rules.
That's basically enough.
I've talked about the search part in an earlier video. Most of the time, what's useful is the conclusion. All the material you flip through while searching doesn't need to stay in the main agent's context window.
Case 01 | Looking up one command vs. comparing two tools
If you only need a tool's install command, the main agent can look it up directly. If you need to choose a testing tool for a project, read several docs, and compare them, hand it to a sub-agent and have it bring back a conclusion with sources.
With the global rules above, my instructions only need to state what I want, and the agent decides whether to split the task.
The two rules about replies were added because the behavior annoyed me.
One is replies that are too long. Something that takes one sentence gets expanded into several paragraphs.
The other is appending a question after every answer. I came to ask one thing; answer it and you're done. But it always wants to keep the topic going.
If information is really missing, ask. If it's just to keep chatting, don't.
Besides rules, the global scope also holds skills.
What I keep globally is the set of skills from Matt that I recommended earlier. He packaged them into a plugin that covers a lot of situations, and I don't want to reinstall it for every new project.

02 Project Rules
I mostly work on two kinds of projects. One is the personal wiki I set up a few days ago. The other is a vibe coding project I start whenever an idea hits me at work or while scrolling Twitter.
The rules for the personal wiki live in AGENTS.md at the folder root. They mostly cover how to maintain it: where material goes, what to refer to when curating, and what to produce afterward.
Vibe coding projects are the same: based on the project's direction and goals, I first write rules specific to that project.
The skeleton of both kinds of rules is about the same. I care most about two things.
First, the project's architecture.
Which folders exist and what goes in each. For a code project, what each module is responsible for and how they relate. Once this is spelled out, the agent knows where to look when it works.
In the personal wiki, for example, original material, source summaries, curated concepts, and my own articles each have their own place. With the directory relationships written down, new content always has an obvious home.
Second, the project's maintenance process.
How to add content, how to change existing content, how to handle problems, and how to check when you're done. I write SOPs for these common situations.
In the wiki that means ingesting and curating material. In a code project it might be adding features, fixing bugs, or restructuring. The steps change, but the agent always needs to know how work moves forward in this project.
For the projects I'm doing now, getting these two parts down is enough to start. After that I adjust based on the specific goals and the problems I run into.
Case 02 | Ingesting an article without re-explaining the process
Say I find an article worth keeping. I send the link or the full text to the agent and tell it to add it to the wiki.
This works because the project rules already describe the ingestion flow: keep the original, write a source summary, link new knowledge to existing topics, and finally update the index and the log. So each time I only need to say what to add.

03 Add Skills as Needed
Which extra skills each project gets depends on what it needs.
For the personal wiki I basically don't add any. If I ever need illustrations for an article, I'll bring in the image generation skill I made earlier.
In vibe coding projects, if I'll spend a lot of time polishing frontend UI and interaction, I add skills like Frontend Design and motion design.
Case 03 | The modal works; now polish the interaction
Say a modal already opens and closes correctly, but the transition is abrupt and feels stiff. That's when a motion skill helps the agent tune the enter and exit animation, duration, and easing.
But if I'm just writing a few scripts, simple backend features, or some automation, I usually tell the agent what to do directly. In my experience so far, those tasks don't really need extra skills.
Agents are already strong at logic. Sometimes, before you've even sorted out your own thinking, they can string together a very smooth line of reasoning for you.
There is one case where I deliberately use a skill: when a project is about 80% done and I look back to find more and more duplicated code and tangled relationships between modules, and I want to refactor.
That's when I use Codebase Design from Matt's plugin, which I have installed globally, to rework the modules and interfaces. It has worked very well for me.

So after the cleanup, everything I've added back has a specific reason: when a problem keeps coming back, I write a rule; when something really needs finer guidance, I add a skill.