Dev Skills & MCP Servers¶

Dev skills are modular commands that extend AI coding agents with specialized workflows for common development tasks. This page covers all available skills (internal and community-sourced) and the MCP servers integrated into the project.

How Skills Work¶

Skills live in .agents/skills/ and are agent-agnostic — any AI coding agent that supports the skill format can use them. For Claude Code specifically, .claude/skills/ is a symlink to .agents/skills/.

Each skill is a directory containing a SKILL.md file with YAML frontmatter (name, description, allowed-tools) and markdown instructions that teach the agent a specialized workflow.

Skill Sources¶

Source	Description	Examples
Internal	Built and maintained by the Rose team	`test-backend`, `pr-fix`, `config-system`
Community	Downloaded from the internet (e.g. via `/find-skills`)	`supabase-security`, `visual-explainer`, `skill-creator`

Internal Skills¶

Skills built and maintained by the Rose team.

Testing & Quality¶

Skill	Command	Description	Status
Test	`/test`	Router that delegates to test-backend or test-frontend	Needs review
Test Backend	`/test-backend`	Run Python tests with pytest, parse failures, fix issues	Needs review
Test Frontend	`/test-frontend`	Run TypeScript tests with Vitest, parse failures, fix issues	Needs review
Mypy	`/mypy`	Run mypy type checking, parse errors, apply fixes. Auto-triggers after Python edits	Active
Smoke	`/smoke`	Run backend smoke tests	Active

Workflow & Git¶

Skill	Command	Description
PR Fix	`/pr-fix`	Address PR review comments, make fixes, reply, and resolve threads
Create PR	`/create-pr`	Push and create a PR with a title derived from actual changes
Commit	`/commit`	Generate and create a commit from current changes
Solve Linear Ticket	`/solve-linear-ticket`	Implement Linear issues systematically with task tracking
Client-Facing Changelog	`/client-facing-changelog`	Generate changelog entries from recent git history for clients

Browser Integration¶

Skill	Command	Description
Browse Playground	`/browse-playground`	Access preprod-ui via Playwright (port 3001)
Browse Demo Page	`/browse-demo-page`	Access widget demo page via Playwright (port 8083)
Browse Backoffice	`/browse-backoffice`	Access client-backoffice via Playwright (port 3002)

Agent Skills (Client Configuration)¶

Skill	Command	Description
Create Client Skills	`/create-client-skills`	Onboard a new client: analyze needs, create skills, build eval dataset
Fix Client Skills	`/fix-client-skills`	Diagnose and fix agent behavior for existing clients
Prompt Engineering	`/prompt-engineering`	Systematic prompt fix workflow: reproduce, fix, verify, prevent regressions

Platform & Config¶

Skill	Command	Description
Config System	(auto)	Unified config system workflow — add properties, create slugs, run codegen
Debug GCloud	`/debug-gcloud`	Fetch and analyze Cloud Run production logs by session_id

Community Skills (Downloaded from Internet)¶

Skills installed from the open skill ecosystem via /find-skills or manual download. These are maintained by third-party authors.

Code Intelligence (GitNexus)¶

Skill	Command	Description
GitNexus Exploring	(auto)	Understand architecture, trace execution flows
GitNexus Debugging	(auto)	Trace bugs through the knowledge graph
GitNexus Impact Analysis	(auto)	Blast radius analysis before editing code
GitNexus Refactoring	(auto)	Safe multi-file renames and code moves
GitNexus Guide	(auto)	Reference for GitNexus tools, schema, and resources
GitNexus CLI	(auto)	Run `npx gitnexus analyze`, `status`, `wiki`

Frontend & UI¶

Skill	Command	Description	Author
Baseline UI	`/baseline-ui`	Enforces typography, animation, accessibility, layout constraints in Tailwind	—
Fixing Motion Performance	`/fixing-motion-performance`	Fix animation jank, layout thrashing, compositor issues	—
Implement Design	`/implement-design`	Translate Figma designs into production code (requires Figma MCP)	—
Vercel React Best Practices	(auto)	React/Next.js performance optimization guidelines	Vercel
TanStack Query	`/tanstack-query`	TanStack Query v5 patterns, migration guide, SSR/hydration	—

Sentry Integration¶

Skill	Command	Description
Sentry Fix Issues	`/sentry-fix-issues`	Find and fix production issues using Sentry MCP
Sentry React Setup	`/sentry-react-setup`	Install and configure `@sentry/react`
Sentry Setup Logging	`/sentry-setup-logging`	Configure Sentry structured logging (JS, Python, Ruby)
Sentry Setup Tracing	`/sentry-setup-tracing`	Configure Sentry performance monitoring

Supabase¶

Skill	Command	Description	Author
Supabase Security	(auto)	RLS policies, auth hardening, API security, production checklist	Supabase
Supabase Postgres Best Practices	(auto)	Query optimization, schema design, connection management	Supabase

Meta & Tooling¶

Skill	Command	Description	Author
Skill Creator	`/skill-creator`	Guide for creating new skills with proper structure	—
Find Skills	`/find-skills`	Discover and install skills from the open ecosystem	—
Visual Explainer	`/visual-explainer`	Generate self-contained HTML pages for diagrams and data tables	nicobailon
Architecture Review	`/architecture-review`	Review code against SOLID, DRY, KISS, coupling/cohesion	—
Claude MD Improver	`/claude-md-improver`	Audit and improve CLAUDE.md files across a repo	—

MCP Servers¶

MCP (Model Context Protocol) servers provide Claude with external tool integrations. They are configured in .mcp.json (project-level) and ~/.claude.json (global).

Active MCP Servers¶

Server	Type	Purpose	Configuration
Linear	HTTP	Issue tracking — read/create/update issues, comments, statuses	`https://mcp.linear.app/mcp`
Playwright	stdio	Browser automation — navigate, click, fill forms, screenshots, E2E testing	`npx @playwright/mcp@latest`
GitNexus	stdio	Code intelligence — query knowledge graph, impact analysis, rename tracking	`npx gitnexus mcp`
Sentry	HTTP	Error tracking — read issues, stack traces, breadcrumbs, traces	`https://mcp.sentry.dev/mcp`
Figma	HTTP	Design files — read Figma nodes, extract design tokens, inspect components	`https://mcp.figma.com/mcp`

Server Configuration¶

MCP servers are defined in two places:

Project-level (.mcp.json): Servers specific to this repo. Currently configures Linear, Figma, Sentry, Playwright, and GitNexus.
Global (~/.claude.json): Servers available across all projects. Currently configures Linear globally.
Enabled servers (.claude/settings.json): The enabledMcpjsonServers array controls which .mcp.json servers are active. Currently: linear-server, figma.

How Skills Use MCPs¶

Several skills depend on MCP servers to function:

Skill	Required MCP	Usage
Solve Linear Ticket	Linear	Fetch issues, update status, add comments
Browse Playground/Demo/Backoffice	Playwright	Navigate browser, interact with UI, take screenshots
Sentry Fix Issues	Sentry	Read production errors, stack traces, breadcrumbs
Implement Design	Figma	Read design files, extract component specs
GitNexus skills	GitNexus	Query code knowledge graph, impact analysis

Adding a New MCP Server¶

Add the server config to .mcp.json:

{
  "mcpServers": {
    "my-server": {
      "type": "http",
      "url": "https://mcp.example.com/mcp"
    }
  }
}

For stdio servers:

{
  "mcpServers": {
    "my-server": {
      "type": "stdio",
      "command": "npx",
      "args": ["my-mcp-package"]
    }
  }
}

If the server should be active by default, add it to enabledMcpjsonServers in .claude/settings.json.

Detailed Skill Reference¶

PR Fix¶

Automates addressing pull request review feedback: analyze comments, make fixes, reply to explain changes, resolve threads, and commit.

Usage:

/pr-fix          # Auto-detect PR from current branch
/pr-fix 123      # Use specific PR number

What it does:

Fetches unresolved review threads via GitHub GraphQL API
Analyzes and categorizes each comment (code change, docs, question, disagree)
Reads relevant files and makes fixes
Replies to each comment explaining what was changed
Resolves the thread
Creates a single commit with all fixes

Notes:

Does NOT push automatically - review changes before pushing
Asks for user confirmation on disagreements (never auto-resolves)
Requires gh CLI to be authenticated

Test¶

Router skill that delegates to test-backend or test-frontend.

Usage:

/test backend          # Run backend tests
/test frontend         # Run frontend tests
/test unit             # Run backend unit tests (auto-routes)
/test smoke            # Run backend smoke tests (auto-routes)
/test coverage         # Run frontend tests with coverage (auto-routes)
/test path/to/test.py  # Run specific backend test (auto-routes)

If no arguments provided, asks which to run.

Test Backend¶

Run Python tests with pytest, parse failures, fix issues, and verify resolution.

Usage:

/test-backend              # Run unit tests (default)
/test-backend unit         # Run unit tests
/test-backend integration  # Run integration tests
/test-backend smoke        # Run smoke tests
/test-backend evaluation   # Run evaluation tests
/test-backend all          # Run all tests (excludes evaluation)
/test-backend path/to/test.py  # Run specific file

What it does:

Runs appropriate pytest command (just test, just unit, just smoke, etc.)
Parses failures (test name, error type, traceback)
Categorizes issues (mock, import, type, assertion, async, fixture)
Applies fixes based on confidence level
Re-runs individual tests to verify
Runs full suite for final verification

Critical rules enforced:

Uses mocker fixture, NEVER unittest.mock
Never skips tests - fixes the issue instead
All async tests must have @pytest.mark.asyncio

Test Frontend¶

Run TypeScript tests with Vitest, parse failures, fix issues, and verify resolution.

Usage:

/test-frontend              # Run all tests
/test-frontend coverage     # Run with coverage
/test-frontend watch        # Watch mode
/test-frontend e2e          # E2E tests with Playwright
/test-frontend path/to/file.test.ts  # Run specific file

What it does:

Runs appropriate vitest command (just test, etc.)
Parses failures (test name, error type, traceback)
Categorizes issues (import, type, assertion, mock, async)
Applies fixes based on confidence level
Re-runs individual tests to verify

Critical rules enforced:

Uses logger from shared utils, NEVER console.log
Tests use Vitest, NOT Jest
Run tests from frontend/ directory

Mypy (Typecheck Python)¶

Run mypy type checking on Python files, parse errors, apply fixes, and verify resolution.

Auto-triggers when:

User mentions "mypy" or "type error"
User asks to fix typing issues
Mypy output is pasted showing errors
After ANY edit to Python files (mandatory)

Usage:

/mypy                          # Fix errors in recently edited files
/mypy packages/ixchat          # Check a package
/mypy path/to/file.py          # Check specific file

Common fixes:

Missing Optional[] wrappers
Type narrowing with assert or if
Adding return type annotations
Import errors for known modules

Solve Linear Ticket¶

Systematically implement Linear issues by working through TODO subissues with structured task tracking.

Usage:

/solve-linear-ticket IX-1151          # Use issue identifier
/solve-linear-ticket https://linear.app/.../IX-1151  # Use full URL

What it does:

Fetches parent issue and all TODO subissues via Linear MCP
Creates hierarchical task structure with dependencies
For each subissue, executes 7 steps: fetch → analyze → impl → test → visual → commit → linear
Downloads attachments/images using linearis CLI
Commits changes with Linear issue reference
Updates Linear status to "In Review" and adds implementation comment
Creates summary of all completed work

Requirements:

Linear MCP server configured
linearis CLI installed (for attachments)
gh CLI authenticated (for commits)

Browse Skills (Playwright Integration)¶

Three skills for accessing different UIs via Playwright MCP. All require Playwright MCP server to be active.

Browse Playground¶

Access preprod-ui for testing widget changes.

/browse-playground                 # Open localhost:3001
/browse-playground /ai-sections-test  # Navigate to specific page
/browse-playground chat "Hello"    # Type in chat widget
/browse-playground screenshot      # Take screenshot

Port: 3001 | Start: cd frontend/preprod-ui && just dev

Browse Demo Page¶

Access widget demo page for testing widget builds.

/browse-demo-page                  # Open localhost:8083/demo.html
/browse-demo-page rebuild          # Rebuild widget + demo, then refresh
/browse-demo-page rebuild-sections # Rebuild AI Sections only
/browse-demo-page screenshot       # Take screenshot

Port: 8083 | Start: cd frontend/widget && just dev

Rebuild commands:

Scenario	Command
Any code change	`just rebuild` (server stays running)
AI Sections only	`npx vite build --config vite.sections.config.ts`
Server not running	`just dev` (builds + starts server)

Browse Backoffice¶

Access client-backoffice for admin panel testing.

/browse-backoffice                 # Open localhost:3002
/browse-backoffice /sites          # Navigate to sites list
/browse-backoffice find "Edit"     # Find element on page
/browse-backoffice screenshot      # Take screenshot

Port: 3002 | Start: cd frontend/client-backoffice && just dev

Config System¶

Auto-triggered skill that guides Claude through the unified config system workflow when editing schemas or working with ixconfig.

Auto-triggers when:

Editing JSON schema files in schemas/configs/
Working with the ixconfig package or ConfigResolver
Mentioning "config", "schema", "x-feature", "x-access", "codegen"

What it provides:

Workflow A — Add a property to an existing config (edit schema, codegen, mypy)
Workflow B — Create a new config slug (schema, validate, codegen, migration, check-slugs)
Schema template with all required fields
Key commands reference (just validate, just codegen, just list, just check-slugs)

Key rules enforced:

Never edit *_generated.py or *.generated.ts — run just codegen instead
Schema "$id" must match the filename stem
Schema "default" must be a JSON object
Always run just codegen then just mypy packages/ixconfig after schema edits

Related docs: Config System

Debug GCloud¶

Fetch and analyze Cloud Run production logs for a given session_id.

Usage:

/debug-gcloud session_pennylane.com_1771033548702_cy46t7

What it does:

Parses session_id from arguments
Queries GCloud Logging API for structured JSON logs filtered by session_id
Presents logs with timestamps, severity, and relevant context

Requirements:

gcloud CLI authenticated with access to the GCP project

Adding New Skills¶

Installing from the Internet¶

Use /find-skills to discover community skills:

/find-skills supabase          # Search for Supabase-related skills
/find-skills "visual diagram"  # Search by description

Skills are installed into .agents/skills/<skill-name>/SKILL.md.

Creating Internal Skills¶

Each skill needs a SKILL.md file in .agents/skills/<skill-name>/:

---
name: my-skill
description: When to trigger this skill and what it does
allowed-tools:
  - "Bash(just test **)"
  - "Edit(backend/**/*.py)"
---

# My Skill

Instructions for the workflow...

Use /skill-creator for guided skill creation. See the Prompt & Skill Workflow for the full development and testing process.