Best Playwright Skills and Plugins for AI Coding Agents

TL;DR

This article ranks the agent skills and plugins that give coding agents Playwright know-how. It judges them on what a team running Playwright Test in CI needs: current practice, fixing tests, CI and scale, whether the agent ends up with specs or one-off browser scripts, and which agents each one works in.

If your team runs Playwright Test in CI and wants agents to follow current practice and fix flaky failures from real run data, start with Currents: its skill covers practice, fixing and CI scale, and its MCP skill reads the failed run's steps and trace before it changes anything. Add Playwright CLI skills when you also want the agent to debug interactively. Claude Code teams starting from zero should look at Playwright Pro, and you can use Playwright MCP to explore live pages from an MCP client.

1. If your team runs Playwright Test in CI and wants agents to follow current practice and fix flaky failures from real run data, start with Currents.
2. Add Playwright CLI skills when you also want the agent to debug interactively: run the test with --debug=cli, drive the paused browser, and paste the printed TypeScript back into the spec.
3. If you're a Claude Code team starting from zero, look at Playwright Pro, which scaffolds the config, the CI setup and a first test.
4. For a light review guard on agent-written specs, use Playwright Agent Skills.
5. Use Playwright MCP to explore live pages from an MCP client.

Hand a coding agent a Playwright task with no Playwright guidance, and the test it writes tends to include waitForTimeout calls. Playwright's API docs are blunt about why that fails: tests that wait for time are inherently flaky, and locator actions and web assertions already wait on their own.

The selectors are the second problem. Unguided agents reach for brittle CSS selectors. Playwright's best practices warn that tests tied to DOM structure, such as a button selected by its CSS classes, can fail when the DOM changes. So the suite the agent hands you can fail when the markup changes, in code nobody on the team wrote.

None of this shows up in the chat. The test passed once on the agent's machine and the agent reported success.

Playwright's own CLI skills teach coding agents how to use playwright-cli, providing structured reference documentation that agents can discover and use. The hard part is picking one that leaves you with specs your CI keeps instead of a folder of one-off browser scripts.

How we picked

Install counts tell you which skills are popular, not which ones keep a suite green. So this list ranks by fit for a team running Playwright Test in CI.

In Anthropic's format, each skill is a folder whose SKILL.md file holds the instructions and metadata Claude uses. We looked only at Playwright-specific skills and plugins, plus the Playwright MCP server. General TDD and lifecycle skills are out, because the question here is what the agent knows about Playwright.

For each entry we name the route: how the agent runs Playwright through it. Playwright Test is a full-featured test runner built for end-to-end testing. Through Playwright CLI the agent runs shell commands, while through MCP the LLM calls MCP tools with structured parameters. We've also compared MCP, the CLI and the built-in agents on the same suite if you want to see the routes side by side. Then we judged each entry on five criteria:

Specs or scripts is the criterion that separates skills that drive a browser from skills that keep a suite stable.

The baseline comes with Playwright out of the box. Playwright ships three built-in Test Agents: planner, generator and healer. You add their definitions with the init-agents command, and the docs say to regenerate them whenever Playwright is updated, to pick up new tools and instructions. Every entry below has to add something to that.

One more thing to weigh: a skill helps only as far as the agent reads it. In one report, the agent ran the wrong command after the Playwright CLI skills were installed (#42135). A contributor found it had read only lines 1-260 of the skill file, while the installation note was at line 343. The reporter later found that another model used the right command from the start. The issue was closed as not planned. Keep the instructions that matter near the top of any skill you write or fork.

Currents

Currents is our product, and its entry here is the Playwright best practices agent skill. The skill targets what agents write without guidance: waitForTimeout calls, brittle CSS selectors and retries that hide real bugs. It teaches Playwright practice instead: locators, web-first assertions, debugging flaky tests, CI setup and more.

How the agent gets it

The agent loads the skill on its own when a task involves Playwright, so you don't name it in the prompt. The skill works in Claude Code, Cursor, VS Code, Gemini CLI and other agents that read skills.

The CI side comes through the Currents MCP server. Currents hosts that server, and a connected agent reads your runs, test results, failure evidence and analytics, then acts on them, for example by quarantining a flaky test. An agent connected to the server gets its skills along with the tools, with nothing to install. Claude, Cursor, Codex, ChatGPT, editors and any other MCP client can connect.

Practice, structure and scale

The skill's coverage goes past locators and assertions into test structure: the Page Object Model, fixtures, and global setup and teardown. Structure is where an agent's shortcuts spread across a suite instead of staying in one file.

For CI and scale, it covers projects, dependencies, parallel runs and sharding. An agent that edits your config should know how your suite is split across machines.

Fixing failing tests

The Currents MCP server's fix-failing-tests skill starts from a real failed run. It finds the run, reads each failure with its steps and trace, fixes the cause, runs the test again and asks before it commits. The best practices skill backs that up with its own coverage of flaky tests, timeouts in CI and debugging failures. The failure context also opens in Claude, Claude Code, Codex, Conductor, Cursor, GitHub Copilot or Zed.

Next to Playwright's built-in planner, generator and healer, that failed CI run is what this entry adds.

Anti-pattern

Fixing CI failures from the log

A build goes red, and someone pastes the CI log into the agent. Working from the log alone, the agent often adds a wait, loosens the assertion or retries until the test passes. The build goes green. The bug stays in the code.

Fix

Give the agent the failure's steps and trace, not just the log. With the failure context from Currents, the agent finds the cause in the app or in the test, fixes it and runs the test again to check the fix.

Who it fits

It fits teams that run Playwright Test in CI and want agents to write tests the way the team would, then fix the failures CI produced. Pick something else if all you want is an agent that pokes at a page once. It meets every criterion this list judges in one tool (current practice, fixing tests, CI scale, spec output and agent support) and adds the failure context of real CI runs, which is why it comes first here.

Playwright CLI skills

Playwright CLI skills teach coding agents to use playwright-cli, giving them structured reference documentation they can discover and use. One of the bundled reference guides covers planning, generating and healing tests, the three jobs Playwright's built-in planner, generator and healer are named for. The built-in agents are definitions you add with init-agents and regenerate whenever Playwright is updated. The CLI skills give the agent playwright-cli commands to do those jobs with.

The difference shows in repair. The agent runs an existing test with --debug=cli in the background, where the test stays paused and holds the browser open. Every playwright-cli action the agent takes prints the equivalent Playwright TypeScript, and the agent pastes that back into the test as the fix. Most of the time the fix is an updated locator or expectation, though the docs note it can also be a genuine bug in the app. That paused test is the reason to add these skills next to the built-in healer.

The generate step ends in test files too: the agent replays a spec step by step and collects the generated code into test files. That code prefers role-based locators, which survive markup changes far better than CSS selectors.

The CLI's prerequisites list a coding agent such as Claude Code or GitHub Copilot. It fits teams that want official, command-level control of the browser while they write and repair specs. Pick something else if your agent won't drive a browser. The skills' stated job is teaching the agent to use playwright-cli.

Playwright Expert

Playwright Expert is a skill for writing Playwright end-to-end tests, setting up test infrastructure and debugging flaky browser tests. Its description lists the jobs it can be invoked for: test scripts, page objects, test fixtures, reporters, CI integration, API mocking and visual regression testing.

The agent writes Playwright Test code. The skill's Page Object Model example imports the Page and Locator types from @playwright/test.

Its example finds a button by its role and accessible name, then waits for it to become visible. That's the habit you want an agent to copy.

It fits Claude Code users who want one skill to cover writing, infrastructure and flaky-test work in a single Playwright persona. Pick something else if you want a project dedicated to Playwright. The repository describes itself as a collection of 67 specialized skills that turn Claude Code into an expert pair programmer, and Playwright Expert is one of them.

Playwright Pro

Playwright Pro calls itself a production-grade Playwright testing toolkit for AI coding agents. It installs as a plugin with claude plugin install pw@claude-skills.

The setup command detects the project's framework and generates a Playwright config, a CI setup and a first test. Next to Playwright's built-in planner, generator and healer agents, that scaffolding is the part of Playwright Pro we'd reach for first.

For failures, /pw:fix uses the agent's /debug for trace analysis alongside Playwright-specific diagnostics. Its compatibility table gives Claude Code full plugin support: slash commands, MCP tools, hooks and agents.

It fits Claude Code teams that want Playwright work behind slash commands, whether they're scaffolding a new suite or fixing failures in an existing one. Pick something else if you want a lighter footprint than a full plugin.

Playwright Agent Skills

Playwright Agent Skills describes itself as Playwright skills for writing, reviewing and debugging reliable end-to-end tests. In practice it is a small, opinionated set of reusable prompts for writing and reviewing Playwright tests, and each skill stays focused on one job so agents can apply the right standard.

Its README says that left unguided, agents tend to reach for brittle selectors and hard waits, and its playwright-core skill steers them toward the pattern Playwright's own docs recommend. The README's example of that pattern is a test block that takes { page }, which tells Playwright Test to set up the page fixture.

Next to the built-in generator, use Playwright Agent Skills as the reviewer. Its prompts cover reviewing Playwright tests as well as writing them.

It fits teams that want a light review guard on agent-written specs without adopting a larger toolkit. Pick something else if you want a large reference library for the agent to browse. The repository calls its prompts a small, opinionated set.

Playwright MCP

Playwright MCP sits in a different category from the skills here. A skill is instructions the agent reads; an MCP server is tools the agent calls.

Playwright MCP is a Model Context Protocol server that gives LLMs browser automation through Playwright. It works from structured accessibility snapshots instead of screenshots, so no vision model is needed.

You install the Playwright MCP server with your agent's MCP client. We cover how Playwright MCP drives a browser and where it fits in CI in its own post. Playwright MCP works with VS Code, Cursor, Windsurf, Claude Desktop and other MCP clients, and the README gives a Codex CLI command for adding it. Next to the built-in agents, we'd use Playwright MCP from the MCP clients that aren't coding agents, such as Claude Desktop.

It fits agents and editors that speak MCP and need to interact with live pages, such as exploring a flow before anyone writes a test. Pick something else for test authoring in a coding agent. The README itself says that if you're using a coding agent, you might benefit from a CLI-plus-skills setup instead of the MCP interface.

Playwright Skill

Playwright Skill is an Agent Skill that lets coding agents write and run Playwright automation on the fly, from simple page tests to complex multi-step flows. It is also packaged as a Claude Code plugin for easier installation.

Ask the agent to test or automate a browser task, and it writes custom Playwright code, runs it and returns results with screenshots and console output.

The skill is meant for when the agent needs a real Playwright program: loops, assertions, multiple contexts, network interception, screenshots, video, or a script you want to keep and rerun. Next to the built-in agents, Playwright Skill is for the jobs that need a standalone program rather than a test. Its README says Agent Skills are supported by Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, OpenCode and other clients.

It fits developers who want an agent to check a page or a flow on demand. The skill is for automation the agent writes and runs on the fly.

Anti-pattern

Agent scripts as the regression suite

The agent's script ran once and passed, so it gets committed next to the specs and counted as coverage. Those scripts are custom Playwright code the agent writes and runs itself. Nothing in the pipeline runs them, and nothing reports on them.

Fix

Use the skill for exploration, and keep regression coverage in specs. When a script finds something worth guarding, rewrite it as a test the runner owns.

webapp-testing

webapp-testing is a toolkit for interacting with and testing local web apps through Playwright. It supports verifying frontend behavior, debugging UI behavior, capturing browser screenshots and viewing browser logs.

Anthropic's skills repository contains Anthropic's implementation of skills for Claude. Like every skill there, webapp-testing sits in its own folder with a SKILL.md file.

Many of the repository's skills are open source under Apache 2.0. That makes the repository a readable model of how to build a skill. Next to the built-in agents, webapp-testing is worth reading more than installing.

It fits Claude users who want quick checks of a local app, and anyone writing their own skill who wants a reference layout. Pick something else for production suites. The repository presents its skills as being for demonstration and educational purposes only.

At a glance

Read the route column first: it tells you whether the agent ends up with specs or with scripts.

How to choose

Start from what your suite needs, not from what the agent can do in a browser. For a team running Playwright Test in CI that wants agents to follow current practice and fix flaky failures from real run data, start with Currents. Its skill covers practice, fixing and CI scale, and its MCP skill reads the failed run's steps and trace before it changes anything.

Add Playwright CLI skills when you also want the agent to debug interactively: run the test with --debug=cli, drive the paused browser, and paste the printed TypeScript back into the spec. Practice guidance and a driving tool don't overlap, so the two sit side by side.

Outside that path, your situation picks the tool. Claude Code teams starting from zero should look at Playwright Pro, which scaffolds the config, the CI setup and a first test. Playwright Expert suits Claude Code users who want one skill for writing, infrastructure and flaky-test work. For a light review guard on agent-written specs, Playwright Agent Skills is enough.

The browser-side picks are simpler. Use Playwright MCP to explore live pages from an MCP client, and Playwright Skill for one-off checks of a page or flow. Read webapp-testing when you want to learn how skills are built.

If you want no third-party code at all, Playwright's built-in planner, generator and healer are the baseline, regenerated with init-agents whenever Playwright is updated. Our strategies for getting more out of Playwright Test Agents start from there.

Anti-pattern

Expecting specs from a browser skill

A team installs a skill that drives a browser, asks the agent for tests, and gets scripts the agent ran once. Playwright Test only runs files that match its testMatch pattern, which by default means files with a .spec or .test suffix.

Fix

Check what the skill produces before you adopt it. If the output isn't @playwright/test specs, keep that skill for exploration and pick a different one for the suite.

Before it reaches CI

Whatever you install, check what it writes to your repository and what it lets the agent run. Add the agent's output directories to your gitignore file before the first trace lands in a commit. Treat a skill as a convenience, not a sandbox.

Frequently asked questions

What are the best Playwright skills for AI coding agents?

For a team running Playwright Test in CI that wants agents to follow current practice and fix flaky failures from real run data, start with Currents, whose skill covers practice, fixing and CI scale.

What are Playwright CLI skills?

Playwright CLI skills teach coding agents to use playwright-cli by giving them structured reference documentation they can discover and use. One of the bundled reference guides covers planning, generating and healing tests. The Playwright CLI skills entry also shows how the agent repairs a test.

Is there a Playwright plugin for Claude Code?

Yes. Playwright Pro installs as a plugin with claude plugin install pw@claude-skills. Its compatibility table gives Claude Code full plugin support: slash commands, MCP tools, hooks and agents, as the Playwright Pro entry describes.

Should a coding agent use Playwright MCP or a skill?

For test authoring in a coding agent, pick a skill rather than Playwright MCP. The Playwright MCP README itself says that if you're using a coding agent, you might benefit from a CLI-plus-skills setup instead of the MCP interface. The Playwright MCP entry covers where the MCP server fits instead.

Why do AI agents write flaky Playwright tests?

Without Playwright guidance, the tests an agent writes tend to include waitForTimeout calls, and Playwright's API docs say that tests that wait for time are inherently flaky. Unguided agents also reach for brittle CSS selectors, which can fail when the DOM changes, as the introduction explains before the ranking criteria.

Do Playwright skills write test specs or browser scripts?

It depends on the skill, so check what it produces before you adopt it.

How do I get an AI agent to fix failing Playwright tests in CI?

Give the agent the failure's steps and trace, not just the log. With the failure context from Currents, the agent finds the cause in the app or in the test, fixes it and runs the test again to check the fix, as the anti-pattern on fixing from the log shows.

Does Playwright have built-in test agents?

Yes. Playwright ships three built-in Test Agents: planner, generator and healer. You add their definitions with the init-agents command, and the docs say to regenerate them whenever Playwright is updated, as How we picked notes.