artofwar-skills 🐲 — winning without fighting

"To subdue the enemy without fighting is the acme of skill." — Sun Tzu, III.2

The Art of War (dragon edition) with a puerh tea setting

*Sun Tzu's The Art of War* (Lionel Giles 1910 translation, public domain) processed into atomic strategy recipes* — a decision lens an AI agent consults during a session* to quote the applicable principle and translate it into the concrete move. Project-agnostic: it applies to any endeavour with wins and losses.

47 principles, one per file, with frontmatter metadata + index sheets — the "fieldcraft" skills pattern (one technique per recipe, a triggers reverse-index for recall).

What's in it

• `recipes/` — 47 atomic principles. Each file: frontmatter (`id, title, chapter, verses, type,

applies_to, quote, source, see_also) + sections ## Principle · ## Apply · ## Trigger · ## Quote ·

See also`.

• `_index/` — generated indexes:
• triggers.md — situation → principle reverse index. *This is the entry

point during a session.*

• by-chapter.md — the 13 chapters in book order.
• by-type.md — by strategic type (positioning, timing, intelligence, leadership…).
• sources/ — the public-domain source text. _gen.py — regenerates everything.

The loop (how an agent uses it)

At a strategic decision — a call to make, a build/no-build, a sequencing or scope/conflict choice, a negotiation, a risk:

1. Match the situation in _index/triggers.md.
2. Open the matched recipe(s) in recipes/.
3. Quote the principle in chat as 🐲 Sun Tzu — <principle> (with the Giles line).
4. Translate it into the concrete next move — only where it genuinely applies. Never

force-fit or decorate.

Hook it into any agent / any project (so it's used during the session)

The mechanism is the same everywhere: put a short instruction block where your agent reads its standing rules, pointing it at this repo's path. Three scopes:

1. Claude Code — one project (recommended start)

Add the block below to that project's `CLAUDE.md` (at the repo root or working dir). Claude loads it automatically each session for that project.

2. Claude Code — every project (global)

Add the block to `~/.claude/CLAUDE.md` (your global instructions, loaded every session). Now the lens applies across all your work.

3. Any other agent (Cursor, Windsurf, a custom harness, an API system prompt)

Paste the block into wherever that tool keeps project rules / system prompt / memory (.cursorrules, a "rules" file, the system prompt, an MCP/skills entry). Same effect.

The portable hook block (copy-paste, edit the path if needed)

## Strategy lens — The Art of War (`~/artofwar-skills/`)
Apply Sun Tzu's *Art of War* as a decision lens. At any strategic moment — a call/decision, a
build-or-don't, a sequencing/scope/conflict choice, a negotiation, a risk — consult `~/artofwar-skills`:
1. Match the situation in `~/artofwar-skills/_index/triggers.md`.
2. Open the matched recipe in `~/artofwar-skills/recipes/`.
3. Quote the principle in chat as `🐲 Sun Tzu — <principle>` (with the Giles line).
4. Translate it into the concrete move. ONLY where it genuinely fits — never force-fit or decorate.
Don't quote it on trivial/mechanical steps; reserve it for real strategic forks.

Make the path portable. The block above assumes the repo at ~/artofwar-skills. To use it on another machine or project, clone it and point the path at wherever it lives:

git clone https://github.com/xAlisher/artofwar-skills ~/artofwar-skills
# then edit the path in the hook block if you cloned elsewhere

Persistence & hot-loading (so it's auto-used every session)

Persistence = put the hook in `CLAUDE.md`. Claude Code auto-loads CLAUDE.md (project) and ~/.claude/CLAUDE.md (global) into context at the start of every session — so the instruction is always present, with no per-session step. That's the persistent hook. (Other agents: their rules/system-prompt file is the equivalent always-loaded slot.)

Lazy vs hot-loaded — two modes:

• Lazy (default, recommended). The hook tells the agent to *read _index/triggers.md when a

decision arises. Recipes load on demand* → near-zero context cost; the lens is there but only pulled when needed.

• Hot-loaded at session start. If you want the index always present in context, add one line to

the hook: At session start, read ~/artofwar-skills/_index/triggers.md. — or inline the (small) triggers index directly into `CLAUDE.md` so it's literally in context every session (zero file read, but spends some token budget each session).

Which to choose: lazy for almost everything (cheap, fires only at forks). Hot-load only if you want the agent primed with the full trigger map from the first message. The repo is small enough that inlining triggers.md into a global CLAUDE.md is viable if you want it omnipresent.

Verify the hook is live

Start a session in the hooked project and ask: "what does the Art of War lens say about this decision?" If the agent reads _index/triggers.md and replies with a 🐲 Sun Tzu — … quote + move, it's wired. (Some agents only read rules files at session start — restart the session after adding the hook.)

Keep it from being noise

The hook says only where it genuinely fits. Good practice: apply at forks (sequencing, timing, build/no-build, conflict, negotiation, scope) — not on routine edits. The applies_to tags and triggers.md exist precisely to gate when it fires.

Extend / regenerate

Edit the R = [...] list in _gen.py (id, title, chapter, verses, type, applies_to, quote, principle, apply, trigger, see_also), then:

python3 _gen.py        # rewrites recipes/ + _index/ (indexes auto-built from the data)

Adding a recipe to R is all it takes — the three index sheets regenerate from it.

License / source

The source text is public domain (Sun Tzu, The Art of War, trans. Lionel Giles, 1910). The original recipe distillations, indexes, and notes are released under [CC0 1.0](LICENSE) (public domain dedication) — use, adapt, and redistribute freely, no attribution required.