nen

Skill packs that give an AI coding agent a discipline.

In Hunter x Hunter, every fighter's aura falls into one of six Nen categories, and mastery means knowing which category a problem belongs to. nen maps each category to an engineering discipline and ships each one as an installable agent skill: a stance, a method, hard boundaries, and a worked trace that shows the discipline actually being applied.

nen ships skills only — no runtime, no hooks, no MCP servers; the installer writes nothing but plain-text instruction blocks, at most one small always-on routing block per runtime. Each skill is a single portable SKILL.md that any agent can read: Claude Code, Codex CLI, Cursor, OpenCode, Gemini CLI, Qwen Code, Kimi CLI, Antigravity, Pi, GitHub Copilot, or anything with an AGENTS.md-style instructions file. One skill text, every runtime.

The skills know about each other. Each one's Boundaries section names the sibling disciplines it hands off to — enhancer locks in the benchmark and hands the restructuring to transmuter; specialist decodes the mechanism before conjurer enumerates how it fails. The hand-off graph is enforced by the lint, not left to prose.

発 — Hatsu. In the source material it is the personal expression of Nen: the ability you forge for yourself, sharpened by self-imposed restrictions. Here it is a skill of its own, hatsu (/nen:hatsu) — the meta-discipline of forging new skills: prove a practice actually recurs, write its restrictions before its powers, ship it in the same six-section contract the other six follow, and trial-fire it before calling it real.

円 — En: extending your aura outward to sense everything in range. The field itself is a skill, en (/nen:en) — auto-routing — you stop choosing skills. The agent reads each request's underlying problem shape (never keywords — classifying the work properly is the Nen), engages every ability the work genuinely spans, stacked in dependency order, and hands recurring uncovered needs to hatsu for forging. Every engagement is announced in one auditable line: En: specialist → conjurer — name the mechanism, then close its failure modes.

Turning it on:

• install.sh path (any runtime) — nothing to do: the installer switches the baseline on (see Install — one command).
• Claude Code via the plugin — skills auto-fire on matching requests out of the box; for the standing baseline invoke /nen:en once per session, or run the installer to make it permanent.
• AGENTS.md-family runtimes (Codex, OpenCode, Gemini CLI, Qwen Code, Kimi, Antigravity, ...) — the installed routing block is the En protocol; it is on by default after install.
• Cursor — the always-on nen-en-baseline rule routes every request; without it, the nen-en rule still engages when a request spans disciplines.

Turning it off: say nen off (resume with nen on) — the protocol requires the agent to acknowledge both transitions.

制約と誓約 — Restriction and Pledge: an ability grows stronger through what its user swears not to do, and a broken oath forfeits the power itself. That law ships as a skill, vow (/nen:vow) — pre-commitment engineering. Before the work starts, the agent declares falsifiable vows right under the En engagement line: discipline pledges distilled from the engaged skills' own Done means ("no fix claimed without the failing case red then green") and scope pledges bounding the blast radius ("diff stays inside src/billing/", "no new dependencies"). Every vow is audited before any done claim, with evidence a third party can check; a vow broken without open renegotiation voids the claim.

For an agent the law is literal, not thematic: constraints declared before the first action bind every action after it — the same constraints recalled at review time only grade the damage.

curl -fsSL https://raw.githubusercontent.com/rlaope/nen/main/install.sh | sh

That is the whole setup. The installer detects the runtimes it can wire — Claude Code, Codex, OpenCode, Gemini CLI, and Qwen Code anywhere on the machine, plus Cursor and any existing AGENTS.md when run inside a project — and wires nen into each one it finds: skill bodies land in ~/.nen, a marker-scoped routing block goes on top, and the En baseline is switched on. From the next request onward the agent reads each task's problem shape and engages the right abilities on its own. There is nothing to learn and no command to remember — the only phrase worth knowing is nen off (and nen on to resume). Runtimes the auto-detect cannot see (Kimi, Antigravity, Pi, Copilot) get the same block explicitly: curl -fsSL https://raw.githubusercontent.com/rlaope/nen/main/install.sh | sh -s -- --agent <name>.

Per runtime, "on" means:

• Claude Code — the routing block (En protocol plus the skill table pointing into ~/.nen) is appended to ~/.claude/CLAUDE.md, which loads in every session: the standing baseline. /nen:<skill> slash commands come from the plugin path below — the two compose. Pass --no-baseline to skip the block.
• AGENTS.md family (Codex, OpenCode, Gemini CLI, Qwen Code, Kimi, Antigravity, ...) — the installed routing block is the En protocol.
• Cursor — one always-on baseline rule (nen-en-baseline.mdc, kept deliberately tiny) routes every request; the per-skill rules load on demand.

Everything the installer writes sits between <!-- nen:begin/end --> markers (replacements leave a .nen-bak backup beside the file), under a nen- file prefix, or inside ~/.nen — and re-running it replaces rather than duplicates, so uninstalling is deleting exactly those.

The prompt below teaches your agent the Nen abilities. Whatever you run — Claude Code, Codex, Cursor, OpenCode, Gemini CLI, Qwen Code, Kimi, Antigravity, Pi — paste it in, and the agent learns the skills by installing them the way its own runtime expects:

Teach yourself the nen skill pack from https://github.com/rlaope/nen.

1. Fetch the repo: git clone --depth 1 https://github.com/rlaope/nen.git /tmp/nen
   (or download and extract https://codeload.github.com/rlaope/nen/tar.gz/refs/heads/main).
2. Copy every skill directory from the repo's skills/ folder to
   ~/.nen/skills/<name>/SKILL.md.
3. Wire them into YOUR runtime, whichever you are:
   - Claude Code: its instructions file is ~/.claude/CLAUDE.md — append the
     same marker-scoped "nen skills" section as the AGENTS.md family, listing
     each skill's ~/.nen path. (/nen:<skill> slash commands come from the
     plugin instead: /plugin marketplace add rlaope/nen.)
   - Cursor: for each skill create .cursor/rules/nen-<name>.mdc — frontmatter
     description = the skill's description, alwaysApply: false, body = the
     SKILL.md body without its frontmatter. Copy the repo's
     .cursor/rules/nen-en-baseline.mdc as-is (alwaysApply: true) so En routes
     every request.
   - Any agent with an instructions file (AGENTS.md, GEMINI.md, QWEN.md,
     copilot-instructions.md, ...): append a "nen skills" section listing each
     skill's name, its ~/.nen/skills path, and its description, plus this rule:
     "when a task matches a description, read that SKILL.md first and follow
     its Method before acting."
4. Do not edit the SKILL.md files themselves.
5. Verify: list the skills you installed and where each one landed.

Claude Code plugin — managed updates, namespaced /nen:* commands:

/plugin marketplace add rlaope/nen
/plugin install nen@nen

Already wired in-repo. Cloning the repo gives you working project-level setups out of the box: AGENTS.md for anything that reads it (Codex, OpenCode, Antigravity, Kimi, OpenClaw, ...), .cursor/rules/ for Cursor, .claude-plugin/ for Claude Code. Copy any of them into your own project to vendor nen. These adapters are generated from skills/ by scripts/gen-adapters.py — edit the skills, never the copies.

Raw files. The skills are plain frontmatter-plus-markdown in skills/<name>/SKILL.md — point any Agent Skills-compatible runtime at them directly. The .claude-plugin/ manifests and install.sh are additive packaging that other consumers simply ignore.

Skills auto-activate when your request matches a skill's description, or invoke one explicitly:

/nen:conjurer harden the webhook consumer before launch

On runtimes without slash commands (Codex, OpenCode, Gemini CLI, Qwen Code, and the rest of the AGENTS.md family), the installed routing block auto-matches requests against the descriptions — or just say "use the nen conjurer skill".

A design stance, stated honestly: the descriptions are written deliberately assertive, because skills under-trigger by default — a timid description means the discipline never fires when it should. The cost of the aggressive side is bounded: if a skill fires on the wrong problem, its Boundaries section recognizes that and hands off to the right sibling instead of plowing ahead.

evals/ holds trigger-precision cases for claude plugin eval: routing probes that check the right skill fires on the right request (including deliberate traps between neighboring disciplines) and that nothing fires when no discipline applies. See evals/README.md for how to run them, including the with/without-plugin ablation.

Want to add a skill? Run it through hatsu — it walks the exact contract the lint enforces:

• Frontmatter holds exactly two keys: name (must equal the directory name) and description. The description must contain an explicit "Use when" trigger clause.
• Body has six required H2 sections in this order: Stance, Boundaries, Method, Worked trace, Anti-patterns, Done means. Extra sections are allowed; the required six keep their relative order.
• Worked trace needs at least one fenced code block — a discipline you can't show in a transcript isn't one.
• Boundaries must name each sibling skill it hands off to; the adjacency graph lives in the lint.
• Repository content is English only.

Run the gates before sending a PR:

python3 scripts/lint-skills.py --release
python3 scripts/gen-adapters.py --check

Skill content is MIT-licensed — see LICENSE.

This is an unofficial fan project, not affiliated with or endorsed by the Hunter x Hunter rights holders. The images under assets/ and the embedded GIFs are rights-holder material (and the poster carries third-party logos owned by their respective companies) — none of it is covered by the MIT grant.

Next: an original SVG recreation of the hexagon to replace the rights-holder image.