One Import Token, Scoped Across Your Tree
A pasted rules file is a copy with no scope, loaded everywhere.
A pattern token is closer to an address: place this rule here, this memory there, this skill at the root.
Scope is what keeps the window carrying signal.
What this covers
- The usual way to share conventions is to paste a long file at the repo root, which is a copy with no scope that loads for every task and grows into the flat-file problem.
- A pattern is imported with a single reference token that expands into placed pieces; the token behaves more like an address than like pasted content.
- Each piece lands at the path it declares, creating missing paths on demand, and you choose the base it attaches under so a generic bundle maps onto your actual tree.
- Scoped placement keeps the context window clean and makes the bundle reversible, while the imported pieces remain ordinary, editable memories, rules, and skills.
Before and after
| Area | Pasting a rules file | Importing a pattern |
|---|---|---|
| What you hand over | One long file of mixed conventions | One token that expands into placed pieces |
| Where it lands | At the root, loaded everywhere | Each piece at the path it applies to |
| Effect on the window | Always on, even where irrelevant | Present only when work touches that path |
| Removing it later | Hunt through a file by hand | Remove the bundle by its token and base path |
Sharing conventions is usually a paste
When a team wants an agent to follow a stack convention, the usual move is to paste. Someone keeps a good rules file and drops it into the repo root, or into a chat, and that becomes the shared context. It is fast, and it is the same shape that does not scale.
A pasted file is a copy with no scope. It sits at one location and loads for every task, including the ones it has nothing to do with. As more conventions get pasted in, the file grows, the agent treats later lines as background, and the follow-rate drops the way every flat instruction file does.
The deeper problem is that a paste loses the one piece of information that matters most: where each convention applies. A rule about the app folder and a rule about the database folder end up in the same undifferentiated block, loaded together everywhere.
A token that expands into placed pieces
A pattern is imported with a single reference token, like ::pathrule:package:nextjs-app-router. Pasting that token into an assistant does not paste text. It triggers an import that reads the pattern definition and places each piece in the workspace.
The token is closer to an address than to content. It says: fetch this bundle, and put its rule here, its memory there, its skill at the root. One short string expands into several scoped pieces, instead of one long block of undifferentiated prose.
For the cases where a token is not convenient, the same bundle can be copied piece by piece from the pattern page. Either way the unit being shared is a structured, scoped bundle, not a flat file someone has to read and re-sort by hand.
Each piece lands at the path it belongs to
The defining behavior of the import is placement. The pattern declares a target path for every piece, and the import honors it. A rule that only matters in the app folder is written to the app folder. A schema memory is written to the database folder. A review skill goes to the root because it applies everywhere.
If the target path does not exist in the workspace tree yet, it is created on demand. The team does not pre-build a structure to receive the pattern. The pattern materializes the paths it needs, mirroring the part of the repo it describes.
You choose the base the pattern attaches under, so a bundle written for a generic app can land on the specific package that actually holds your app. The scope is not hard-coded to one layout. It adapts to the tree you already have.
Scope is what keeps the window clean
The reason placement matters is the same reason this blog keeps arguing against the big root file: context that is always on is mostly wrong. A convention loaded into every session, including the ones it does not touch, spends window budget and lowers the weight the model gives to everything else.
A pattern imported with scope does not do that. The app rule is present when the agent works in the app folder and absent when it works in the database folder. The window for any given task carries the pieces that match the task, which is the whole point of scoping context at all.
So a pattern is not only a faster way to add conventions. It is a way to add them without the token cost of a flat dump, because each piece is delivered by path rather than loaded globally.
Reversible, and it keeps evolving
Because a pattern is a defined bundle rather than hand-pasted text, it can be removed as cleanly as it was added. Remove the bundle by its token and base path and its pieces come back out, instead of leaving you to hunt through a file for the lines you once pasted in.
After import, the pieces are ordinary memories, rules, and skills. They are not frozen. You edit them, the team edits them, and they evolve at their paths as the project changes. The pattern is a starting point that becomes your own context, not a dependency you are stuck with as shipped.
This is the difference between importing a bundle and vendoring a snapshot. The bundle gives you a curated baseline and then gets out of the way, leaving real, editable context where the work happens.
Try one import
The cheapest way to see the mechanism is to import one pattern into a repo you know well. Pick a stack you use, paste its token, and look at where the pieces land. The placement, more than the content, is the part worth feeling directly.
Then open a session in one of the targeted folders and confirm the scoped pieces arrive, and open a session in an unrelated folder and confirm they do not. That contrast is the whole argument for importing by scope instead of pasting at the root.
Every signup gets three months of Pathrule PRO on the house. If you want help choosing patterns or mapping them onto a real tree, [email protected] is open, and the full catalog is free and Apache-2.0.