Skip to main content
plugin

meticulous — Claude Code plugin: what it does, how to install

Connects Meticulous visual regression testing workflows and hosted MCP server to Claude Code. It inspects UI diffs, reviews CI runs, and fixes rejected visual snapshots in chat.

ISC ★ 10 updated 2026-10-22

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add anthropics/claude-plugins-community
/plugin install meticulous@claude-community
Open on GitHub

What meticulous does

This plugin links Claude Code directly to the Meticulous frontend testing service and connects its hosted MCP server at https://app.meticulous.ai/api/mcp. It packages specialized tasks as slash commands under the /meticulous: namespace. The agent can trigger test runs after frontend edits, inspect visual diffs, and classify changes as expected or unintended.

Workflows cover specific testing jobs. meticulous-zero-diff-task runs an iterative loop for refactors or dependency upgrades where the UI must stay intact. Another skill, meticulous-fix, takes rejected test runs and updates component code according to review notes. Without completing browser authentication, the MCP connection will not answer queries.

What it helps with

  • review visual diffs on pull requests against expected design changes
  • fix rejected visual snapshots based on reviewer comments
  • verify UI stability during refactoring or dependency upgrades
  • expand test coverage by mapping under-covered files to recorded UI actions

Example prompts for the agent

  • /meticulous:meticulous-review check the latest CI run and report any visual regressions
  • /meticulous:meticulous-fix resolve the rejected diffs on the checkout modal
  • /meticulous:meticulous-zero-diff-task upgrade tailwindcss and ensure no visual changes occur

How to install meticulous

Plugin marketplace

/plugin marketplace add anthropics/claude-plugins-community
/plugin install meticulous@claude-community

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about meticulous

How to install meticulous in Claude Code?

Run /plugin marketplace add anthropics/claude-plugins-community followed by /plugin install meticulous@claude-community. After installation, open /mcp and authenticate the hosted Meticulous MCP server.

What does the meticulous plugin do?

It provides Claude Code with structured skills to interact with Meticulous test runs. The agent can inspect visual regressions, fix broken layouts, and verify zero-diff refactoring tasks.

Is an account or authentication required?

Yes, the plugin connects to a hosted MCP server that requires authentication. You can sign in via your browser using the /mcp command in Claude Code or via meticulous auth login using the CLI.

Source text

SKILL.md · ISC
# Meticulous Agent Skills

A collection of agent skills for [Meticulous](https://meticulous.ai) — the automated visual regression testing platform for web frontends.

These skills enable AI coding assistants (Cursor, Claude Code, etc.) to use Meticulous: review test runs, investigate replays, debug diffs, etc.

## Setup

Full setup instructions live in the Meticulous docs: **[app.meticulous.ai/docs/agents/setup](https://app.meticulous.ai/docs/agents/setup)**. They cover installing the CLI, authenticating, and installing these skills.

The short version:

```bash
# 1. Install/update the Meticulous CLI
npm install --global @alwaysmeticulous/cli@latest

# 2. Authenticate (opens a browser to sign in and pick a default project)
meticulous auth login

# 3. Install these skills into your project
npx skills add alwaysmeticulous/skills --skill "*" --agent claude-code --agent codex --agent cursor -y
```

### Claude Code plugin

This repository is also packaged as a [Claude Code plugin](https://code.claude.com/docs/en/discover-plugins), which installs all the skills below (namespaced as `/meticulous:<skill-name>`) and automatically connects the hosted [Meticulous MCP server](https://app.meticulous.ai/api/mcp). To install, run in Claude Code:

```shell
/plugin marketplace add alwaysmeticulous/skills
/plugin install meticulous@meticulous
```

Then type `/mcp` and choose **Authenticate** for the Meticulous MCP server (login happens in your browser; not needed if you already authenticate via `meticulous auth login` for the CLI).

### Codex plugin

This repository is also packaged as a [Codex plugin](https://developers.openai.com/codex/plugins), which installs all the skills below and automatically connects the hosted [Meticulous MCP server](https://app.meticulous.ai/api/mcp). To install, run:

```bash
codex plugin marketplace add alwaysmeticulous/skills
codex plugin add meticulous@meticulous
```

Then run `codex mcp login meticulous` to authenticate the MCP server (login happens in your browser). To pick up later changes, run `codex plugin marketplace upgrade meticulous`.

### Cursor Marketplace

This repository is also packaged as a [Cursor plugin](https://cursor.com/docs/plugins). Once listed in the Cursor Marketplace, Cursor users can install Meticulous skills from **Customize → Plugins** (or search the marketplace) without using `npx skills`. The `npx skills` flow above remains the recommended path when you need the same skills across multiple agents.

## Skills

Skills are Markdown files that provide AI coding assistants with domain-specific knowledge and step-by-step workflows. When an agent reads a skill, it gains targeted expertise for a specific task — without needing that context baked into every conversation.

Skills follow the [`SKILL.md` format](https://docs.cursor.com/context/rules-for-ai) used by Cursor and Claude Code.

| Skill                                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Review skills**                                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [`meticulous-review`](skills/meticulous-review/SKILL.md)                       | Work through a Meticulous test run's results, reacting to their review state — review the unreviewed diffs against what the PR is meant to change and flag potential regressions; when you're working on the PR's code, hand what needs fixing to `meticulous-fix`. Use whenever a run's results matter: reviewing a pull/merge request, right after pushing a frontend change, when its Meticulous CI check is failing or pending, or when asked to look at Meticulous results.     |
| [`meticulous-fix`](skills/meticulous-fix/SKILL.md)                             | Fix the visual diffs that have been reviewed and rejected on a test run, following their review comments if given. Use when a user has reviewed the results of a test run and is handing off to an agent to implement the fixes, or when `meticulous-review` hands off what needs fixing.                                                                                                                                                                                            |
| [`meticulous-test`](skills/meticulous-test/SKILL.md)                           | Run a Meticulous test run after implementing a frontend change, then hands off to the `meticulous-review` skill to classify each visual change as intended or unintended.                                                                                                                                                                                                                                                                                                            |
| [`meticulous-zero-diff-task`](skills/meticulous-zero-diff-task/SKILL.md)       | Implement a task for which no visual diffs are expected end to end, using Meticulous as the loop you iterate against until the diff is clean, then open a PR. Use when the task's whole premise is "the UI shouldn't change" — a dependency/version upgrade, a code refactor, a migration, or similar.                                                                                                                                                                               |
| [`meticulous-increase-coverage`](skills/meticulous-increase-coverage/SKILL.md) | Increase coverage for a Meticulous project by tracing specific under-covered files back to a real UI action in the codebase, driving that action with a real recorded browser session, and validating the improvement with a clean coverage comparison. Also opens a PR proposing `.meticulousignore` entries for code that structurally never executes in-browser. Use when asked to "increase coverage", "find untested code", or "add `.meticulousignore` entries" for a project. |
| [`meticulous-iterative-dev`](skills/meticulous-iterative-dev/SKILL.md)         | Iterative frontend development loop using Meticulous for per-step visual validation. Use when implementing a multi-step frontend change and want to catch visual regressions and unintended side effects at each step, before the final cloud test run.                                                                                                                                                                                                                              |
| [`meticulous-simulate-and-diff`](skills/meticulous-simulate-and-diff/SKILL.md) | Run a Meticulous session simulation against a live URL and analyze the visual output — either by inspecting screenshots directly (quick-check mode) or by comparing pixel and HTML diffs against a base replay. Use when checking whether a code change has introduced visual regressions for a specific session.                                                                                                                                                                    |
| [`meticulous-use-session-data`](skills/meticulous-use-session-data/SKILL.md)   | Download and use structured Meticulous session data (user flows + network mocks) for testing code changes locally. Use when you need to understand what user interactions and API calls a test covers, or when you want network mocks for writing tests.                                                                                                                                                                                                                             |
| [`meticulous-improve-test-env`](skills/meticulous-improve-test-env/SKILL.md)   | Work out what to change in a project's test environment so Agent swarm stops getting blocked when it tests against a live backend — seed better test data, widen the test user's permissions, enable feature flags, fix test login. Reads the setup blockers Agent swarm has recorded, inspects the codebase and test-environment configuration, and proposes concrete fixes.                                                                                                        |
| **Supporting skills**                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [`meticulous-cli`](skills/meticulous-cli/SKILL.md)                             | Overview of the Meticulous CLI tool and its global options. Use when asking about the meticulous CLI in general, available commands, or global flags that apply to all commands.                                                                                                                                                                                                                                                                                                     |
| [`meticulous-cli-update`](skills/meticulous-cli-update/SKILL.md)               | Check whether the Meticulous CLI (@alwaysmeticulous/cli) and skills are installed and up to date, and install/update them if not. Invoked at the start of every other Meticulous skill, since the CLI and skills are under active development with frequent changes and improvements.                                                                                                                                                                                                |

## Contributing

All Markdown, JSON and YAML in this repository is formatted with
[oxfmt](https://www.npmjs.com/package/oxfmt), and CI enforces it:

```bash
pnpm install
pnpm format        # format in place
pnpm check-format  # what CI runs
```

This isn't only about house style. Skills from this repository get installed
into other repositories (via `npx skills add`), some of which run oxfmt over
their whole tree — including the installed skill files. If a skill isn't
already oxfmt-clean at the source, their formatter rewrites it on the way in,
the installed copy no longer matches the upstream hash recorded in
`skills-lock.json`, and every subsequent `npx skills update` there fights the
formatter. Keeping the source formatted the same way avoids that entirely, so
`.oxfmtrc.json` here mirrors the settings used in the repositories these skills
are consumed from (notably `printWidth: 80`).

## License

[ISC](LICENSE) © Meticulous, Inc.

© Meticulous · ISC · alwaysmeticulous/skills

Similar plugins

All plugins for Testing and QA →

From the same set12

The whole set →
meticulous-iterative-dev meticulous-iterative-dev runs a frontend change step by step and replays recorded Meticulous sessions after each one, so a visual regression shows up where it started. CX Codex +1 9,100installs meticulous-simulate-and-diff meticulous-simulate-and-diff simulates recorded Meticulous sessions against an active application URL to detect visual UI regressions and changes in DOM structure. CX Codex +1 9,100installs meticulous-review meticulous-review reviews Meticulous results against the intended PR change, including visual diffs and failed non-visual checks. Use it after frontend pushes or when CI needs review. CX Codex +1 9,100installs meticulous-use-session-data meticulous-use-session-data — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI and OpenCode that downloads structured Meticulous session data — recorded user flows and network mocks. CX Codex +1 9,000installs meticulous-fix meticulous-fix applies fixes for rejected Meticulous visual diffs and failing checks. Use it after a test run has been reviewed. CX Codex +1 5,100installs meticulous-zero-diff-task meticulous-zero-diff-task drives frontend refactors and dependency upgrades toward zero visual regressions using the Meticulous test loop before you open a PR. CX Codex +1 5,000installs meticulous-increase-coverage meticulous-increase-coverage — a Meticulous skill that traces under-covered files to a real UI action, drives it with a recorded browser session and proves the coverage gain against a baseline. CX Codex +1 3,000installs meticulous-improve-test-env meticulous-improve-test-env — a skill for Claude Code that investigates why Agent swarm gets blocked on live backends. It checks missing seed data, test user permissions, auth errors, and feature flags. CX Codex +1 129installs

Project sponsors

Companies that keep this analytics open