DEV Community: Roei

We Audited 481 Public CLAUDE.md and AGENTS.md Files: Here Is What Claude Code, Cursor, and Codex Silently Ignore

Roei — Wed, 28 Oct 2026 15:25:55 +0000

Most engineering teams in 2026 use at least two AI coding agents side by side: Claude Code, Cursor, OpenAI Codex CLI, or GitHub Copilot.

To find out what actually happens to repo instruction files in practice, we audited 481 public CLAUDE.md and AGENTS.md files and traced the exact file-loading rules across all 7 major agent harnesses.

You can test your own repo's CLAUDE.md or AGENTS.md in your browser (free, client-side, no login) at https://gethrbr.com/check.

Here are the 5 silent failure modes that break almost every multi-agent repo today:

1. The 7-Agent Instruction Loading Matrix (2026)

File & Location	Claude Code	Codex CLI	Cursor	GitHub Copilot
`CLAUDE.md` (Repo Root)	Loaded at launch	Ignored (unless added to `project_doc_fallback_filenames` in `~/.codex/config.toml`)	Loaded in Agent chat only (Cursor Tab, Inline Edit `Cmd+K`, and Bugbot never see it)	Ignored
`AGENTS.md` (Repo Root)	Ignored the moment any `CLAUDE.md` exists in the folder or above it (unless `CLAUDE.md` starts with `@AGENTS.md`)	Loaded at launch (capped at 32 KiB)	Loaded in Agent chat only (Tab, Inline Edit, and Bugbot never see it)	Loaded at launch
`AGENTS.md` (Subfolder)	Ignored	Ignored when Codex starts at the repo root (Codex walks root to `cwd` and stops there)	Loaded when Agent chat works in that folder	Ignored (root only)
*`.cursor/rules/.mdc`**	Ignored	Ignored	Loaded across Tab, Inline Edit, and Agent chat (when `alwaysApply: true`)	Ignored

2. Codex CLI Silently Cuts `AGENTS.md` Mid-Sentence at 32 KiB (`32,768 bytes`)

Codex enforces a hard 32 KiB budget (project_doc_max_bytes) across the combined AGENTS.md chain. The moment your file crosses byte 32,768, Codex truncates the tail mid-sentence with zero warning in the terminal. Any git, testing, or security rule at the bottom of a long AGENTS.md disappears silently.

3. Prose Pointers (`See AGENTS.md`) Do Not Auto-Load in Claude Code

If your CLAUDE.md says Read [AGENTS.md](./AGENTS.md) before starting, Claude Code does not load AGENTS.md at session start. It only sees AGENTS.md if the model decides to spend a tool call opening it. To make Claude Code inline AGENTS.md automatically at startup, line 1 of CLAUDE.md must be @AGENTS.md.

4. `@path/to/file.md` Imports Break Outside Claude Code

While Claude Code expands @path/to/doc.md imports at startup (up to 4 hops deep, burning the full token count on every turn), Codex CLI, Cursor, and Copilot treat @path/... as literal plain text and never open the referenced file.

5. 60% of Repos Ask in Prose for Guardrails That Require a `PreToolUse` Hook

Across the 481 files we studied, 60% used words like NEVER, MUST NOT, or CRITICAL in prose to ban dangerous commands (rm -rf, git push --force, git reset --hard, --no-verify, or reading .env). Because CLAUDE.md and AGENTS.md are injected as user-message context, compliance degrades as the context window fills. Hard blocks belong in .claude/settings.json (permissions.deny or a PreToolUse hook exiting 2).

Check Your File (and Sync Rules Automatically)

Free Browser Linter: Paste your CLAUDE.md, AGENTS.md, or .cursor/rules/*.mdc into https://gethrbr.com/check to see which agents load it, where it hits byte/line limits, and which prose lines need to become hooks.
Harbor (Shared Memory & Rule Routing for Coding Agents): We built Harbor (https://gethrbr.com/#start) so teams using Claude Code, Cursor, Codex, and Copilot don't have to maintain four drifting markdown files or load 10,000 tokens of static rules on every turn. Join the early access beta at https://gethrbr.com/#start.

Claude Code skills: how to write SKILL.md and when to use one

Roei — Fri, 16 Oct 2026 13:30:00 +0000

A Claude Code skill is a folder with a SKILL.md file: a name, a description, and instructions. Claude sees every skill's description on every turn and loads the full instructions only when a task matches, or when you type /skill-name. That makes a skill the place for knowledge you need sometimes, not always.

Everything below was checked against the Claude Code skills docs on 2026-10-05 (Claude Code 2.1.289), with the other tools checked against their own docs the same day. Skills have changed more than any other part of Claude Code this year: custom slash commands were folded into them, other agents started reading the same folders, and several fields are newer than most tutorials.

What is a skill in Claude Code?

A skill bundles instructions, and optionally supporting files and tool permissions, into something Claude can pick up on demand. It is the answer to a question every CLAUDE.md eventually raises: where does knowledge go that matters for one kind of task and is noise for the rest? CLAUDE.md is read at the start of every session. A skill costs one line of description until it is needed.

Custom slash commands are now skills. A file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md both create /deploy and behave the same. Old command files keep working; new work should be skills, because only skills can carry supporting files.

How do you create a skill?

Make a folder under .claude/skills/ in the repo (or ~/.claude/skills/ for yourself) and put a SKILL.md in it. The frontmatter must start on line 1.

.claude/skills/webhook-change/SKILL.md

---
name: webhook-change
description: "Use when adding or changing a payment webhook handler, its retries or its idempotency key."
paths: src/payments/**
---
1. Handlers are idempotent. Key on the provider's event id.
2. Retries go through src/lib/retry.ts. Five attempts, then dead-letter.
   Why: docs/decisions/0012-webhook-retries.md
3. Add a replay test in tests/webhooks/ before opening the PR.
   See checklist.md for the full review checklist.

The folder can hold more files. SKILL.md links to them, and Claude reads them only when the task needs them; scripts in the folder are run, not read. Anthropic's guidance is to keep SKILL.md under 500 lines and move detail into those files.

SKILL.md frontmatter fields that matter

Every field is optional. These are the ones that change behaviour:

Field	What it does
`description`	What the skill does and when to use it. Claude matches your request against it to decide whether to load the skill. Combined with when_to_use, capped at 1,536 characters in the listing.
`when_to_use`	Extra trigger context and example requests, appended to the description.
`paths`	Globs that restrict when the skill auto-loads, same format as path-scoped rules.
`disable-model-invocation`	true means only you can run it, with /name. Use it for anything with side effects, like a deploy.
`user-invocable`	false hides it from the / menu. Only Claude can load it.
`allowed-tools`	Tools pre-approved for the turn that invokes the skill. The grant clears on your next message.
`context: fork`	Runs the skill in a subagent with its own context, in the background by default. Pair with agent to pick the subagent type.
`model`	Overrides the session model while the skill runs.

How does Claude decide to use a skill?

Progressive disclosure, in three steps. Every skill's name and description sit in context on every turn, so Claude knows what exists. When your request matches a description, or you type the command, the rendered SKILL.md enters the conversation as a message and stays there for the rest of the session. Supporting files load only if the instructions send Claude to them.

Two consequences follow. The description is the whole trigger, so write it as the task it serves ("Use when adding or changing a payment webhook handler"), not as a title ("Webhooks"). And skills are not free: fifty descriptions are fifty lines in every prompt, whether or not any of them fire.

Where do skills live, and which one wins?

Location	Path	Who gets it
Enterprise	managed settings directory	Everyone on machines with the org deployment. Highest precedence
Personal	`~/.claude/skills/<name>/`	You, in every project on this machine
Project	`.claude/skills/<name>/`	Everyone who clones the repo
Nested	`<subdir>/.claude/skills/`	Sessions working in that part of a monorepo
Plugin	`<plugin>/skills/<name>/`	Anyone with the plugin enabled, as /plugin-name:skill-name

When two share a name, enterprise beats personal beats project. Plugin skills are namespaced and never shadowed. To share a skill with the team, commit it to .claude/skills/; to share it across repos, ship it in a plugin. Which of the .claude/ files to commit is covered in should you commit CLAUDE.md.

Do Cursor, Copilot and Codex read Claude Code skills?

Cursor and Copilot in VS Code do. Codex does not. Skills follow the Agent Skills open standard, so the SKILL.md format is shared, but each tool looks in its own folders.

Tool	Project skill folders it reads
Claude Code	`.claude/skills/`, plus plugins. Not `.agents/skills/`
Cursor	`.agents/skills/` and `.cursor/skills/`, and "for compatibility" `.claude/skills/` and `.codex/skills/`
Copilot in VS Code	`.github/skills/`, `.claude/skills/`, `.agents/skills/`
OpenAI Codex	`.agents/skills/` in every directory from the working directory up to the repo root

Sources: Cursor skills, VS Code agent skills, Codex skills. So a skill in .claude/skills/ reaches three of the four. To reach Codex too, keep each skill in .agents/skills/ and symlink its folder into .claude/skills/: both Claude Code and Codex document that they follow a symlinked skill folder. The Codex side is in Codex skills. Cursor and Copilot read both folders, so check that the skill is not listed twice. Claude-only fields such as context: fork are not part of the standard, so do not count on them in the other tools; the Claude Code docs list which fields are.

Skills can now come from a server as well. The MCP Skills extension (SEP-2640) is Final, so an MCP server can list and serve SKILL.md folders next to its tools. The MCP site says SDK and host support is still being implemented, so check its client matrix before you rely on it.

How do you test a skill, and find the ones nobody uses?

Three built-in commands, all newer than most guides to skills:

Command	Since	What it tells you
`/skill-doctor`	2.1.261	Which loaded skills go unused and what each costs in context, so you can turn some off. The report opens in the /plugin Stats tab.
`claude plugin eval`	2.1.269	Runs a plugin's eval suite in isolated sessions with and without the plugin, scores it, and exits non-zero below a threshold, so CI can gate on it. A tool_used: Skill grader measures how often a skill triggers.
`/doctor prompt-audit`	2.1.283	Audits CLAUDE.md files, skills, agents and commands for prompting patterns written for older models, and leads with stale paths and contradicting files.

claude plugin eval covers skills that ship in a plugin. For a skill in .claude/skills/, the docs point to the skill-creator plugin's own eval loop instead. The two formats are not interchangeable.

Why isn't my Claude Code skill triggering?

From the docs, in the order worth checking:

Cause	Fix
disable-model-invocation: true	Only /name works. Remove it if Claude should pick the skill itself.
The description does not match the request	Rewrite it as the task, put the key use case first, add when_to_use examples.
A paths glob matches no file in play	Check the glob against the files Claude is working on.
Hidden by skillOverrides or a permission rule	Run /skills to see what is visible, and /permissions for Skill(...) rules.
Frontmatter failed to parse	The skill still loads, with no fields set. Validate the YAML and check the log.

The deeper problem is the one no field fixes. In Vercel's Next.js evals the skill was never invoked in 56% of cases, and skills left to their default behaviour passed 53%, the same as no docs at all. A compressed docs index in AGENTS.md passed 100% (Vercel, January 2026). A skill is a bet that the model will notice it needs the skill. For anything that must happen every time, use a hook; the trade-offs are in the hooks guide and CLAUDE.md vs skills vs hooks.

Skills vs CLAUDE.md: what goes where?

Anthropic's own best practices draw the line: CLAUDE.md is for what applies broadly, and "for domain knowledge or workflows that are only relevant sometimes, use skills instead." A good test is whether a new engineer would need the line on their first day for every task. If yes, CLAUDE.md. If only when touching payments, a skill with a paths glob. If it is a procedure you run on purpose, a skill with disable-model-invocation.

Where Harbor fits

Skills pile up the way CLAUDE.md lines do. Each one is cheap to add and nobody removes them, and every description is in every prompt. harbor context, the one Harbor command that needs no account and no network, reads the machine and prints the always-on budget per turn: the skills index, skill files that are not indexed, agent definitions, MCP tools and injected context, and who put each there. It also flags skill files with no description, which are the ones Claude cannot choose on its own.

npm install -g harborloop
harbor context

A skill is still a file somebody wrote. The decisions inside it were usually made in a pull request review or a Slack thread first, and when one of them changes, every copy of every skill that repeats it has to change by hand. Harbor keeps the decision instead of the copy. It reads those places, a person approves what becomes a fact (or a policy you set approves the routine ones), and every agent is served the facts that apply to the task. It counts, per fact, how often it was served against how often an answer cited it; a cite is evidence, not proof. See served vs cited.

Start with what you already carry. Run harbor context first; the CLI reference explains each line, and the quickstart takes about ten minutes.

Questions

What is a skill in Claude Code?

A skill is a folder with a SKILL.md file holding a name, a description and instructions. Claude sees every description on every turn and loads the full instructions only when a task matches or when you type /skill-name.

Where do Claude Code skills go?

Project skills go in .claude/skills/<name>/SKILL.md and are shared through git. Personal skills go in ~/.claude/skills/. Plugins can also ship skills, which run as /plugin-name:skill-name.

Do Cursor and Codex read Claude Code skills?

Cursor does: it loads .claude/skills for compatibility, and Copilot in VS Code reads it too. Codex does not; it reads .agents/skills. Keep the folder in .agents/skills and symlink it into .claude/skills to reach all four, since Claude Code and Codex both follow symlinked skill folders.

Why is my Claude Code skill not triggering?

Check whether disable-model-invocation is set, whether the description matches the task, whether a paths glob matches the files in play, and whether skillOverrides or a permission rule hides it. Run /skills to see what Claude can see.

Should I use a skill or CLAUDE.md?

Use CLAUDE.md for what applies to every task and a skill for knowledge or workflows that matter only sometimes. For anything that must happen every time, use a hook, because a skill depends on the model choosing to load it.

Disclosure: I work on Harbor, which published this note.

Claude Code hooks: a practical guide with examples

Roei — Thu, 08 Oct 2026 12:00:00 +0000

Claude Code hooks are commands that run at fixed points in a session: before a tool runs, after a file is edited, when a prompt is submitted, when Claude stops. Unlike a line in CLAUDE.md, a hook is not advice. It always runs, and a PreToolUse hook can block the action outright by exiting with code 2.

Checked against the hooks guide and reference on 2026-10-05 (Claude Code 2.1.289). The event list has grown to 33; the handful below are the ones most teams use. Three things changed in the fortnight before that date: sessions now start in auto mode, mods arrived and can overrule a hook, and Cursor runs Claude Code's hooks too. Each has a section below.

What are Claude Code hooks?

Anthropic's best practices put it in one line: unlike CLAUDE.md instructions, which are advisory, hooks are deterministic and guarantee the action happens. A rule asks the model. A hook does not ask anyone. That is why the answer to "Claude keeps ignoring my rule" is so often "make it a hook", and why the causes behind the ignoring, covered in why Claude ignores CLAUDE.md, do not apply to one.

Which hook events should you know?

Event	Fires	Typical use
`PreToolUse`	Before a tool call runs. Can block it	Refuse dangerous commands, protect files
`PostToolUse`	After a tool call succeeds	Format or lint the file that was just edited
`UserPromptSubmit`	When you submit a prompt, before Claude sees it	Add context to the prompt, such as branch state
`SessionStart`	When a session begins, resumes, clears or compacts	Load context the session should start with
`Stop`	When Claude finishes responding	Run the tests and refuse to stop until they pass
`PreCompact` / `PostCompact`	Around context compaction	Re-inject what must survive a summary
`SessionEnd`	When the session terminates	Write logs, clean up
`Notification`	When Claude Code sends a notification	Desktop alert when Claude is waiting for you

How do you configure a hook?

Hooks live in a settings file under a hooks key. Each event takes matchers (a tool name or a regex such as Edit|Write) and the commands to run. This formats every file Claude edits:

// .claude/settings.json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ]
  }
}

Where the block goes decides who it applies to:

Location	Scope	Shared
`~/.claude/settings.json`	All your projects	No
`.claude/settings.json`	This project	Yes, commit it
`.claude/settings.local.json`	This project	No, gitignored
Managed policy settings	The whole organization	Admin controlled
Plugin, skill or subagent	While that is enabled or running	Yes, ships with it

Run /hooks inside Claude Code to see everything configured. Since 2.1.286 it opens on one list grouped by event, each hook labelled with where it comes from; select one to see the full command and the file that defines it. The menu is read-only, so to change a hook you edit that file.

How do you block a command with a PreToolUse hook?

The hook receives the tool call as JSON on stdin. Exit 0 lets it through. Exit 2 blocks it, and what you write to stderr goes back to Claude as the reason, so it can change course. This is the pattern from Anthropic's guide, protecting files:

#!/bin/bash
# .claude/hooks/protect-files.sh
INPUT=$(cat)
FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')

for pattern in ".env" "package-lock.json" ".git/"; do
  if [[ "$FILE_PATH" == *"$pattern"* ]]; then
    echo "Blocked: $FILE_PATH matches protected pattern '$pattern'" >&2
    exit 2
  fi
done
exit 0

Register it on PreToolUse with the matcher Edit|Write, make it executable, and ask Claude to edit .env to test it. For structured control, exit 0 and print JSON with permissionDecision set to deny, ask or allow. When several hooks answer, the most restrictive wins.

A hook and your permission rules stack. A hook that exits 2 blocks the call even when an allow rule would let it through, and a deny rule still blocks a call the hook allowed. Since 2.1.288, if Claude Code cannot match a PreToolUse hook or cannot serialize the tool's input for it, the call is blocked rather than waved through. That fix is narrow: a guard that exits 1, or times out, still lets the call run, so a guard should exit 2 on anything it does not understand.

Do hooks still run in auto mode?

Yes, and they matter more there. Since 2.1.284, published 2026-09-28, interactive sessions start in auto mode when no permission mode is configured, on every plan and provider. Most tool calls are then approved by a classifier instead of by you. PreToolUse hooks still run before that: a hook that denies, or exits 2, blocks the call, and a hook that returns ask forces a prompt the classifier cannot approve on its own.

Auto mode adds one event of its own. PermissionDenied fires when the classifier refuses a call, which is the place to log what it stopped. And a PostToolUse hook can return classifierContext, a note the classifier reads before it judges the next action, since it never sees tool results themselves. Details are in the permission modes docs.

Mods vs hooks: can a mod overrule a hook?

Yes. Mods arrived in 2.1.287 on 2026-10-01. A mod is a plugin whose handlers are JavaScript or TypeScript functions running inside Claude Code rather than shell commands, so it can draw panes, add commands and step into a tool call. The mods docs now call the hooks on this page "settings hooks" to tell them apart.

The part that matters for a guard: per the permissions docs, a mod that handles tool.check answers after your rules and your PreToolUse hooks, and its answer can replace theirs.

Your control	Can an installed mod approve past it?
A `PreToolUse` hook that blocks	Yes, unless the hook is in managed settings
An ask rule	Yes
The auto mode classifier	Yes. A call the mod approves is not checked
A deny rule	Not on a machine with managed settings or a Team or Enterprise sign-in, by default. Anywhere else, yes

So a guard the whole team relies on belongs in managed settings, and a mod deserves the review you would give any dependency that runs with your permissions. If a shell script does the job, a settings hook is still the simpler choice.

Do Codex and Cursor have hooks too?

Both do, and both borrowed Claude Code's shape, so one guard script can serve all three.

	Cursor	OpenAI Codex
Where	`.cursor/hooks.json`, `~/.cursor/hooks.json`, and enterprise paths	`.codex/hooks.json` or `[hooks]` in `.codex/config.toml`, and the same under `~/.codex`
Reads Claude Code's hooks	Yes, by default, from `.claude/settings.json`, `.claude/settings.local.json` and `~/.claude/settings.json`	No
Blocking	Exit 2, or Claude Code's `permissionDecision` JSON. Any other non-zero exit lets the action through	Exit 2, or `permissionDecision: "deny"`. Matching hooks start at once, so one cannot stop another
Before a hook runs	Nothing extra	You review and trust each hook in /hooks; a changed hook is skipped until trusted again. Project hooks load only in trusted projects

Cursor maps the names for you: Bash becomes Shell, Edit becomes Write, and UserPromptSubmit becomes beforeSubmitPrompt. It does not map Notification or PermissionRequest. Codex calls a file edit apply_patch, so an Edit|Write matcher needs that name added there. Because Cursor fails open on a crash, write a guard to exit 2 when it cannot parse its own input. Sources: Cursor third-party hooks, Codex hooks.

Which commands are worth blocking?

The ones your agents actually run, not the ones that sound scariest. A guard written from imagination can sit for months without matching anything. The costly commands are often ordinary: rm -r on a source directory, git checkout -- <paths> or git reset --hard throwing away uncommitted work. Read your agents' command history before you decide which guard comes first.

Start a new guard in log-only mode for a week, count what it would have blocked, then switch it to blocking. A guard that fires on legitimate work gets disabled by the second person it annoys.

Can a hook add context for Claude?

Yes. On UserPromptSubmit, return JSON with hookSpecificOutput.additionalContext and the text is added to Claude's context for that prompt. The guide's example adds the branch and a deploy freeze. Put the field inside hookSpecificOutput; at the top level it is silently ignored. SessionStart with the compact matcher is the documented way to re-inject what must survive a compaction.

This is the part of hooks that is easiest to overdo. Every line a hook injects is in the prompt, with the same cost and the same context rot as a line in CLAUDE.md. Inject what applies to this prompt, not everything that might.

How do you debug a hook that is not running?

Press Ctrl+O for the transcript view. A successful hook shows nothing; a block shows its reason; a failing hook shows a hook error notice. For the full picture, start with claude --debug-file /tmp/claude.log and tail the log, or run /debug mid-session. The usual culprits: the script is not executable, jq is missing, the matcher does not match the tool name, or a project setting set disableAllHooks.

Where Harbor fits

Harbor is itself delivered through hooks. harbor init installs hooks in Claude Code, Codex and Cursor, and they serve each session the team's approved facts that apply to the repo and the task, so the agent starts with the decision from last month's review instead of rediscovering it. What a session learns is written back through review, not straight into the next prompt.

Harbor's guardrails run on these same hooks, in Claude Code, Codex and Cursor, and since 2026-10-04 they cover MCP tool calls as well as shell commands, so the GitHub MCP server's merge_pull_request can be stopped the way gh pr merge is. The ready-made ones are off, and record nothing, until your team turns one on. A guardrail you write starts in observe, the log-only week above, and one you add from the library blocks from the start. Either can be switched, and Claude Code tells each developer when one is turned on. harbor off pauses the whole thing for one repo, and harbor doctor checks that the hooks are installed and reaching the agents you think they reach.

See what is installed where. Agents and MCP lists every hook event Harbor uses per agent, and the quickstart takes about ten minutes.

Questions

What are hooks in Claude Code?

Hooks are commands Claude Code runs at fixed points in a session, such as before a tool call, after a file edit, or when Claude stops. Unlike CLAUDE.md instructions, they always run.

How do I block a command in Claude Code?

Add a PreToolUse hook with a matcher such as Bash or Edit|Write. The script reads the tool call as JSON on stdin and exits with code 2 to block it; what it writes to stderr is passed back to Claude as the reason.

Where are Claude Code hooks configured?

In a settings file under a hooks key: ~/.claude/settings.json for all your projects, .claude/settings.json to share with the team, .claude/settings.local.json for yourself, or managed settings for the organization. Run /hooks to see them all.

Do hooks run in Claude Code auto mode?

Yes. PreToolUse hooks run before the auto mode classifier: a hook that denies or exits 2 blocks the call, and one that returns ask forces a prompt the classifier cannot approve on its own. Since 2.1.284, sessions start in auto mode when no permission mode is configured.

Does Cursor run Claude Code hooks?

Yes, by default. Cursor loads hooks from .claude/settings.json, .claude/settings.local.json and ~/.claude/settings.json, maps Bash to Shell and Edit to Write, and honours exit code 2 and Claude Code's permissionDecision JSON. Codex does not read them; it uses .codex/hooks.json.

Disclosure: I work on Harbor, which published this note.

DEV Community: Roei

We Audited 481 Public CLAUDE.md and AGENTS.md Files: Here Is What Claude Code, Cursor, and Codex Silently Ignore

1. The 7-Agent Instruction Loading Matrix (2026)

2. Codex CLI Silently Cuts AGENTS.md Mid-Sentence at 32 KiB (32,768 bytes)

3. Prose Pointers (See AGENTS.md) Do Not Auto-Load in Claude Code

4. @path/to/file.md Imports Break Outside Claude Code

5. 60% of Repos Ask in Prose for Guardrails That Require a PreToolUse Hook

Check Your File (and Sync Rules Automatically)

Claude Code skills: how to write SKILL.md and when to use one

What is a skill in Claude Code?

How do you create a skill?

SKILL.md frontmatter fields that matter

How does Claude decide to use a skill?

Where do skills live, and which one wins?

Do Cursor, Copilot and Codex read Claude Code skills?

How do you test a skill, and find the ones nobody uses?

Why isn't my Claude Code skill triggering?

Skills vs CLAUDE.md: what goes where?

Where Harbor fits

Questions

What is a skill in Claude Code?

Where do Claude Code skills go?

Do Cursor and Codex read Claude Code skills?

Why is my Claude Code skill not triggering?

Should I use a skill or CLAUDE.md?

Claude Code hooks: a practical guide with examples

What are Claude Code hooks?

Which hook events should you know?

How do you configure a hook?

How do you block a command with a PreToolUse hook?

Do hooks still run in auto mode?

Mods vs hooks: can a mod overrule a hook?

Do Codex and Cursor have hooks too?

Which commands are worth blocking?

Can a hook add context for Claude?

How do you debug a hook that is not running?

Where Harbor fits

Questions

What are hooks in Claude Code?

How do I block a command in Claude Code?

Where are Claude Code hooks configured?

Do hooks run in Claude Code auto mode?

Does Cursor run Claude Code hooks?

2. Codex CLI Silently Cuts `AGENTS.md` Mid-Sentence at 32 KiB (`32,768 bytes`)

3. Prose Pointers (`See AGENTS.md`) Do Not Auto-Load in Claude Code

4. `@path/to/file.md` Imports Break Outside Claude Code

5. 60% of Repos Ask in Prose for Guardrails That Require a `PreToolUse` Hook