Rune Guides

Everything you need to go from install to production. Rune turns your AI coding assistant into a structured engineering team with 66 interconnected skills.

What is Rune?

Rune is a 66-skill mesh ecosystem for AI coding assistants. Instead of giving your AI one prompt at a time, Rune gives it structured workflows where skills call each other automatically.

Without Rune

  • You prompt "fix this bug"
  • AI guesses a fix, might break tests
  • No security check before commit
  • Same mistake next session
  • Context lost between sessions

With Rune

  • You say /rune cook "fix login bug"
  • scout scans codebase, debug traces root cause
  • fix writes code, test verifies, sentinel blocks secrets
  • session-bridge saves context for next session
  • git creates semantic commit automatically

Think of it like this: without Rune, your AI is a solo intern. With Rune, your AI is a coordinated engineering team — debugger, tester, security auditor, architect, all talking to each other.

Installation

Claude Code uses Rune as a native plugin — no compilation needed.

# Step 1: Add marketplace (one-time) claude plugin marketplace add rune-kit/rune # Step 2: Install the plugin claude plugin install rune # Verify it's loaded claude 66 skills loaded from rune
Tip: The marketplace only needs to be added once. After that, just claude plugin install rune or claude plugin update rune.

Cursor uses Agent Skills (Cursor 2.4+). Rune compiles all 66 skills into .cursor/skills/ — loaded on demand.

# In your project directory npx --yes @rune-kit/rune init --platform cursor → Detected: cursor ✓ Created rune.config.json ✓ Built 66 skills + 14 extensions to .cursor/skills/

Skills are compiled into .cursor/skills/. Cursor picks them up automatically.

Windsurf uses .md rule files in its rules directory.

npx --yes @rune-kit/rune init --platform windsurf ✓ Built 66 skills + 14 extensions to .windsurf/skills/

Google Antigravity (formerly Jules) uses the .agent/ directory.

npx --yes @rune-kit/rune init --platform antigravity ✓ Built 66 skills + 14 extensions to .agents/skills/
Note: Antigravity is currently in early access. Install it from idx.google.com (Project IDX) or via your Google Cloud workspace.

Codex loads Rune as a native plugin and keeps project skills in .agents/skills/.

# Add the Rune marketplace once codex plugin marketplace add rune-kit/rune # Install Rune, then compile roles and wire synchronous hooks codex plugin add rune@rune-kit npx --yes @rune-kit/rune setup --here --platform codex # Inside Codex: inspect and trust the installed hooks /hooks

OpenClaw uses Rune as a unified mesh package from ClawHub.

clawhub install rune-kit # All 66 skills installed as one mesh package # Works with any OpenClaw-compatible agent
Note: Rune is published as a single unified package on ClawHub. Individual skills are NOT published separately — the mesh requires all skills together.

First Run

After installing, onboard your project so Rune understands your codebase:

/rune onboard [scout] Scanning project structure... [scout] Detected: Next.js 16 + TypeScript + Prisma + TailwindCSS 4 [onboard] Created .rune/conventions.md [onboard] Created .rune/decisions.md [onboard] Created CLAUDE.md (project configuration) ✓ Project context ready. Rune will remember this across sessions.

This creates persistent context files that every Rune skill reads. No more re-explaining your stack every session.

Tip: Commit the .rune/ directory to your repo. This way every team member (and every AI session) starts with the same project understanding.

Add to Existing Project

"I already have a project. How do I make Rune debug it?" — Great question. Rune works on any existing codebase. Here's the 3-step flow:

  1. Install Rune (see platform tabs above)
  2. Run onboard — /rune onboard scans your codebase, detects stack, frameworks, patterns
  3. Start using workflows — /rune debug "my error", /rune cook "add feature", etc.

Rune's scout skill reads your files, onboard creates context, and from there every skill knows your project structure, conventions, and dependencies. You don't need to configure anything manually.

# Example: debug a real bug in your existing project /rune debug "API returns 500 on /api/users when filtering by date" [scout] Scanning: src/api/users/route.ts, src/lib/db.ts... [debug] Root cause: Date parsing fails for ISO format without timezone [debug] → Handing off to fix [fix] Patched: src/lib/db.ts:47 — added timezone normalization [verification] ✓ All tests pass

Mesh Architecture

Unlike a pipeline (A→B→C) or hub-spoke (everything through one center), Rune's mesh means skills call each other bidirectionally and route around failures.

248 connections + 45 signals across 66 skills. When debug can't find the cause, it escalates to problem-solver. When cook hits a wall 3 times, it pivots to brainstorm. When sentinel finds a vulnerability, it blocks the commit. The mesh is self-healing.

5-Layer System

Layer Role Count Examples
L0 Router 1 skill-router — routes every action to the right skill
L1 Orchestrators 5 cook, team, launch, rescue, scaffold
L2 Workflow Hubs 30 plan, debug, fix, test, review, sentinel, design, ba, adversary...
L3 Utilities 30 research, verification, git, session-bridge, sentinel-env...
L4 Extension Packs 14 @rune/trading, @rune/saas, @rune/ai-ml, @rune/gamedev...

Layer rules: Skills only call downward (L1→L2→L3). L3 utilities never call L1 orchestrators. This prevents circular dependencies and keeps the mesh predictable.

Skill Connections

Every skill declares who it calls and who calls it. Here's how cook orchestrates a feature:

cook
→
scout
→
ba
→
plan
→
adversary
→
test
→
fix
→
preflight
→
sentinel
→
review
→
git

This is just one path. If fix fails 3 times, cook escalates: first to debug, then to brainstorm (rescue mode), then asks the user. The mesh adapts.

Model Routing

Rune auto-selects the cheapest model that can handle each task:

ModelCostUsed For
HaikuLowestscout, verification, git, sentinel-env — scanning, checking
SonnetMediumfix, test, review, design — code writing, analysis
OpusHighestplan, architect, adversary, ba — deep reasoning, decisions
Cost estimate: A typical /rune cook feature costs ~$0.05-0.15 in API tokens. Most of the work is done by Haiku and Sonnet.

/rune cook — Build Features

The primary workflow. Builds any feature with TDD discipline, security gates, and automatic verification.

/rune cook "add Stripe subscription billing with plan management"
Phase 0: Resume
→
Phase 0.5: Env Check
→
Phase 1: Understand
→
Phase 2: Plan
→
Phase 2.5: Adversary
→
Phase 3: Test
→
Phase 4: Implement
→
Phase 5: Quality
→
Phase 6: Verify
→
Phase 7: Commit

Phase 2.5 (Adversary) is unique to Rune: before writing any code, the adversary skill red-teams the plan across 5 dimensions — edge cases, security, scalability, error propagation, and integration risk. It catches issues before they become bugs.

Key gate: If adversary returns REVISE, the plan must be updated before proceeding. This prevents "code first, fix later" patterns that waste time.

/rune debug — Root Cause Analysis

/rune debug "login returns 401 for valid credentials" [scout] Found: src/auth/middleware.ts, src/auth/jwt.ts, src/api/login.ts [debug] Tracing authentication flow... [debug] Root cause: JWT_SECRET rotated but old secret not in fallback array [debug] Confidence: HIGH (verified with test case) [debug] → Handing off to fix [fix] Patched: src/auth/jwt.ts — added secret rotation fallback [verification] ✓ 14/14 tests pass, 0 regressions

Debug uses structured reasoning to trace code paths. If it can't find the cause after 3 attempts, it escalates to problem-solver (5 Whys, Fishbone analysis).

/rune rescue — Refactor Legacy Code

/rune rescue src/legacy/payment-processor.ts [autopsy] Health score: 34/100 (CRITICAL) [autopsy] Issues: 12 God classes, 8 circular deps, 0% test coverage [safeguard] Creating characterization tests... [surgeon] Refactoring 1 module per session (Strangler Fig pattern)

Rescue takes the safe approach: autopsy first (health score), then characterization tests (safety net), then one module at a time. Never rewrites everything at once.

/rune team — Parallel Execution

/rune team "refactor auth, add billing, update dashboard" [team] Decomposing into 3 parallel streams... [worktree] Created: auth-refactor, billing-feature, dashboard-update [team] Stream 1: cook → auth refactor (worktree: auth-refactor) [team] Stream 2: cook → billing (worktree: billing-feature) [team] Stream 3: cook → dashboard (worktree: dashboard-update) [team] All streams complete → merging... [completion-gate] ✓ All 3 streams verified

Team decomposes large tasks into a DAG, creates isolated git worktrees for each stream, runs parallel agents, then merges everything back. Use when a task spans 5+ files or 3+ modules.

/rune onboard — Project Setup

/rune onboard [scout] Scanning 247 files... [scout] Stack: Next.js 16 + Prisma 6 + TailwindCSS 4 + TypeScript 5.7 [onboard] Created .rune/conventions.md (coding patterns detected) [onboard] Created .rune/decisions.md (architecture decisions) [onboard] Updated CLAUDE.md (project configuration for AI)

Run this once per project. After that, every Rune skill knows your stack, patterns, and conventions.

Claude Code

Rune is a native Claude Code plugin. It uses the full plugin system: subagents, hooks, commands, contexts, and skills. This is the richest experience.

# Step 1: Add marketplace (one-time) claude plugin marketplace add rune-kit/rune # Step 2: Install claude plugin install rune # Use any skill directly /rune cook "add user authentication" /rune debug "TypeError in dashboard" /rune review

Cursor

Cursor uses Agent Skills (Cursor 2.4+) — directory-per-skill SKILL.md files that the agent loads on demand, keeping context lean.

npx --yes @rune-kit/rune init --platform cursor # Skills appear in .cursor/skills/ # Cursor discovers them and loads each on demand

Windsurf

npx --yes @rune-kit/rune init --platform windsurf # Skills appear in .windsurf/skills/

Antigravity

npx --yes @rune-kit/rune init --platform antigravity # Skills appear in .agents/skills/

OpenAI Codex

OpenAI Codex is a first-class Rune runtime. Native plugin installation supplies Rune's skills and lifecycle integration; project compilation emits directory-per-skill files in .agents/skills/, a managed AGENTS.md block, and project-scoped roles in .codex/agents/.

# Native plugin installation codex plugin marketplace add rune-kit/rune codex plugin add rune@rune-kit # Project-local skills, roles, and synchronous lifecycle hooks npx --yes @rune-kit/rune setup --here --platform codex # Source-only alternative when you do not install the plugin npx --yes @rune-kit/rune init --platform codex # Output structure: .agents/skills/ ├── rune-cook/SKILL.md ├── rune-debug/SKILL.md ├── rune-fix/SKILL.md ├── rune-plan/SKILL.md ├── rune-test/SKILL.md └── ... (66 skills total) .codex/agents/rune-{heavy,standard,fast}.toml .codex/hooks.json AGENTS.md (Rune-managed block; existing content preserved)

Codex skills use YAML frontmatter with name and description fields, matching Codex's native skill format. The compiler maps model tiers to project roles and tool names to Codex-compatible descriptions. Codex lifecycle handlers are synchronous because Codex skips async handlers.

Hook trust is explicit: after setup, open /hooks in Codex, review the commands in .codex/hooks.json, and trust the definitions you want enabled. Rune preserves human-authored AGENTS.md content and replaces only its managed block.
Pulse on Codex: [tui].status_line can show Codex's built-in footer items only. The full rich Pro Pulse display runs as an external watcher/HUD; Codex does not expose Claude's arbitrary executable statusLine hook.

OpenCode

OpenCode is an open-source AI coding agent with 120K+ GitHub stars. It supports directory-per-skill SKILL.md format with native subagent support.

# Build Rune skills for OpenCode npx @rune-kit/rune build --platform opencode --output . # Or initialize with auto-detection npx @rune-kit/rune init # Output structure: .opencode/ └── skills/ ├── rune-cook/ │ └── SKILL.md ├── rune-plan/ │ └── SKILL.md └── ...

OpenCode preserves native subagent support — parallel agents are kept as true parallel invocations rather than collapsed to sequential steps. The compiler also generates an AGENTS.md file for project-level context.

Note: OpenCode also searches .claude/skills/ and .agents/skills/ — so Claude-compatible skill formats work too.

OpenClaw (ClawHub)

OpenClaw agents can install Rune from ClawHub — the skill registry for the OpenClaw ecosystem. Rune is published as a single unified package (not individual skills).

clawhub install rune-kit # All 66 skills + 14 extension packs as one mesh package # Slug: rune-kit on clawhub.ai
Important: Rune skills are NOT published individually on ClawHub. The mesh uses 248 connections + 45 signals for routing — installing skills separately would break those workflows.
All 13 platforms get the same 66 skills. The compiler handles format differences. Cross-references, tool names, and model hints are adapted per platform.

Using Extension Packs

Extension packs are domain-specific skill bundles. They're included with Rune and auto-detected when your project matches their domain.

# Packs are auto-loaded by the mesh. No configuration needed. # When cook detects a SaaS project, @rune/saas patterns activate automatically. # To manually compile with specific packs only: npx --yes @rune-kit/rune build --extensions trading,saas

Available Packs

@rune/uiFrontend patterns, component architecture, responsive design
@rune/backendAPI design, database patterns, auth, caching
@rune/devopsCI/CD, Docker, K8s, monitoring, chaos engineering
@rune/mobileReact Native, Flutter, platform-specific patterns
@rune/securityOWASP, threat modeling, penetration testing
@rune/tradingMarket data, backtesting, risk management, quant patterns
@rune/saasMulti-tenancy, billing, usage tracking, onboarding
@rune/ecommerceCart, checkout, inventory, payment gateways
@rune/ai-mlML pipelines, LLM integration, prompt patterns, evaluation
@rune/gamedevGame loops, ECS, physics, asset pipelines
@rune/contentCMS patterns, markdown processing, SEO
@rune/analyticsTracking, dashboards, SQL patterns, data validation
@rune/chrome-extBrowser extensions, content scripts, popup UI
@rune/zaloZalo OA messaging, Mini Apps, webhooks, and rate-limit-aware integrations

Creating Your Own Pack

# Use skill-forge to scaffold a new extension pack /rune skill-forge "create extension pack @rune/my-domain" # Pack structure: extensions/my-domain/ ├── PACK.md ← Pack manifest (skills, patterns, conventions) └── README.md ← Documentation

See docs/EXTENSION-TEMPLATE.md for the full PACK.md format. Community packs are welcome — submit a PR to add yours!

rune.config.json

Created by rune init. Only needed for non-Claude platforms.

{ "$schema": "https://rune-kit.github.io/rune/config-schema.json", "version": 1, "platform": "cursor", "skills": { "disabled": ["video-creator", "marketing"] }, "extensions": { "enabled": null // null = all, or ["trading", "saas"] }, "output": { "index": true } }

Disabling Skills

Don't need marketing or video skills? Disable them:

# Via CLI flag npx --yes @rune-kit/rune build --disable marketing,video-creator # Or in rune.config.json "skills": { "disabled": ["marketing", "video-creator"] }

Common Issues

"Skills not loading" (Claude Code)

# Reinstall the plugin claude plugin uninstall rune claude plugin install rune-kit/rune # Restart Claude Code to pick up changes

"npx command not found" (Cursor/Windsurf)

Make sure Node.js 18+ is installed. Or install globally:

npm install -g @rune-kit/rune rune init --platform cursor

"Skills compiled but AI doesn't use them"

Restart your IDE after running rune init or rune build. Some IDEs cache rules and need a restart to pick up new files.

"How do I update Rune?"

# Claude Code claude plugin install rune-kit/rune # reinstall gets latest # Other platforms npx --yes @rune-kit/rune@latest build

FAQ

Is Rune free?

Yes. The full 66-skill mesh + 14 extension packs are free forever, MIT license. Rune Pro ($49 lifetime) adds business department skills (Product, Sales, Data Science).

Does Rune work with my existing CLAUDE.md / .cursorrules?

Yes. Rune's skills are additive — they don't overwrite your existing configuration. Your project-specific rules take precedence.

How much does it cost in API tokens?

A typical /rune cook feature: $0.05-0.15. Rune auto-routes to the cheapest model (Haiku for scanning, Sonnet for code, Opus only for architecture decisions).

Can I create my own skills?

Yes! Use /rune skill-forge to scaffold a new skill. Skills are just Markdown files with a specific format. See docs/SKILL-TEMPLATE.md.

Does it work offline?

Rune itself is offline (all skills are local Markdown files). But the AI model you're using (Claude, GPT, etc.) needs internet access.

◆ Rune — Less skills. Deeper connections.
GitHub • npm • Issues