- name
SKILL.md
The skill file stays in the publisher's repository.
Paste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add agentsope/SkillAlchemy --skill agentsop-conventions-pinning -a cursor -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add agentsope/SkillAlchemy --skill agentsop-conventions-pinning -a claude-code -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add agentsope/SkillAlchemy --skill agentsop-conventions-pinning -a codex -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add agentsope/SkillAlchemy --skill agentsop-conventions-pinning -a grok -ySend the copied message in a Grok Bot chat. The Bot fetches this SKILL.md from GitHub and adds it to the skills all your Bots share.
Install this skill: https://github.com/agentsope/SkillAlchemy/tree/HEAD/skills/agentsop-conventions-pinningFrom the publisher
One line: a conventions file is the system prompt of your codebase. Treat it like a system prompt, not like a README. Anti-patterns: writing prose, narrating history, marketing the project. Patterns: command-first, verifiable, "prefer X over Y", < 200 lines.
make lint before commit"), write a hook / precommit / CI check..eslintrc, pyproject.toml, .editorconfig, tsconfig.json. Point the agent at the config; don't duplicate.A conventions file earns its tokens only if it contains information that is not already in the repository. The research is unambiguous on this: "Developer-written context files performed better for exactly the reason you'd guess: they contained information that wasn't already in the repository — tooling preferences, workflow requirements, conventions that existed in developers' heads but not in any documentation." [developer.upsun.com/posts/ai/agents-md-less-is-more]
If everything you would write into CONVENTIONS.md is already discoverable from package.json, pyproject.toml, .eslintrc, the test directory, and obvious code patterns — don't write the file. The agent will pre-cache it itself.
+-------------------------------------+ +-------------------------------------+
| COMPILE-TIME (conventions file) | | RUNTIME (code review / lint / CI) |
| | | |
| - Loaded once per session | | - Runs on every change |
| - Shapes generation | | - Catches violations after-the-fact|
| - Cheap to update, free to ignore | | - Costly to set up, hard to ignore |
| - "Prefer X over Y" lives here | | - "X must always hold" lives here |
| - Style + intent + preferences | | - Invariants + safety + correctness|
+-------------------------------------+ +-------------------------------------+
^ ^
| Conventions guide; |
| review enforces. |
| Both are needed; they fail |
| in different ways. |
Conventions fail by silent drift: agent ignores the rule once, no one notices, code is merged. Review fails by late catch: violation is found post-PR, expensive to fix. The two complement, not substitute.
Every coder-tool has settled on one of four mechanics for getting persistent context into the agent. Knowing which mechanic your tool uses is the difference between "agent reads my rules" and "agent silently ignores them."
A project that uses multiple tools should pick one source of truth and have the other tools @-import or symlink to it. Claude Code 2.x docs explicitly recommend this: "If your repository already uses AGENTS.md for other coding agents, create a CLAUDE.md that imports it ... @AGENTS.md." [code.claude.com/docs/en/memory]
The litmus test: would this information be discoverable by a competent developer who spent 30 minutes browsing the repo? If yes — leave it out, the agent will discover it too. If no — pin it. [developer.upsun.com/posts/ai/agents-md-less-is-more]
Claude Code documentation: "Target under 200 lines per CLAUDE.md file. Longer files consume more context and reduce adherence." [code.claude.com/docs/en/memory]
Cursor docs: "Keep rules concise: under 500 lines. ... A 1,000-word always-apply rule is expensive, so trim aggressively or convert it to auto-attached with appropriate globs." [cursor.com/docs/rules]
Aider docs: "Above about 25k tokens of context, most models start to become distracted." [aider.chat/docs/troubleshooting/edit-errors.html] — and CONVENTIONS.md is one chunk competing for that budget against the actual code.
When the file passes ~200 lines, split it: glob-scoped rules (Cursor, Claude Code paths:), per-language file (python.md, react.md), or move detail into a skill that loads on demand.
You will eventually hit: CONVENTIONS.md says A, the existing code shows B. What wins?
Default precedence the major tools converge on:
managed/org policy > user (~/.claude/) > project (./) > local (gitignored)
(loaded in order; later overrides for conflicts)
existing code in repo ⟂ conventions file ← these don't have built-in precedence;
you must declare it explicitly
The agent does not know which one you want to win unless you tell it. Two patterns:
Claude Code docs warn about this directly: "If two rules contradict each other, Claude may pick one arbitrarily. Review your CLAUDE.md files ... periodically to remove outdated or conflicting instructions." [code.claude.com/docs/en/memory]
[Q1] Will this codebase be touched in ≥ 3 future sessions?
no -> skip; pin nothing.
yes -> continue.
[Q2] Are there style/library choices NOT already encoded in config files
(pyproject, eslintrc, editorconfig, tsconfig)?
no -> point the agent at the existing configs; skip a conventions file.
yes -> continue.
[Q3] Is the rule something the agent should DO (guidance) or something that
MUST hold (invariant)?
must hold -> write a hook/precommit/CI check instead.
guidance -> conventions file is the right tool. Continue.
Start with 5–15 bullets, max. Aider's documented example is exactly this minimal: two bullets ("prefer httpx over requests" + "use types everywhere"). [aider.chat/docs/usage/conventions.html]
Structure template (copy this):
# <Project> Conventions
## Language & versions
- Python 3.12+ (no 3.11 syntax workarounds).
- Node 20 LTS, TypeScript strict mode.
## Libraries — prefer / avoid
- HTTP client: prefer `httpx` over `requests`.
- Date math: prefer `pendulum` over stdlib `datetime` for tz-aware ops.
- Avoid: `os.system` (use `subprocess.run`), `eval`, raw f-strings in logging.
## Style
- Type hints everywhere (`ANN*` ruff rules are on).
- 2-space indent (TS), 4-space (Python).
- No inline comments unless explaining "why not how".
## Layout
- API handlers: `src/api/handlers/`
- Shared types: `src/types/`
- Tests mirror source: `tests/<module>/test_<file>.py`
## Workflow
- Before commit: `make fmt && make test`.
- Conventional commits: `feat:`, `fix:`, `chore:`, `refactor:`.
## When this file disagrees with existing code
- Treat existing code as drift; propose a refactor in a separate commit.
Save it at the canonical location for the primary tool:
This is where most projects fail silently.
Verify the load worked, every time you change tools or environments:
/tokens shows the file in the context budget./memory lists it.If the file isn't shown — the agent isn't reading it. Don't proceed.
Pin one specific, verifiable rule (e.g. "use httpx not requests"). Then ask the agent to write a new HTTP call from scratch. If it uses requests, the load failed or the rule is too vague. Fix and retest.
This is the same test Aider documents: their example explicitly shows httpx + type hints get used with CONVENTIONS.md and requests + no types get used without. [aider.chat/docs/usage/conventions.html] If you cannot produce that A/B in your own setup, the load is broken.
Add a rule when (codified from Claude Code docs): [code.claude.com/docs/en/memory]
Delete a rule when:
Split a rule when it only applies to part of the codebase: use glob-scoped rules. Claude Code .claude/rules/api.md with paths: ["src/api/**/*.ts"]. Cursor: per-.mdc globs: field. This shrinks the always-on context budget. [code.claude.com/docs/en/memory], [cursor.com/docs/rules]
1. Run `/memory` (or equivalent) — list what's loaded.
2. For each rule:
- Has it been triggered? (grep recent PRs / chat for the keyword)
- Does the codebase still follow it? (grep code for violations)
- If both no → delete.
- If first no, second yes → the rule is enforced by gravity; consider deleting.
- If first yes, second no → drift; either fix code or kill rule.
3. Check size: > 200 lines → split into glob-scoped rules.
4. Check for contradictions across files (project + user + ancestor).
Eight reusable operations. Each is Trigger / Action / Output / Evidence. Detailed JSON form in intermediate/operation_candidates.json.
--read CONVENTIONS.md but the agent still uses requests instead of httpx"Symptom: rule is loaded (Aider /tokens shows it; Claude Code /memory lists it), but generation ignores it.
Differential diagnosis (cheapest first):
/tokens to confirm.requests. Code-in-context is a stronger demonstration than a one-line rule. "If two rules contradict each other, Claude may pick one arbitrarily." [code.claude.com/docs/en/memory] Fix: add the conflict-resolution clause to CONVENTIONS.md ("if existing code uses requests, treat as drift and propose refactor"), or /drop the conflicting files.httpx.Client with timeout=10.0; do not import requests" is not.~/.claude/CLAUDE.md) says one thing, project says another. Claude Code loads them in a defined order (managed → user → project → local) [code.claude.com/docs/en/memory] — but if both have the same rule wording with different answers, the merge is ambiguous. Verify with /memory.Resolution rule: if cases 1–4 don't resolve it, the rule belongs in enforcement (lint, precommit), not guidance. Add a ruff rule to pyproject.toml that bans import requests. The conventions file is not a hammer.
httpx, half use requests. Fix in conventions or in code?"Trigger: codebase has visible inconsistency. Agent will mirror whichever file it reads first.
Decision rule:
The anti-pattern to avoid: writing "agents should use httpx going forward" without doing the migration. The agent will see 50% requests in the existing code, ignore your rule, and the drift continues. Conventions describe the codebase you have, not the one you wish you had. If the rule contradicts > ~30% of the existing code, fix the code first, pin the rule second.
Decision: one. Two files = two truths = silent disagreement.
Implementation (Claude Code 2.x's recommended pattern): [code.claude.com/docs/en/memory]
repo/
├── AGENTS.md # canonical, ~80 lines
├── CLAUDE.md # one line: "@AGENTS.md"
├── .cursor/rules/main.mdc # frontmatter alwaysApply: true; body: contents copied or symlinked
└── .clinerules/main.md # symlink → ../AGENTS.md (Cline reads .md transparently)
For Cursor (.mdc files require frontmatter, can't symlink raw), either:
.mdc from AGENTS.md in a pre-commit hook, ORSurprising finding from the research: Claude Code's /init reads existing .cursorrules and .windsurfrules and incorporates them into the generated CLAUDE.md. [code.claude.com/docs/en/memory] So if you already have a .cursorrules, Claude Code will not silently ignore it on first init — it pulls it in.
Diagnosis: violating both Aider's 25k-distraction threshold (in aggregate context) and Claude Code's 200-line per-file recommendation. [code.claude.com/docs/en/memory], [aider.chat/docs/troubleshooting/edit-errors.html] Cursor's docs are even more explicit: "if you're hitting context limits, look at your always-apply rules first." [cursor.com/docs/rules]
Resolution sequence (cheapest first):
.claude/rules/python.md with paths: ["**/*.py"]; Cursor .mdc with globs: field). Only the rules matching files-in-this-session load.Target after pruning: < 150 lines, every line a verifiable directive.
Decision: not yet. Pinning conventions before the conventions exist forces premature decisions and the agent will fight you on them.
Right sequence:
The exception: policy-level rules that aren't about code style but about constraints — "never call external APIs without explicit approval", "no secrets in git history", "all functions need docstrings". Those can be pinned from day 0 because they don't depend on emergent style.
The unintuitive bit: CONVENTIONS.md is context, not enforcement. Claude Code documents this explicitly: "CLAUDE.md content is delivered as a user message after the system prompt, not as part of the system prompt itself. Claude reads it and tries to follow it, but there's no guarantee of strict compliance, especially for vague or conflicting instructions." [code.claude.com/docs/en/memory]
Tiered response:
package.json / pyproject.toml. The agent reads those. "Context files generated by /init commands are doing little more than pre-caching information the agent would discover on its own." [developer.upsun.com/posts/ai/agents-md-less-is-more] If it's already there, leave it out./memory. [code.claude.com/docs/en/memory].cursor/rules/ each with one bullet is a different kind of bloat. Group by topic; aim for 3–8 files if you split, not 30.--read CONVENTIONS.md to .aider.conf.yml means new shells silently lose it. Cursor: not setting alwaysApply: true means the rule sits inert. Always verify load with the tool's introspection (/tokens, /memory, sidebar).~/.claude/CLAUDE.md) helps for personal prefs but is not shared.CLAUDE.local.md (Claude Code, gitignored) or env files for personal paths..mdc files. The legacy .cursorrules (single file) is deprecated; you migrate piece by piece. [cursor.com/docs/rules].clinerules/ (style/preferences) with memory-bank/ (mutable working memory). Memory bank is read at the start of every task — "this is not optional" — and includes projectBrief.md, activeContext.md, progress.md. [docs.cline.bot/customization/cline-rules] This is a different mechanism than conventions; do not conflate them.backstory= argument), not on the filesystem. This means style is per-agent (not per-project) and cannot be edited by non-engineers. Trade-off: more programmatic control, less convenient for teams.--read CONVENTIONS.md pattern)/read, /tokens, /clear@-imports, .claude/rules/ with paths: frontmatter, 200-line guideline, AGENTS.md interop, /init reading of .cursorrules.cursor/rules/ migration).mdc format, frontmatter, alwaysApply, globs.clinerules/ + memory-bank)paths frontmatter for conditional rulesrole + goal + backstory triplet, backstory as primary style lever.cursorrules template gallery/Users/5imp1ex/Desktop/Skill-Workplace/output/aider-sop-skill/SKILL.md §2.2, §3 Phase 1, §6 anti-pattern #7/Users/5imp1ex/Desktop/Skill-Workplace/output/crewai-sop-skill/SKILL.md §2.2 (backstory as style lever)/Users/5imp1ex/Desktop/Skill-Workplace/output/dify-sop-skill/SKILL.md (system-prompt patterns in visual workflows)SOP for writing, loading, and evolving a project-level convention file (CONVENTIONS.md / CLAUDE.md / .cursor/rules / .clinerules / AGENTS.md) so that a coder-agent reliably respects your codebase's st
---name: agentsop-conventions-pinningdescription: SOP for writing, loading, and evolving a project-level convention file (CONVENTIONS.md / CLAUDE.md /…---# skills/agentsop-conventions-pinning/SKILL.mdOverview
SOP for writing, loading, and evolving a project-level convention file (CONVENTIONS.md / CLAUDE.md / .cursor/rules / .clinerules / AGENTS.md) so that a coder-agent reliably respects your codebase's style choices every session. Tool-agnostic; covers the four load mechanics (read-only attachment, ancestor-walk auto-load, glob-scoped rules, agent backstory) and the conflict resolution between pinned conventions and the existing code.
FAQ
Download skills/agentsop-conventions-pinning/SKILL.md from the publisher, or copy the path and open the repository. PlugMCP lists the skill and does not host the file.
The publisher keeps it at https://github.com/agentsope/SkillAlchemy.
Claude, Cursor, Codex, and Grok Build can read a SKILL.md you add from the publisher's repository. Grok Bot installs it when you send the skill's GitHub folder link in a chat.
@| One source of truth, multiple thin pointers |
| Loaded as rule (system-prompt-ish) |
| Loaded into rules section of system prompt |
| Part of agent's persona |
| Personal vs team layer | Team commits CONVENTIONS.md; no per-user layer | CLAUDE.md (team) + CLAUDE.local.md (personal, gitignored) + ~/.claude/CLAUDE.md (user-global) + managed policy | .cursor/rules/ (team) + user rules in settings | .clinerules/ (workspace) + global rules; workspace wins on conflict [docs.cline.bot/customization/cline-rules] | Code-level; no built-in personal layer |
| Hard size budget | 25k-token total-context threshold (whole context, not just rules) [aider.chat/docs/troubleshooting/edit-errors.html] | < 200 lines per CLAUDE.md recommended; full file loaded regardless [code.claude.com/docs/en/memory] | < 500 lines per .mdc rule; always-apply rules trimmed aggressively [cursor.com/docs/rules] | Concatenated total; same context-pressure rules apply | Limited by LLM context; backstory is part of system prompt |
| Conflict precedence | None built-in; later --read wins by recency | managed > user > project > local; later files in walk override earlier | Always-apply > globs-matched > manually attached | workspace > global on conflict [docs.cline.bot/customization/cline-rules] | Per-agent only |
| Cross-tool import | --read AGENTS.md works | @AGENTS.md import syntax [code.claude.com/docs/en/memory] | Must duplicate (or generate from a build step) | Plain markdown, can symlink to AGENTS.md | Read external file in Python at construction time |
| Verifiable load check | /tokens (in-session) | /memory lists all loaded files | Sidebar shows active rules | Sidebar shows loaded rules | Inspect agent object in code |