RC is an agent plugin — skills, commands, agents, and hooks — that drives the full lifecycle of
AI-assisted development: optional ideation → PRD → TechSpec → tasks → execution → review →
remediation. It runs inside your agent host (Claude Code, OpenCode, and other tools); every
artifact is plain markdown under a project's .rc/. No binary, no daemon, no lock-in.

✨ Highlights

• Idea to code in a structured pipeline. Each phase produces plain-markdown artifacts that feed
  the next: idea (optional) → PRD → TechSpec → tasks → execution → review. Start from an idea for full
  research and debate, or jump straight to a PRD if the scope is clear.
• Runs in your host. Claude Code, OpenCode, and other agent tools load the same skills, commands,
  agents, and hooks — auto-discovered from the plugin.
• Cost-tiered specialists. Bundled leaf-worker agents route work to the right model: recon on a
  cheap/fast tier (rc-explorer, rc-librarian on haiku), hard reasoning/review on the strong tier
  (rc-oracle on opus), bounded implementation mid-tier (rc-fixer on sonnet).
• Codebase-aware. Tasks aren't generic prompts — RC explores your codebase to discover patterns
  and grounds each task in real project context.
• Memory & instincts between runs. Curated per-project memory, cross-task workflow memory, and an
  observe→distill instincts loop keep context fresh without manual bookkeeping.
• Multi-perspective review. rc-review-round (multi-lens) and rc-review-workflow (automated
  review→fix loop) find and remediate issues.
• Markdown everywhere. PRDs, specs, tasks, reviews, and ADRs are human-readable, diffable markdown.
• Resilience hooks. Guardrails (git/commit/gate/db), formatting, observability, and a repair-guidance
  hook that helps the agent recover from a failed edit or delegation.
• Local-first. All state lives in .rc/ — nothing leaves your machine.

📦 Installation

RC installs through your host's plugin/marketplace mechanism; skills, commands, agents, and hooks are
auto-discovered.

Claude Code:

/plugin marketplace add rodolfochicone/rc-project
/plugin install rc@rc-project

Commands are namespaced /rc:rc-*; update with /plugin marketplace update. The marketplace add
clones the private repo, so GitHub read access is required (gh auth login or GH_TOKEN).

OpenCode and other hosts: clone this repo and symlink its asset directories — skills into the
cross-tool ~/.agents/skills path and the OpenCode-specific agents/commands/plugin (under
opencode/) into ~/.config/opencode/; update with git pull. Step-by-step in
docs/claude-code-plugin.md.

Recommended companion: Serena MCP. When Serena is connected,
the code-touching skills (analyze, create-tasks/techspec/prd, execute-task, fix-analysis,
fix-reviews, review-round, code-review) prefer its LSP-backed symbolic tools for more accurate,
token-efficient navigation and editing, falling back to Grep/Glob when unavailable. Install it with
uv per Serena's docs.

🔄 How It Works

idea (optional) → PRD → TechSpec → tasks → execution → review → remediation → ship
      /rc-idea-factory        /rc-create-*        rc-tasks-workflow /       /rc-git
                                                  rc-execute-task

Each phase is a skill. Artifacts land under .rc/tasks/<slug>/ (_prd.md, _techspec.md, task
files, adrs/, reviews-NNN/) and are consumed by the next phase. See skills/rc/SKILL.md for the
full reference and skills/rc/references/workflow-guide.md for a step-by-step walkthrough.

🧩 Skill catalog

Skills run inside your AI agent — no context switching. Every skill is namespaced under the
plugin: the host auto-routes to a skill by its description, or you can invoke one explicitly as
/rc:<skill> (e.g. /rc:rc-analyze). The catalog below is grouped by job; "Use when" tells the
agent (and you) exactly when each one fires.

Meta — start here

Pipeline — plan

Pipeline — execute

Pipeline — autonomous loop (opt-in)

Autonomy is earned, not default: it pays off for migrations and large mechanical build-outs,
and only behind a green harness. Normal feature work stays in /rc-pipe.

Analysis & understanding

Review & remediation

Quality, testing & discipline

Docs

Ship & git

Memory & context

Config, security, integrations & scaffolding

Skill authoring & self-improvement

Frontend & design

Content & media

Library & framework references

Deep, opinionated guides for a specific library/runtime — auto-fire on the matching tech.

Backend, data & operations

TUI, CLI & multi-agent

Research

Project-specific (Escale)

Bundled extension

Optional, under extensions/rc-idea-factory: rc-idea-factory — raw idea → structured idea spec
with market research, business analysis, and a council debate. Sits before rc-create-prd.

⌨️ Commands

Commands are explicit entry points (/rc:<command>) that chain skills for a whole phase. Skills
auto-fire from context; commands are what you type to drive a stage on purpose.

🤖 Bundled specialist agents

Leaf-worker subagents (under agents/, discovered as rc:<name>) you delegate to, each on a
cost-appropriate model tier. They carry no Task/Agent tool, so they cannot spawn further
subagents (the recursion cap). See skills/rc/references/delegation-contract.md.

Council archetypes (dispatched by the rc-council skill for multi-perspective debate, not called
directly): architect-advisor (systems & long-horizon), pragmatic-engineer (execution reality),
security-advocate (assume-breach), product-mind (user value & opportunity cost), devils-advocate
(informed skeptic), the-thinker (reframing).

🧠 Memory & instincts

• Project memory — .rc/memory/ (INDEX.md + one file per durable fact), curated by rc-memory.
• Workflow memory — .rc/tasks/<slug>/memory/ (shared MEMORY.md + per-task files), maintained
  by rc-workflow-memory so each agent inherits context from previous tasks.
• Instincts — the observe hook appends tool observations to .rc/memory/observations.jsonl;
  rc-memory distills recurring patterns into confidence-scored learnings.

🪝 Hooks

Harness-only guardrails (no model-context cost), wired in hooks/hooks.json:

• git-guard — blocks destructive/history-rewriting git commands.
• commit-guard — gates commits behind verification.
• db-guard — enforces read-only database access by default (blocks write/DDL SQL without approval).
• go-mod-guard / gateguard — protect go.mod and force investigation before risky edits.
• go-fmt — formats Go on write. observe — feeds the instincts loop. repair-guidance —
  helps the agent recover from a failed edit/delegation. notify — Stop/Notification signals.
• memory-load — SessionStart warm-start: surfaces a bounded summary of .rc/memory/ (facts +
  learnings) and nudges distillation when observations pile up. Silent outside RC projects.

🖥️ Supported hosts

RC ships for Claude Code, OpenCode, and other agent tools. Skills, commands, agents, and hooks are
auto-discovered when the plugin is installed; OpenCode-specific variants live under opencode/.
Output styles under output-styles/ are versioned here but applied per-host (Claude Code loads them
from ~/.claude/output-styles/).

🤝 Contributing

There is no build step — components are markdown, JSON, and small Node/Bash scripts. Validate a change
with node scripts/plugin-smoke.mjs (frontmatter + hook wiring) and, for task files,
node scripts/validate-tasks.mjs --slug <slug>. See AGENTS.md for conventions and CONTRIBUTING.md.

📄 License

MIT — see LICENSE.