Agent integrations

You’re a developer who wants their AI coding agent to read the same project conventions as the rest of the team and pick up the skills bundled inside the npm packages you depend on. This page is the per-IDE cookbook. Pick your agent below, copy-paste the snippet, ship.

Every section follows the same three-step pattern — what differs is which files agent-kit writes, which --target flag to pass, and what reload step the agent needs.

The shared baseline

Before any per-IDE step, every project does the same bootstrap — no install needed:

npx @mongez/agent-kit@latest init

That runs the latest published agent-kit on the fly (use the scoped name with npx; npx agent-kit … unscoped resolves a different package) and writes a starter AGENTS.md at the project root (only if one doesn’t already exist), then derives CLAUDE.md, .gemini/GEMINI.md, .github/copilot-instructions.md, and CONVENTIONS.md from it. It also seeds agentKit.targets in package.json — ["claude"] by default, or pass --target claude,cursor,… to choose — so the otherwise-implicit default is visible and editable. (init is one-time, so always-latest npx is ideal; the recurring sync belongs as a pinned dev dependency.) From here, the per-agent sections below differ only in which --target you pass and which directory the skills land in.

Then wire sync into postinstall so every future yarn install / npm install keeps everything current:

{
  "scripts": {
    "postinstall": "agent-kit sync"
  }
}

init can wire this for you. When @mongez/agent-kit is already a dependency/devDependency and no postinstall exists yet, init writes the script above automatically. The zero-install npx @mongez/agent-kit@latest init bootstrap can’t (nothing is in node_modules to run it), so add it by hand after installing agent-kit — init prints a reminder.

At-a-glance: every supported agent

A one-table lookup before you scroll into the per-agent sections. Two things to watch for in the Skills folder column — the singular/plural variants are real and easy to mis-type:

Agent	`--target`	Derived file	Skills folder	Reload
Claude Code	`claude`	`CLAUDE.md`	`.claude/skills/`	live — next prompt
Cursor	`cursor`	— (reads `AGENTS.md`)	`.cursor/skills/`	window reload
Codex	`codex`	—	`.codex/skills/`	next session
Kiro	`kiro`	—	`.kiro/skills/`	window reload
GitHub Copilot	`copilot`	`.github/copilot-instructions.md`	`.github/skills/`	window reload
Antigravity	`antigravity`	—	`.agent/skills/` (singular “agent”)	window reload
OpenCode	`opencode`	—	`.opencode/skill/` (singular “skill”)	next session
Amp	`amp`	—	`.agents/skills/` (plural “agents”)	window reload
Goose	`goose`	—	`.goose/skills/`	next session
Gemini CLI	derive-only	`.gemini/GEMINI.md`	not supported	re-read every invocation
Aider	derive-only	`CONVENTIONS.md`	not supported	re-read every session

Three lookalikes, three different paths. .agent/skills/ (Antigravity, singular agent) ≠ .agents/skills/ (Amp, plural agents) ≠ .opencode/skill/ (OpenCode, singular skill). These are the upstream conventions — agent-kit just writes what each tool actually reads. The --target name is always unambiguous; trust the flag.

Using agent-kit with Claude Code

Claude Code is Anthropic’s terminal/IDE coding agent. It reads CLAUDE.md for project conventions and .claude/skills/ for installable skills. Live skill reload — the only agent that picks up new skill files within the same session without a restart.

# One-time setup
npx agent-kit init
npx agent-kit sync --target claude

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["claude"] }
}

agent-kit creates: CLAUDE.md (derived from AGENTS.md) + .claude/skills/<pkg-slug>-<skill-name>/SKILL.md for every skill bundled in your dependencies.

Reload quirk: if .claude/skills/ didn’t exist when your Claude Code session started, restart Claude once after the first sync so it discovers the new directory. After that, edits to existing skill files are picked up on the next prompt — no restart.

Using agent-kit with Cursor

Cursor is a VSCode-based AI editor. Reads root AGENTS.md natively (no derivation needed) and .cursor/skills/ for skills.

npx agent-kit sync --target cursor

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["cursor"] }
}

agent-kit creates: .cursor/skills/<pkg-slug>-<skill-name>/SKILL.md for every bundled skill. No CLAUDE.md-style derived file is generated — Cursor reads AGENTS.md directly.

Reload quirk: Cursor reads its .cursor/skills/ directory on session start. After running sync, close and reopen the project (or Cmd/Ctrl+Shift+P → “Reload Window”) so the new skills are picked up.

Using agent-kit with Codex

Codex is OpenAI’s coding agent (CLI + IDE flavors). Reads root AGENTS.md natively and .codex/skills/ for skills.

npx agent-kit sync --target codex

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["codex"] }
}

agent-kit creates: .codex/skills/<pkg-slug>-<skill-name>/SKILL.md. No derived AGENTS.md alternative needed.

Reload quirk: Codex picks up skills on the next session. CLI users get fresh reads on every codex invocation; IDE users should reload the window.

Using agent-kit with Kiro

Kiro is Amazon’s AI-native IDE. Reads root AGENTS.md natively and .kiro/skills/ for skills.

npx agent-kit sync --target kiro

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["kiro"] }
}

agent-kit creates: .kiro/skills/<pkg-slug>-<skill-name>/SKILL.md. No derived file.

Reload quirk: Reload Kiro (window reload) after the first sync. Subsequent skill edits typically need a fresh session too.

Using agent-kit with Gemini CLI

Gemini CLI is Google’s terminal-based coding agent. Reads .gemini/GEMINI.md (it does not read root AGENTS.md natively).

npx agent-kit sync --derive-only

agent-kit creates: .gemini/GEMINI.md derived from AGENTS.md (regenerated on every sync, so the two never drift).

No --target gemini for skills — Gemini CLI doesn’t currently have a published skills directory convention, so agent-kit doesn’t write one. Only the derived GEMINI.md is generated for this agent. If you also use Claude or Cursor on the same project, run sync --target claude,cursor so the derive step + the skills targets you do care about run in one shot:

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["claude", "cursor"] }
}

The Gemini derive runs on every sync regardless of targets — the targets array gates only the skills export. So this agentKit block keeps GEMINI.md fresh AND mirrors skills into Claude + Cursor.

Reload quirk: Gemini CLI re-reads its instructions on every invocation, so there’s no “reload window” step.

Using agent-kit with GitHub Copilot

GitHub Copilot is the VSCode / Visual Studio AI completion + chat agent. Reads .github/copilot-instructions.md for project conventions and .github/skills/ for skills.

npx agent-kit sync --target copilot

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["copilot"] }
}

agent-kit creates: .github/copilot-instructions.md (derived from AGENTS.md) + .github/skills/<pkg-slug>-<skill-name>/SKILL.md.

Reload quirk: Cmd/Ctrl+Shift+P → “Developer: Reload Window” after the first sync so VSCode re-scans .github/skills/. Copilot’s instructions file is re-read on every prompt, so no reload needed for AGENTS.md edits.

Using agent-kit with Aider

Aider is a terminal-based AI pair programmer that doesn’t follow the skills/ convention. It reads a CONVENTIONS.md file (loaded via /read or auto-loaded via .aider.conf.yml).

npx agent-kit sync --derive-only

agent-kit creates: CONVENTIONS.md derived from AGENTS.md.

To auto-load it in every Aider session, drop this in .aider.conf.yml at the project root:

read:
  - CONVENTIONS.md

No --target aider for skills — Aider doesn’t currently have a skills directory convention. Only the derived CONVENTIONS.md is generated for this agent.

Reload quirk: Aider re-reads CONVENTIONS.md on every session start.

Using agent-kit with Antigravity

Antigravity is Google’s AI-native IDE (distinct from Gemini CLI). Reads root AGENTS.md natively and .agent/skills/ (singular agent — not to be confused with Amp’s plural .agents/skills/).

npx agent-kit sync --target antigravity

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["antigravity"] }
}

agent-kit creates: .agent/skills/<pkg-slug>-<skill-name>/SKILL.md. No derived file.

Reload quirk: Reload the Antigravity workspace after the first sync.

Using agent-kit with OpenCode

OpenCode is an open-source AI coding agent. Reads root AGENTS.md natively and .opencode/skill/ for skills — note the singular “skill” in the path (this is OpenCode’s own convention, distinct from every other agent’s plural skills/).

npx agent-kit sync --target opencode

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["opencode"] }
}

agent-kit creates: .opencode/skill/<pkg-slug>-<skill-name>/SKILL.md. No derived file.

Reload quirk: OpenCode rescans on session start; reload after the first sync so the new directory is picked up.

Using agent-kit with Amp

Amp (Sourcegraph) is a CLI + IDE coding agent. Reads root AGENTS.md natively and .agents/skills/ for skills — note the plural “agents” in the path (distinct from Antigravity’s singular .agent/).

npx agent-kit sync --target amp

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["amp"] }
}

agent-kit creates: .agents/skills/<pkg-slug>-<skill-name>/SKILL.md. No derived file.

Reload quirk: Window reload on first sync so Amp picks up the new directory.

Using agent-kit with Goose

Goose (Block / Square) is an extensible AI coding agent. Reads root AGENTS.md natively and .goose/skills/ for skills.

npx agent-kit sync --target goose

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["goose"] }
}

agent-kit creates: .goose/skills/<pkg-slug>-<skill-name>/SKILL.md. No derived file.

Reload quirk: Goose re-reads on the next session.

Using more than one agent at once

You can pass multiple targets to a single sync invocation, and the agentKit.targets array in package.json accepts a list too. This is the right answer when a project has contributors using different agents — every supported agent picks up the same skills with one install.

npx agent-kit sync --target claude,cursor,codex

{
  "scripts": { "postinstall": "agent-kit sync" },
  "agentKit": { "targets": ["claude", "cursor", "codex", "copilot"] }
}

Every listed target gets its own .<tool>/skills/ directory. Skill content is copied (not symlinked) — disk overhead is small, but you can mix and match without worrying about cross-tool state. The derive step still emits CLAUDE.md, .gemini/GEMINI.md, .github/copilot-instructions.md, and CONVENTIONS.md on every sync regardless of which skill targets you pick.

Where to go next

Overview — what agent-kit is and how it fits together
CLI usage — every flag, every command, exact invocations
Recipes — monorepo wiring, watch mode, CI guardrails, pick/omit filtering
Authoring skills — for package authors who want to ship reusable skills inside their own npm package