Introducing rvue: Team Intelligence That Every AI Tool Auto-Discovers

AI coding assistants have changed how we write code. Whether you use Cursor, GitHub Copilot, Claude Code, Codex, Windsurf, or Gemini CLI, the same frustration keeps showing up: the code they generate is often correct but doesn’t match your team’s patterns. Naming, structure, error handling, and domain concepts drift from what your codebase and reviews have already established. We built rvue so every AI tool can auto-discover that team intelligence instead of you maintaining it in six different places.

The Problem: Great Code, Wrong Conventions

Tools like Cursor and Copilot are trained on huge amounts of public code. They’re good at syntax and common patterns, but they have no built-in view of your repo: how you name things, how you structure modules, which anti-patterns your team consistently flags in review, or how your domain entities relate. So you get valid code that still doesn’t fit. You end up either rewriting suggestions or copy-pasting instructions into each tool - and when you switch from Cursor to Claude Code or from Copilot to Windsurf, you start over. We dug into this in why AI tools ignore your team’s patterns; rvue is the fix.

What rvue Is

rvue is a single CLI that turns your team’s existing behavior into machine-readable intelligence that AI tools can discover on their own. One command inspects your codebase and PR history, runs an AI-backed analysis, and produces an Agent Skill plus an MCP server. Cursor picks it up from .cursor/skills/, Copilot from the Agent Skills spec, Claude Code, Codex, Windsurf, Gemini CLI, and any MCP client get the same context without separate config. If you’re new to the concept, what are Agent Skills explains the open standard we build on.

How It Works

From a repo with GitHub PR history, you run:

npx rvue-cli enable

rvue then (1) scans the codebase for structure and patterns, (2) fetches PR metadata and diff summaries from GitHub, (3) runs an AI analysis over that data, and (4) generates an Agent Skill file and an MCP server that expose the results. Cursor auto-discovers the skill from .cursor/skills/; other tools that support the Agent Skills spec or MCP do the same. No per-tool setup: one pipeline feeds Cursor, Copilot, Claude Code, Codex, Windsurf, Gemini CLI, and any other compatible client. For step-by-step setup, see getting started in our docs.

What Gets Extracted

The analysis produces three kinds of output, all derived from real code and review history rather than generic rules.

Conventions (with confidence)

Naming, file layout, preferred libraries, and stylistic choices are inferred from how the codebase and PRs actually look. Each convention gets a confidence score so the model can prefer high-signal rules (e.g. “we always use X for Y”) over weaker ones.

Anti-patterns (with severity)

Comments and review feedback in PRs are mined for recurring objections and “don’t do this” patterns. These are tagged with severity so high-impact issues (security, correctness) are weighted more than style nitpicks. That helps tools like Cursor and Claude Code avoid suggestions that your team would reject. For more on AI and code review, see our AI code review guide for 2026.

Domain knowledge (entity relationships)

Important types, modules, and their relationships are summarized so the AI understands your domain. That reduces “correct but generic” code and improves suggestions that match your architecture.

Works With 20+ Tools

We don’t lock you into one editor. The output is standards-based:

• Cursor discovers skills from .cursor/skills/ and uses them as context for completions and chat.
• GitHub Copilot can consume the same Agent Skill format (and agent skills spec) so your team intelligence applies there too.
• Claude Code, Codex, Windsurf, and Gemini CLI can use the generated skill file or query the MCP server for richer, real-time context.
• Any environment that supports the MCP protocol can call the rvue MCP server for on-demand conventions, anti-patterns, and domain knowledge.

So you configure team intelligence once; every tool that supports Agent Skills or MCP gets it. For a full walkthrough of configuring each tool by hand vs. using rvue, read how to make Cursor, Copilot, and Claude Code follow your team’s conventions.

Built on the Agent Skills Open Standard

rvue doesn’t invent a new format. We generate skills that conform to the Agent Skills open standard (agentskills.io). That means the same artifact can be read by any tool that implements the spec, and you’re not tied to rvue for consumption. The standard defines what goes in a skill (conventions, anti-patterns, domain knowledge, reviewer preferences) and how tools discover and load them. We go deeper on the spec in our Agent Skills docs and in the post on what Agent Skills are.

Getting Started

If your repo is on GitHub and has some PR history, you can go from zero to team-aware AI in a few minutes:

1. Run npx rvue-cli enable in the repo root and complete the one-time GitHub auth if prompted.
2. Commit the generated .cursor/skills/ (and any MCP config you use) so the whole team and CI benefit.
3. Use Cursor, Copilot, Claude Code, Codex, Windsurf, or Gemini CLI as usual; they’ll pick up the skill and MCP server according to their docs.

For full setup, CLI options, and MCP installation, see our docs and getting started. rvue is the bridge between your team’s real behavior and every AI coding tool that supports Agent Skills and MCP - one command, one standard, many tools.