rc-project

Explains RC — a pure agent plugin (skills, commands, agents, hooks) for Claude Code, OpenCode and other tools — its workflow pipeline, artifact structure, bundled specialist agents, hooks, and configuration. Use when the user asks how to use RC, what skills or commands exist, or how the workflow pipeline works. Do not use to execute workflow steps — use the specific rc-* skills instead.

Implements idiomatic, fully type-hinted Python 3.12+ — precise typing and generics (PEP 695), asyncio structured concurrency, dataclasses, and robust error handling — with pytest testing, ruff linting/formatting, and pyproject.toml/uv packaging. Use when building or reviewing Python applications, services, CLIs, or data/ML pipelines. Invoke for type hints, Protocols, asyncio/TaskGroup, pytest fixtures/parametrize, packaging, or performance profiling. Do not use for JS/TS or Go.

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes. Do not use for routine changes with no failure to diagnose, or for architecture/design decisions (use rc-analyze or rc-oracle).

Transforms a rough, vague, or one-line user request into a structured, high-signal prompt in markdown before any work begins — surfacing the real objective, implicit context, ambiguities, scope, and acceptance criteria so the executing agent (or another LLM) wastes no turns guessing. Use when a request is underspecified, when the user asks to "enhance/enrich/improve this prompt", or as a first pass before a large or fuzzy task. Do not use when the request is already precise and scoped, for trivial one-step edits, or to actually execute the task (this only rewrites the prompt, it does not implement).

Design and build distinctive, production-grade interfaces with craft — dashboards, admin panels, SaaS apps, tools, web pages, landing pages, and interactive products — that avoid generic AI aesthetics. Use when building or reviewing any UI/frontend that must feel intentionally designed. Do not use for backend/non-UI work, or copywriting with no design deliverable.

Creates or updates a project README by analyzing the real codebase, then rewriting README.md with accurate, evidence-based content — or guides writing/improving a README by hand with templates and guidance matched to audience and project type (open source, personal, internal, config). Use when generating a README from scratch, refreshing an outdated one, syncing docs after features land, or drafting/reviewing a README manually. Do not use for API reference files (use rc-openapi or rc-postman), changelog generation, or editing source code.

Implements and reviews SvelteKit 2 apps with Svelte 5 and Bun — SSR load, form actions, hooks.server, cookies/sessions, adapter-node deploy, CSRF/CSP, and testing. Use when building or changing SvelteKit routes, SSR, forms, or VPS Bun adapters. Do not use for React/Next, Axum APIs alone (rc-axum), or plain static Svelte without Kit.

Use when writing or changing tests, adding mocks, or tempted to add test-only methods to production code - prevents testing mock behavior, production pollution with test-only methods, and mocking without understanding dependencies. Do not use for non-test production code, or for choosing a test framework/runner.

Creates a Product Requirements Document through interactive brainstorming with parallel codebase and web research. Use when starting a new feature or product, building a PRD, or brainstorming requirements. Do not use for technical specifications, task breakdowns, or code implementation.

Creates a Technical Specification by translating PRD business requirements into implementation designs through interactive technical clarification. Use when a PRD exists and needs a technical plan, or when technical architecture decisions need documentation. Do not use for PRD creation, task breakdown, or direct code implementation.

Performs a deep, evidence-based analysis of an existing codebase to answer a specific analytical prompt — diagnosing the root cause of a bug, hunting inconsistencies and contradictions, understanding how something works, or tracing a behavior or data flow — then writes and prints a thorough report, ending with an actionable implementation plan when a change is implied. Use to understand, trace, or diagnose existing code, or to assess impact and feasibility. Do not use to review a change set or diff for defects (use rc-code-review), to generate remediation issues (use rc-review-round), to apply a plan's code changes (use rc-fix-analysis), or to edit source code directly.

Implements and reviews Axum 0.8+ APIs in Rust — routing, State, extractors, Tower middleware, typed errors, WebSockets, CORS, timeouts, and production hardening. Use when building or changing Axum backends, handlers, middleware, or real-time WS endpoints. Do not use for SvelteKit/frontends (rc-sveltekit), SQLx/Postgres data layer alone (rc-sqlx), Rust language idioms — ownership, error types, trait design (rc-rust) — or general React/Next work.

Acts as a Product Manager to drive any issue board through its official MCP server — Linear and Jira/Atlassian supported. Discuss an idea, create/update/finalize an issue, refine an issue into a PRD/TechSpec/task breakdown with native child issues, execute an issue's children with test evidence, or (Jira) manage a GMUD — detecting the connected provider, applying the project's template conventions, and confirming every outward-facing write. Use when the user wants to work a board or tracker — brainstorm a task idea, open/update/move/close an issue or card, refine one into PRD/TechSpec/sub-issues, execute its children with evidence, or search issues. Do not use when no supported board MCP is available and the user declines to configure one, for unsupported trackers (GitHub Issues), or for bulk imports.

Performs a rigorous, standards-driven review of the current change set, writing a categorized, severity-ranked report to .rc/tasks/<slug>/ covering correctness, security, performance, and project-convention conformance. Use for an on-demand quality gate of a diff or branch before merge. Do not use to generate a review-round directory for remediation (use rc-review-round), to fix existing review issues (use rc-fix-reviews), or to edit source code.

Audits what consumes the agent's context window — installed agents, skills, rules, MCP tool schemas, and CLAUDE.md/AGENTS.md — estimates token cost, classifies each as always/sometimes/rarely needed, and recommends the highest-impact reductions. Use when sessions compact too early, when MCP/tooling feels heavy, or before adding more agents/skills. Do not use for application performance profiling or runtime memory analysis.

Decomposes PRDs and TechSpecs into detailed, independently implementable task files with enrichment from codebase exploration. Use when a PRD or TechSpec exists and needs to be broken down into executable tasks, or when task files need enrichment with implementation context. Do not use for PRD creation, TechSpec generation, or direct task execution.

Implements the change planned by a prior rc-analyze report — reads the report's "Implementation plan", applies the root-cause code changes step by step, adds or adjusts tests that encode why the change matters, and verifies with the project's gate. Use when an analysis from rc-analyze exists and the user wants its plan executed. Do not use to investigate or plan (use rc-analyze), to review a change set for defects (use rc-code-review), to remediate external PR review issues (use rc-fix-reviews), or to execute a PRD task file (use rc-execute-task).

Executes provider-agnostic PR review remediation using existing review round files under .rc/tasks/{name}/reviews-NNN/. Use when resolving batched review issues, updating issue markdown files, implementing fixes, and verifying the result. Do not use for PRD task execution, review export/fetch, or generic coding tasks without review issue files.

Routes fullstack Axum + SQLx/Postgres + SvelteKit work to the right specialist skills (rc-rust, rc-axum, rc-sqlx, rc-sveltekit), covering Rust idioms, API, data layer, SSR front, security, tests, and VPS deploy with Bun. Use when building or reviewing the Rust/SvelteKit stack together, scaffolding fullstack features, or unsure which skill to load. Do not use for React/Next stacks, pure Python, or workflow PRD/task pipeline phases.

Runs an adversarial generator↔evaluator loop to drive subjective quality (UI/UX, design, copy, CLI ergonomics, prose) up to a target score, by exercising the running artifact — not just reading the code — scoring it against a weighted rubric, feeding the defects back, and iterating until the threshold or a plateau. Use to refine an artifact whose quality a pass/fail gate cannot capture. Do not use for correctness/security defects (use rc-code-review) or for work fully covered by the build's verification gate.

Moves the current changes onto a proper feature branch, pushes it, and opens a PR — confirming each outward-facing step (branch, push, PR) and explicitly verifying the PR target branch. Also covers intelligent git rebase and merge-conflict resolution. Use when the user wants to ship local work as a branch and pull request, or needs to rebase a feature branch and resolve conflicts. Do not use for committing in place without a PR, or for force-pushing without going through the rebase guidance below.

Authors a new RC Claude Code hook from a plain-language description — emits a fail-open shell script in the house style under hooks/scripts/, wires it into hooks/hooks.json, documents it, and verifies it. Use when the user wants a deterministic guardrail, formatter, observer, or session warm-start turned into a hook. Do not use for application code, one-off shell scripts that aren't hooks, or editing existing guard logic unrelated to hooks.

The single place for RC's durable, cross-session memory and learning. Records and recalls curated project facts (decisions, conventions, gotchas, glossary) AND distills recurring corrections/workflows into confidence-scored learnings — all as plain markdown under .rc/memory/. Use to consult memory before working and to record durable facts or distilled learnings afterward. Do not use for workflow/task-scoped notes (use rc-workflow-memory) or for on-demand reflection on a diff (use lesson-learned).

Creates or updates an OpenAPI specification by discovering the project's HTTP endpoints, request schemas, and response models from source. Use to keep an openapi.yaml in sync after API changes, or to generate a spec for an existing service. Do not use for Postman collections (use rc-postman), README docs (use rc-readme), or editing source code.

Creates or updates a Postman Collection (v2.1.0) and its environment files by discovering the project's HTTP endpoints and request contracts from source. Use to keep a Postman collection in sync after routes or request schemas change, or to bootstrap one for an existing API. Do not use for OpenAPI specs (use rc-openapi), README docs (use rc-readme), or editing source code.

Performs a comprehensive code review of a PRD implementation and generates a review round directory with issue files compatible with rc-fix-reviews. Use when reviewing implemented PRD tasks, creating a manual review round without an external provider, or performing a quality audit of code changes. Do not use for fetching reviews from external providers, fixing existing review issues, executing PRD tasks, or editing source code.

Runs a review→fix→re-review loop over a PRD slug implementation by driving the Claude Code Workflow tool — fanning out multiple review lenses in parallel, synthesizing their findings into a reviews-NNN round, fixing the valid issues, and repeating until clean or a round cap. Use when the user wants an automated multi-lens review-and-remediate loop on a slug, orchestrated by Claude. Do not use for a single-pass review (use rc-code-review or rc-review-round), to fix an existing round (use rc-fix-reviews), or on non–Claude Code hosts (run the review skills manually).

Reviews the current change set through a single lens — over-engineering and complexity only — and writes a ranked delete-list to .rc/tasks/<slug>/ (what to delete, replace with stdlib, fold into a native feature, or shrink), ending with the net lines/dependencies a cleanup could remove. Use as an opt-in pre-PR pass to catch bloat that a severity-ranked review buries, or to audit legacy code that never went through the RC ladder. Do not use for correctness, security, or performance defects (use rc-code-review), to generate a remediation round (use rc-review-round), to fix existing review issues (use rc-fix-reviews), or to edit source code.

Guias de banco de dados relacional para otimização de queries e design de schema. Use ao escrever ou revisar queries (índices, planos de execução com EXPLAIN, problemas N+1, joins, paginação), modelar schema (normalização, tipos, constraints, chaves) ou avaliar performance de banco. Aplica análise read-only (só SELECT/EXPLAIN) por padrão. Carrega o guia certo por tarefa a partir de references/. Não use para migrations específicas de um repositório, administração de infraestrutura de banco, ou bancos não-relacionais (NoSQL, grafos, documentos).

Implements and reviews SQLx 0.8+ with PostgreSQL in Rust — PgPool, query/query_as, bind parameters, transactions, migrations, compile-time query macros, and database tests. Use when writing or changing database access with SQLx or Postgres from Rust. Do not use for Axum HTTP routing alone (rc-axum), SvelteKit (rc-sveltekit), Rust language idioms — ownership, error types, async patterns (rc-rust) — or non-Rust ORMs.

Executes the tasks of a RC feature slug by driving the Claude Code Workflow tool — one subagent per task, in dependency order, each implementing and verifying its task and returning structured test evidence. Use when the user wants to run a slug's task_NN.md files as a Claude-orchestrated workflow on a Claude Code host. Do not use to author tasks (use rc-create-tasks), to execute a single task in isolation (use rc-execute-task), or on non–Claude Code hosts (run each task via rc-execute-task in dependency order).

Maintains workflow-scoped task memory for RC runs using .rc/tasks/{name}/memory/ files. Use when a task prompt provides workflow memory paths and requires the agent to read, update, compact, and promote durable context across PRD task executions. Do not use for PR review remediation, global user preferences, or programmatic event-log summarization.

Guias para trabalhar com vídeo — processamento de mídia local, criação de conteúdo e integração opcional com VideoDB. Use ao manipular arquivos com ffmpeg (cortar, transcodificar, extrair frames/áudio, legendar, concatenar, redimensionar, comprimir para web, HLS), planejar conteúdo em vídeo (roteiro, hook, storyboard, estrutura de Reels/Shorts/YouTube, descrição/timestamps/tags) ou integrar o serviço VideoDB (ingest, busca semântica, edição de timeline — SaaS pago, opcional). Carrega o guia certo por tarefa a partir de references/. Não use para edição em GUI, geração de vídeo por IA sem provider definido, ou pipelines de streaming ao vivo em produção.

Author lean AGENTS.md/CLAUDE.md instruction files — resident system-prompt context where every line pays rent. Use when writing an agent instruction file from scratch, trimming a bloated one, or gating whether a new rule earns residence and at which scope. Do not use for on-demand skills (rc-skill-best-practices), for measuring what the whole config surface costs in tokens (rc-context-budget), or for human-facing docs and READMEs (rc-readme).

Removes AI-generated slop from the branch diff — unearned comments, defensive try/catch on trusted paths, `any` casts that only silence the type-checker, and nesting that should be an early return. Use before claiming a coding task complete, before a commit or PR, or when the user asks for slop cleanup. Do not use to hunt correctness or security defects (rc-code-review), to report on over-engineering without editing (rc-simplify-review), or to fix existing review issues (rc-fix-reviews).

Rust as a language — ownership and lifetimes, error hierarchies with thiserror/anyhow, async with Tokio, trait design, testing, performance, clippy, and rustdoc. Use when writing or reviewing Rust code, deciding between borrowing and cloning, designing an error type, structuring async tasks and channels, or configuring lints and benchmarks. Do not use for Axum HTTP routing and middleware (rc-axum), SQLx/Postgres data access (rc-sqlx), SvelteKit (rc-sveltekit), or non-Rust languages.

Author, refactor, and debug agent skills. Use when creating a new skill from scratch, pruning or restructuring a bloated SKILL.md, tightening a skill description's triggers, or diagnosing bundled references the agent ignores. Do not use for agent instruction files like CLAUDE.md or AGENTS.md (rc-agents-md), for measuring what the whole config surface costs in tokens (rc-context-budget), or for general documentation and READMEs (rc-readme).

Deterministic loop-lessons machine — records grounded engineering lessons from verification signals (AC gaps, surviving mutants, spec deviations, gate failures) and loads the corroborated ones at plan/design time, so autonomous or repeated loops stop re-making the same mistake. All bookkeeping (IDs, distinct-feature recurrence, candidate→confirmed promotion, quarantine, prune) is owned by scripts/lessons.mjs, not prose. Use to record a lesson after a verify/review failure, or to load confirmed lessons before planning a task or roadmap phase. Do not use for user-correction trigger→action learnings (rc-memory), per-task working notes (rc-workflow-memory), or on-demand reflection on a diff.

Executes full-project QA like a real user by discovering the repository verification and E2E contracts, running build, lint, test, and startup commands, exercising core workflows end-to-end through CLI, HTTP, and browser interfaces, requiring automated regression coverage for supported critical flows, fixing root-cause regressions, and rerunning the full gate. Uses the agent-browser companion skill for Web UI validation when a web surface exists. Use when validating a branch, release candidate, migration, refactor, or risky commit. Do not use for static code review only, one-off unit test edits, planning test cases, or architecture brainstorming without execution.

Autonomous creator-loop driver (Claude Code only) — walks .rc/ROADMAP.md one phase at a time, planning, executing, and verifying each phase without per-step human gates, until the roadmap is exhausted or a phase cannot reach a green gate. Use to advance a roadmap unattended for a long-running build/migration on a Claude Code host, after the loop-readiness gate passes. Do not use without a passing readiness gate, without a .rc/ROADMAP.md (author it with rc-roadmap first), on non–Claude Code hosts (run each phase's tasks via rc-execute-task), or for a single task (rc-execute-task) or a fixed pre-authored task set (rc-tasks-workflow).