Rune Guides

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

What is Rune?

Rune is a 58-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.

# Install the plugin claude plugin install rune-kit/rune # Verify it's loaded claude 58 skills loaded from rune
Tip: Claude Code loads SKILL.md files directly from the plugin source. No compilation step, no configuration needed. Just install and go.

Cursor uses .mdc rule files. Rune compiles all 58 skills into Cursor's format.

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

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

Windsurf uses .md rule files in its rules directory.

npx --yes @rune-kit/rune init --platform windsurf ✓ Built 58 skills + 12 extensions to .windsurf/rules/

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

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

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.

200+ connections between 58 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 27 plan, debug, fix, test, review, sentinel, design, ba, adversary...
L3 Utilities 24 research, verification, git, session-bridge, sentinel-env...
L4 Extension Packs 13 @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.

# Install claude plugin install rune-kit/rune # Use any skill directly /rune cook "add user authentication" /rune debug "TypeError in dashboard" /rune review

Cursor

Cursor uses .mdc (Markdown Config) rule files. The compiler converts each SKILL.md into Cursor's native format with proper frontmatter.

npx --yes @rune-kit/rune init --platform cursor # Skills appear in .cursor/rules/rune/ # Cursor auto-loads them for every conversation

Windsurf

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

Antigravity

npx --yes @rune-kit/rune init --platform antigravity # Skills appear in .agent/rules/rune/

OpenAI Codex

OpenAI Codex uses a directory-per-skill structure inside .codex/skills/. Each skill gets its own folder with a SKILL.md file — similar to Rune's native format.

npx --yes @rune-kit/rune init --platform codex # Output structure: .codex/skills/ ├── rune-cook/SKILL.md ├── rune-debug/SKILL.md ├── rune-fix/SKILL.md ├── rune-plan/SKILL.md ├── rune-test/SKILL.md └── ... (58 skills total)

Codex skills use YAML frontmatter with name and description fields, matching Codex's native skill format. The compiler also maps tool names to Codex-compatible descriptions (e.g., Read → read the file).

Codex project config: Codex uses AGENTS.md (equivalent to Claude's CLAUDE.md). Rune skills work alongside your existing AGENTS.md without conflicts.

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.
All platforms get the same 58 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

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 58-skill mesh + 13 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