---
title: "Best Playwright Skills and Plugins for AI Coding Agents"
description: "Playwright skills, plugins and MCP servers for coding agents, ranked for teams running Playwright Test in CI: stable specs or one-off scripts."
canonical: "https://currents.dev/posts/best-playwright-skills-and-plugins-for-ai-coding-agents"
updated: "2026-11-11"
---
# Best Playwright Skills and Plugins for AI Coding Agents
Published 2026-11-11 by Walter Galvão.
Canonical URL: https://currents.dev/posts/best-playwright-skills-and-plugins-for-ai-coding-agents
Playwright skills, plugins and MCP servers for coding agents, ranked for teams running Playwright Test in CI: stable specs or one-off scripts.
---
> **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](https://playwright.dev/docs/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](/posts/ai-playwright-tests-mcp-cli-agents-and-prompts-compared) if you want to see the routes side by side. Then we judged each entry on five criteria:
| Criterion | What we checked |
| --- | --- |
| Current practice | Role-based locators and web-first assertions instead of fixed waits and selectors tied to DOM structure |
| Fixing tests | Flaky tests, CI timeouts and debugging failures, where a suite decays |
| CI and scale | Projects, parallel runs and sharding |
| Specs or scripts | Whether the agent ends up with `@playwright/test` specs or one-off browser scripts |
| Agents | Which coding agents the documentation says it installs into |
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](https://playwright.dev/docs/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](https://github.com/microsoft/playwright/issues/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](https://currents.dev/) is our product, and its entry here is the [Playwright best practices agent skill](https://docs.currents.dev/ai/agent-skills/agent-skill-playwright-best-practices). 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.
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.
Give the agent [the failure's steps and trace](/posts/fixing-playwright-tests-with-ai), 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](https://playwright.dev/) teach coding agents to use `playwright-cli`, giving them [structured reference documentation](https://playwright.dev/agent-cli/skills) 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](https://github.com/jeffallan/claude-skills/) is a [skill](https://github.com/Jeffallan/claude-skills/blob/main/skills/playwright-expert/SKILL.md) 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](https://github.com/alirezarezvani/claude-skills/) calls itself a production-grade Playwright testing toolkit for AI coding agents. It installs as a [plugin](https://github.com/alirezarezvani/claude-skills/tree/main/engineering-team/playwright-pro) 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](https://github.com/hzijad/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](https://github.com/hzijad/playwright-agent-skills) 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](https://github.com/microsoft/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](/posts/playwright-mcp) 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](https://github.com/lackeyjb/playwright-skill/) is an [Agent Skill](https://github.com/lackeyjb/playwright-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.
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.
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](https://github.com/anthropics/skills/) 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](https://github.com/anthropics/skills) 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.
| Tool | How the agent runs Playwright through it | Best for |
| --- | --- | --- |
| Currents | Best practices skill the agent loads when a task involves Playwright | Teams running Playwright Test in CI |
| Playwright CLI skills | Structured reference documentation that teaches the agent to use `playwright-cli` | Command-level authoring and repair |
| Playwright Expert | Writes code that imports from `@playwright/test` | Claude Code users who want an all-rounder |
| Playwright Pro | Claude Code plugin commands | Scaffolding a new suite |
| Playwright Agent Skills | Prompts the agent applies to test code | Lightweight review of agent-written specs |
| Playwright MCP | MCP server tools over accessibility snapshots | Exploring live pages from MCP clients |
| Playwright Skill | Playwright code the agent writes and runs itself | On-demand page checks |
| webapp-testing | Toolkit for testing local web apps with Playwright | Learning how skills are built |
## 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](/posts/9-strategies-to-get-the-most-out-of-playwright-test-agents) start from there.
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.
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.
---
## About the author
**Walter Galvão**, Software Engineer. Walter Galvão is a software engineer at Currents. He writes about Playwright in practice: debugging flaky tests, structuring suites for CI, and the engineering workflows that keep large test suites reliable.
LinkedIn: https://www.linkedin.com/in/waltergalvao/