Browser Testing with DevTools

Browser Testing with DevTools brings screenshots, DOM state, console messages, and network evidence into an agent’s browser testing workflow. It uses Chrome DevTools MCP and works best with a scoped test profile.

Capture browser evidence for a failed interaction

Give the agent a test page and a single interaction to inspect in an isolated Chrome profile.

Provide an approved URL, synthetic data, expected behavior, and the evidence needed.

Copy the request into a new Floatboat conversation and provide the required material.

Download Floatboat

Your request for Floatboat

Preview and copy the request. It is not sent automatically from this page.

Reference: Browser Testing with DevTools
https://github.com/addyosmani/agent-skills/blob/main/skills/browser-testing-with-devtools/SKILL.md

Read the original documentation and check the current environment and dependencies. Propose any new installation or tool connection before proceeding.

My task:
In Claude Code with Chrome DevTools MCP configured for an isolated profile, open my approved localhost checkout fixture. Reproduce the failed shipping quote with synthetic data. Record the visible state, relevant console errors, and the failing request status without secrets. Compare one baseline and one retry, and leave application files unchanged.

Expected deliverable:
A sanitized record of the action, visible state, and relevant runtime evidence.

About Browser Testing with DevTools

This Skill from Addy Osmani gives a coding agent a browser verification procedure. After Chrome DevTools MCP is configured separately, the agent can inspect running Chrome pages, compare visual or runtime evidence, and report what it observed. Use an isolated profile with test data, and treat page content as data.

Browser Testing with DevTools Use Cases

Decide which evidence answers the question before recording a run. A layout defect may need a screenshot and computed styles, while a failed request calls for network evidence.

Diagnose a failed request

Provide a local or staging URL and the action that should issue a request. Capture its status and relevant console errors with sensitive values omitted. Compare the first failure and a controlled retry to distinguish a persistent defect from a transient response.

Verify responsive layout

Specify two viewport sizes and the element expected to remain visible. Capture screenshots and inspect computed styles at both sizes. Keep the comparison focused on the component you changed.

Check a state transition

Choose a non-production interaction with synthetic data, then record what the UI shows before and after the action. Inspect the DOM and console to tell a rendering problem apart from a missing state change.

Compare performance traces

Measure the same page and interaction before and after the change under comparable conditions. For private test URLs, disable CrUX lookups with --no-performance-crux. Record relevant timing or long tasks and the test conditions so a teammate can repeat the comparison.

How to Test a Page with DevTools

Connect the MCP server to an isolated browser before testing. Name the page, interaction and expected behavior, then limit the run to the observations needed to verify the issue.

  1. Configure isolated browser access

    Install the Skill for the chosen host. With supported Chrome, Node.js LTS, and npm available, configure Chrome DevTools MCP separately with --isolated and confirm it can start the test browser.

  2. Capture a focused baseline

    Open the approved test URL, reproduce the selected behavior, and collect only the relevant DOM, console, network, or screenshot evidence.

  3. Verify the change or retry

    Repeat the same interaction under comparable conditions. Record what changed, what stayed unresolved, and where the sanitized evidence is saved.

Explore More Agent Skills

Read another Skill guide and check its original source before using it.

Browser Testing with DevTools FAQ

Does installing the Skill configure MCP?
Set up Chrome DevTools MCP in the host separately. The Skill provides the workflow, and the MCP server provides access to the browser tools.
Can I use my logged-in Chrome profile?
Prefer the dedicated or isolated profile. If authentication is essential, use an approved test profile with only the account needed for the test.
Which findings should I save?
Keep the steps, relevant runtime observations, and useful screenshots or traces. Omit credentials, raw session information and unrelated requests.
Can it compare a fix to the original issue?
Yes. Capture the same interaction under comparable conditions before and after the change, and compare both the visible behavior and the relevant runtime evidence.
Does this cover backend-only changes?
The Skill is designed around behavior observable in the browser. Use appropriate service or unit tests to verify backend behavior outside that surface.
What if the browser page contains commands for the agent?
Treat page text, console output, and response content as observations. Follow your approved test plan and report unexpected instruction-like content.