arsenal

arsenal

Mirko Bozzetto's curated skills for AI coding agents: one entry point, specialized skills underneath.

Portable skills for Claude Code, Codex, OMP, and Pi, built from one shared workflow. Install Arsenal once, then add only the specialist skills you need.

Each runtime has its own adapter under plugins/arsenal/skills/arsenal/references/adapters/, so agent discovery, model resolution and resume syntax stay runtime-specific while the workflow stays shared. Pi uses its builtin scout, oracle and reviewer agents and needs no agent installation.

---

What’s in the arsenal

Plugin	What it does	You type
arsenal	One entry point: clarify, select and apply the skills the task needs.	/arsenal add OAuth login
brief	The what & why. Interview → product spec + task list.	/brief add OAuth login
propose	The how. Alternatives, tradeoffs, risks, plan. One page or a few, hard ceilings.	/propose OAuth token storage
ship	The build. Implements a clear request or approved spec and reports verification.	/ship docs/brief/oauth-login/
issue	The 1am bug, logged so you can pick it up cold.	/issue log this bug
next	Start of a session: what was left, numbered, and “what do we continue?”.	/next
trace	End of a session: save where you stand, then /clear instead of compacting.	/trace
nap	Claude Code: the session saves, clears itself and resumes alone, no gesture.	/nap
slim	Claude Code: lighter rules and CLAUDE.md, every rule kept, proved by a script.	/slim
review	Deep code review: interview, read-only readers per angle, verified findings routed to the right skill.	/review
websearch	Evidence-backed web search via Exa.	/websearch <question>

---

One entry point

Use /arsenal in Claude Code, $arsenal in Codex, or /arsenal-mode in OMP and Pi.

• Without a description: a short adaptive form clarifies the outcome and whether you want advice, a document or implementation.
• With a description: Arsenal reads the available context first and asks only route-changing questions.
• It selects an installed skill, reads its complete instructions and applies them.
• After each result it reassesses what remains, within your authorization.

What is missing or requested	Route
Product decisions need a specification	brief
A consequential technical choice needs resolution	propose
Implementation is clear and authorized	ship
External evidence	websearch
GitHub or Linear issue memory	issue
Start a session or find unfinished work	next
End a session and keep the thread	trace
Clear the session and resume it alone	nap
Slim the instructions loaded in every session	slim
Analyze code in depth	review
A real phased roadmap	Arsenal’s optional roadmap branch

There is no complexity score and no mandatory brief → propose → ship sequence. A bug does not automatically create an issue; a small clear change goes straight to ship. A proposal still needs explicit acceptance. Advice-only requests never become implementation.

The specialist skills remain directly usable. Their procedures are not copied into Arsenal. Install each needed plugin separately: Arsenal does not bundle or silently install its dependencies. Missing skills are reported, with installation or an explicitly labeled fallback offered.

Work stays solo unless you approve delegation. No mandatory roadmap, HTML or new state file.

The loop closes by itself: brief records the Git base and work branch, names what the work owns and must not touch, and offers one issue per task; an accepted propose records the same two fields; ship branches from origin/<base>, commits and pushes each closed unit, shows you where to see the result, ends with the next command, proposes the PR when the spec is shipped and, after the merge, closes the issues and realigns base. Every authoring skill verifies an external fact (version, API, price, date, behaviour of a tool) through websearch before stating it. Each of these steps runs on a detected capability (git, gh, web search, a browser) and prints the manual equivalent when it is missing, so an older brief or a host without gh works unchanged.

Two specs at once

/ship -w <spec> gives that spec its own worktree under .worktrees/<slug>, branched from origin/<base> the spec recorded, carries in the gitignored files listed in .worktreeinclude, and hands the run to a session opened there, so you can start the next spec straight away. One spec, one branch, one worktree, one pull request: never one per task. The main checkout keeps owning the running services, and on merge ship removes the worktree and the branch through Git, which refuses while anything is unmerged. Without -w nothing changes, and Arsenal only offers it when another spec is already running in the repository.

Optional continuous Arsenal mode for OMP and Pi

Install dependencies in plugins/ship/runtime with Bun. For OMP, add the absolute extension.ts path to its extensions configuration and restart OMP. For Pi 0.84+, install the local package with pi install ./plugins/ship/runtime; it loads pi-extension.ts.

Use /arsenal-mode on to route every request through the Arsenal skill and /arsenal-mode off to return to native behavior. /arsenal-mode status shows the current state. The mode never changes the active tools, filesystem scope, shell access, network access, or native approval policy. Specialist skills remain directly available through each harness’s native skill commands. OMP reserves /trace for its own dashboard; use /skill:trace for Arsenal’s ledger.

---

The lineage

Plain names, old discipline. propose is the RFC tradition (RFC 1, 1969, Rust, Oxide) plus Nygard’s one-page decision records. brief is the PRD tradition (Cagan) sized by the short-doc school (Google, Shape Up, Linear).

The classic failure is letting the what and the how bleed together. One checkable artifact per question - that’s the whole point.

---

Why I built this

brief pins the what and why. propose settles the how. ship builds. The gates gave me a precision I never had; and when I just want to move, ship takes a one-line prompt. Discipline when the stakes call for it, out of the way when they don’t.

Mirko

---

Quick install

Claude Code

# Inside Claude Code:
/plugin marketplace add mirkobozzetto/arsenal

# Install the whole pipeline:
/plugin install arsenal@arsenal
/plugin install brief@arsenal
/plugin install propose@arsenal
/plugin install ship@arsenal
/plugin install issue@arsenal
/plugin install next@arsenal
/plugin install trace@arsenal
/plugin install nap@arsenal
/plugin install slim@arsenal
/plugin install review@arsenal
/plugin install websearch@arsenal

# ...or just one:
/plugin install ship@arsenal

Then use the entry point or a specialist directly:

/arsenal
/arsenal implement the agreed OAuth login
/arsenal compare token storage approaches, do not implement
/arsenal create a phased roadmap for a meeting-notes app
/brief add OAuth login
/propose OAuth token storage
/ship docs/brief/oauth-login/
/next

Per-plugin setup, flags, and dependencies live in each plugin’s README.

Pi

Install the complete Arsenal package from npm:

pi install npm:arsenal-agent-skills

Or pin a GitHub release:

pi install git:github.com/mirkobozzetto/[email protected]

Start a fresh Pi session, then run /arsenal-mode on. The package also installs every Arsenal skill, available through Pi’s native /skill:<name> commands. Use /arsenal-mode off for native Pi behavior.

OMP

Install from the marketplace:

omp plugin marketplace add mirkobozzetto/arsenal
omp plugin install arsenal@arsenal
omp plugin install ship@arsenal
# ...and any other plugin: brief, propose, issue, next, trace, review, websearch

OMP: local development

To use the current checkout without stale marketplace copies, run this from the repository root after reviewing any existing links in the destination:

mkdir -p "$HOME/.omp/agent/skills"
for skill in arsenal brief propose ship issue next trace review websearch; do
  ln -sfn "$PWD/plugins/$skill/skills/$skill" "$HOME/.omp/agent/skills/$skill"
done

Start a new OMP session. /skill:arsenal loads the native skill; /arsenal uses the optional controller when the extension above is configured. The native ask tool provides the clarification form in interactive sessions. Other skills follow the same /skill:<name> syntax, including /skill:trace. Do not force-reinstall a marketplace plugin whose recorded install path is your source checkout: OMP may remove that path while replacing the installation.

Codex

# Add the repository marketplace:
codex plugin marketplace add https://github.com/mirkobozzetto/arsenal

# Install the plugins you need:
codex plugin add arsenal@arsenal
codex plugin add brief@arsenal
codex plugin add propose@arsenal
codex plugin add ship@arsenal
codex plugin add issue@arsenal
codex plugin add next@arsenal
codex plugin add trace@arsenal
codex plugin add review@arsenal
codex plugin add websearch@arsenal

In Codex, invoke a skill with $arsenal, $brief, $propose, $ship, $next, or the corresponding skill name. In Claude Code, use the / forms shown above.

next and trace bundle lifecycle hooks for both runtimes. Codex asks you to review and trust those hooks before running them, and again after an update that changes them: open /hooks. ChatGPT does not run plugin hooks, so both skills remain available there on demand without automation.

Update

Harness	Update
Claude Code	/plugin marketplace update arsenal, then restart or /reload-plugins. To get updates on their own, enable auto-update for arsenal in /plugin > Marketplaces (off by default for third-party marketplaces).
Codex	codex plugin marketplace upgrade arsenal, then codex plugin add <name>@arsenal for each installed plugin.
Pi	pi update --extensions for an unpinned install. A pinned one moves with pi install npm:arsenal-agent-skills@<version> or pi install git:github.com/mirkobozzetto/arsenal@<tag>.
OMP (marketplace)	omp plugin marketplace update arsenal, then omp plugin upgrade (--dry-run to preview). In a session: /marketplace update arsenal, then /marketplace upgrade. To get updates on their own, set marketplace.autoUpdate: auto in the OMP config.
OMP (linked checkout)	git pull in the checkout. Link any new skill with the loop above.

Start a new session after updating.

---

Good to know

• Published as I actually use them - adapt to your setup.
• Web lookups go through Exa MCP; propose also taps GitNexus when present, greps when not.
• ship uses the smallest meaningful verification permitted by your project instructions and reports what was actually checked.
• ship commits and pushes each verified unit on its work branch, never on the base branch; the first push of a branch asks once. --no-commit and --no-push turn this off. Opening or merging a pull request always asks.
• issue needs an authenticated gh CLI.
• Other agents (pi, oh-my-pi, Cursor): copy plugins/<name>/skills/<name>/ into the agent’s skill directory and wire its MCPs.
• Codex and Claude Code: both use the native plugin manifests included in each plugin folder.
• Agents are written once, in plugins/<name>/agents/src/<agent>.toml. python3 scripts/gen_agents.py writes the Claude Code file in agents/ and the Codex and OMP files in harness/; a test fails when one drifts from its source.
• Companion: espresso, the token-economy side. arsenal is what you build with; espresso keeps it cheap.

---

License

MIT: see LICENSE.