ra

System design and architecture decisions. Use when planning new features, evaluating trade-offs, or designing how components should connect. Proposes 2-3 approaches and recommends one.

Smart commit workflow. Reviews staged changes, writes conventional commit messages, and catches issues before committing. Use when ready to commit work.

Quality review of completed work. Use after making changes and before claiming completion. Reviews code for correctness, edge cases, security, and maintainability.

Systematic debugging workflow. Use when diagnosing bugs, test failures, or unexpected behavior. Follows a rigorous reproduce → isolate → hypothesize → fix → verify cycle.

Systematic multi-agent research. Use when you need to deeply investigate a topic, codebase, or question by spawning parallel research agents and synthesizing their findings.

Deep code explanation. Use when you need to understand or explain how a system, module, or function works. Traces data flow, maps dependencies, and explains design decisions.

Socratic clarification before execution. Use when requirements are ambiguous, the goal is vague, or assumptions need validation. Asks targeted questions to eliminate uncertainty.

Guided migration for version upgrades, framework changes, and API transitions. Creates a step-by-step migration plan with rollback points. Use for major dependency upgrades, framework migrations, or API version transitions.

Interactive pair programming mode. Use when the user wants to think through a problem together, learn while building, or needs explanations alongside implementation. Explains decisions as you code.

Create well-structured pull requests. Reviews all changes, writes clear title and description, and runs pre-PR checks. Use when ready to open a PR.

Safe incremental refactoring with continuous verification. Use when restructuring code, extracting modules, renaming across files, or changing interfaces. Ensures nothing breaks.

Security-focused code review using OWASP Top 10. Use when auditing code for vulnerabilities, reviewing auth flows, or checking for data exposure. Produces a prioritized findings report.

Recovery skill for when you're going in circles. Use when the same approach keeps failing, errors repeat, or progress has stalled. Breaks the loop with systematic reframing.

Parallel specialist coordination. Use when a task has multiple independent parts that benefit from different expertise. Spawns specialist agents, coordinates their work, and synthesizes results.

Generate comprehensive tests for existing code. Use when adding test coverage, writing regression tests, or testing edge cases. Discovers the project's test framework and conventions automatically.

Full autonomous pipeline for complex tasks. Combines clarification, planning, parallel execution, verification, and self-review into a single end-to-end workflow. Use for ambitious multi-step tasks.

Autonomous self-improvement orchestrator that runs parallel exploration loops across all degrees of freedom to optimize an agent against a benchmark.

Use when creating a new ra recipe — a complete agent configuration with skills, middleware, and config.

Use when adding a new built-in tool to ra.

General-purpose coding agent. Use for writing, editing, debugging, and navigating codebases.

Creates and manages persistent specialist agents by writing ra configs and running them via CLI

Use when reviewing code, writing new code, or the user asks about code quality. Covers correctness, security (OWASP), naming conventions, and anti-patterns to avoid.

Use when diagnosing a bug, test failure, or unexpected behavior. Provides a systematic reproduce → isolate → hypothesize → fix → verify workflow.

Use when you need to search broadly across a codebase, explore multiple areas simultaneously, or parallelize independent research tasks using the Agent tool.

Use for any git operation — branching, merging, rebasing, conflict resolution, or understanding git state. Defines safety rules for destructive commands.

Use when a task has 5+ steps, spans multiple files, or requires architectural decisions. Creates a plan, saves it to the scratchpad, and waits for user approval before starting implementation.

Use when the user asks to commit changes. Runs parallel git status/diff/log, drafts a conventional commit message, stages files by name, and handles pre-commit hook failures.

Use when the user asks to create a pull request. Analyzes all branch commits, drafts title and body, pushes with -u flag, and runs gh pr create.

Use when the same error appears 3+ times, you're retrying commands with minor variations, or making no progress on a sub-problem. Forces a strategy change.

Track tasks during multi-step work. Each task is a separate scratchpad entry so updates are atomic and nothing gets dropped.

Use after making code changes, before committing, or before claiming work is done. Runs type-check → lint → test → build and fixes failures immediately.

Autonomous ML research agent that iteratively modifies training code, runs experiments, and tracks results.

Use when writing or debugging ra middleware hooks.

Use when adding a new LLM provider to ra.

Use when starting work on the ra codebase, navigating the source, or understanding how components connect.

Use before claiming work is complete, before committing, or before creating a PR.

Designs systems and evaluates architecture decisions. Use when planning new features, evaluating trade-offs, or reviewing system design.

Reviews and writes code for clarity, simplicity, and correctness. Use when writing new code, reviewing changes, or refactoring.

Systematically diagnoses bugs and unexpected behavior. Use when something is broken, tests fail, or behavior doesn't match expectations.

Breaks work into concrete steps before implementation. Use when starting a feature, refactor, or multi-step task.