Skip to main content
skill CX Codex

browser-devtools-mcp — Claude Code skill: install & overview

Connects Claude Code to browser DevTools over MCP for live UI review, screenshot-to-code conversion, and computed style extraction.

MIT ★ 126 updated 2026-10-04

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add Ormus-Solutions/LibreUIUX-Claude-Code
/plugin install mcp-integrations@libreuiux
Open on GitHub

What browser-devtools-mcp does

The skill provides Claude Code with explicit workflows to inspect running web applications through the Model Context Protocol. Rather than deducing layouts from static files, the agent interacts with live renders. Accessibility snapshots clarify element hierarchies.

It organizes tasks into distinct capture and inspection patterns. Claude takes element screenshots, extracts computed CSS values with window.getComputedStyle, and combines visual renders with accessibility trees to write matching components.

An active browser MCP server such as Playwright MCP must be configured in Claude Code beforehand. Without these external tools exposed, the skill has no mechanism to navigate pages or run browser evaluations.

What it helps with

  • inspect computed CSS properties on rendered elements
  • convert live interface screenshots into component code
  • capture accessibility snapshots to understand UI structure
  • check layout regressions directly in a running browser

Example prompts for the agent

  • Navigate to the target page via Playwright MCP and extract computed styles for the hero card.
  • Take a screenshot and an accessibility snapshot of the navigation bar, then generate a React component.
  • Inspect the primary button to see its padding, display mode, and margin values.

How to install browser-devtools-mcp

1Plugin marketplace

/plugin marketplace add Ormus-Solutions/LibreUIUX-Claude-Code
/plugin install mcp-integrations@libreuiux

This installs the whole mcp-integrations plugin with all its skills

2Skills CLI (Vercel)

npx skills add Ormus-Solutions/LibreUIUX-Claude-Code --skill browser-devtools-mcp -a claude-code

3Manually: put the files in place

~/.claude/skills/browser-devtools-mcp/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/browser-devtools-mcp/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about browser-devtools-mcp

How to install browser-devtools-mcp in Claude Code?

Run /plugin marketplace add Ormus-Solutions/LibreUIUX-Claude-Code followed by /plugin install mcp-integrations@libreuiux in your Claude Code interface.

What does browser-devtools-mcp do?

It guides Claude Code through browser automation routines to inspect live DOM nodes, grab screenshots, and translate visual interfaces into code.

Which MCP tools are required for this skill?

It expects an MCP server that exposes browser automation methods, such as Playwright MCP with tools like mcp__playwright__browser_navigate and mcp__playwright__browser_take_screenshot.

Source text

SKILL.md · MIT
---
name: browser-devtools-mcp
description: "Chrome DevTools and browser automation through MCP for live UI work: screenshots, DOM and computed-style inspection, screenshot-to-code, design token extraction, Lighthouse and accessibility audits, and visual regression checks. Use when Claude should look at a running interface instead of guessing from code."
---

# Browser DevTools MCP Integration

Leverage browser automation and DevTools through MCP (Model Context Protocol) for live UI inspection, screenshot-to-code workflows, and visual debugging. This skill enables direct observation and manipulation of running interfaces.

---

## When to Use This Skill

- Capturing screenshots of live UIs for analysis
- Inspecting CSS and computed styles programmatically
- Implementing screenshot-to-code workflows
- Debugging layout issues with visual feedback
- Extracting design tokens from existing sites
- Automating visual regression testing
- Building live preview workflows

---

## MCP Architecture Overview

### What is MCP?

Model Context Protocol (MCP) is Anthropic's standard for connecting LLMs to external tools. It provides:

- **Standardized tool interface** - Consistent way to expose capabilities
- **Bidirectional communication** - Tools can query the model
- **Stateful sessions** - Maintain context across interactions
- **Permission boundaries** - Control what tools can do

### Browser MCP Landscape

```
+-------------------+     +-------------------+     +-------------------+
|   Playwright MCP  |     |   Puppeteer MCP   |     | Chrome DevTools   |
|   (Full browser)  |     |   (Headless)      |     | Protocol (CDP)    |
+-------------------+     +-------------------+     +-------------------+
         |                         |                         |
         +-----------+-------------+-----------+-------------+
                     |                         |
              +------v------+           +------v------+
              | Screenshot  |           |  Element    |
              | Capture     |           |  Inspection |
              +-------------+           +-------------+
                     |                         |
              +------v------+           +------v------+
              | Visual      |           |  Style      |
              | Comparison  |           |  Extraction |
              +-------------+           +-------------+
```

---

## Core MCP Tools for UI Work

### Available Browser MCP Tools

When using Playwright MCP (common in Claude Code):

```typescript
// Navigation and page control
mcp__playwright__browser_navigate({ url: string })
mcp__playwright__browser_navigate_back()
mcp__playwright__browser_close()
mcp__playwright__browser_resize({ width: number, height: number })

// Screenshots and visual capture
mcp__playwright__browser_take_screenshot({
  filename?: string,
  fullPage?: boolean,
  type?: "png" | "jpeg",
  element?: string,  // Human-readable description
  ref?: string       // Element reference from snapshot
})

// Accessibility snapshots (better than screenshots for structure)
mcp__playwright__browser_snapshot({
  filename?: string  // Optional: save to file
})

// Interactions
mcp__playwright__browser_click({ element: string, ref: string })
mcp__playwright__browser_type({ element: string, ref: string, text: string })
mcp__playwright__browser_hover({ element: string, ref: string })

// Form handling
mcp__playwright__browser_fill_form({ fields: FormField[] })

// Evaluation
mcp__playwright__browser_evaluate({ function: string, element?: string, ref?: string })

// Tab management
mcp__playwright__browser_tabs({ action: "list" | "new" | "close" | "select" })
```

---

## Screenshot-to-Code Workflows

### Workflow 1: Direct Screenshot Analysis

Capture and analyze a live UI for recreation:

```python
class ScreenshotToCodeWorkflow:
    """
    Convert a screenshot of a UI into working code.
    """

    async def capture_and_analyze(self, url: str) -> CodeOutput:
        # Step 1: Navigate to target
        await mcp.browser_navigate(url=url)

        # Step 2: Wait for full render
        await mcp.browser_wait_for(time=2)

        # Step 3: Take high-quality screenshot
        screenshot = await mcp.browser_take_screenshot(
            filename="capture.png",
            fullPage=False,
            type="png"
        )

        # Step 4: Get accessibility snapshot for structure
        snapshot = await mcp.browser_snapshot()

        # Step 5: Analyze with vision + structure
        analysis = await self.analyze_screenshot(screenshot, snapshot)

        # Step 6: Generate code
        code = await self.generate_code(analysis)

        return code

    async def analyze_screenshot(self, screenshot: str, snapshot: str) -> UIAnalysis:
        """
        Combine visual and structural analysis.
        """
        prompt = f"""
        Analyze this UI screenshot and accessibility snapshot.

        ## Accessibility Snapshot (Structure)
        {snapshot}

        ## Analysis Tasks

        1. **Layout Structure**
           - Identify major sections (header, sidebar, main, footer)
           - Determine grid/flexbox patterns
           - Note responsive breakpoint hints

        2. **Visual Elements**
           - Extract color palette (background, text, accent)
           - Identify typography (font family, sizes, weights)
           - Note spacing patterns

        3. **Components**
           - List all UI components visible
           - Describe their visual treatment
           - Note interactive elements

        4. **Design System Inference**
           - What design system might this be based on?
           - What are the governing principles?

        Output as structured JSON.
        """

        return await self.llm.analyze_image(screenshot, prompt)
```

### Workflow 2: Element-Specific Extraction

Extract and recreate specific elements:

```python
class ElementExtractionWorkflow:
    """
    Extract and recreate specific UI elements.
    """

    async def extract_element(self, url: str, selector: str) -> ElementCode:
        # Navigate to page
        await mcp.browser_navigate(url=url)

        # Get page snapshot to find element
        snapshot = await mcp.browser_snapshot()

        # Find element reference in snapshot
        ref = self.find_element_ref(snapshot, selector)

        # Take element-specific screenshot
        element_screenshot = await mcp.browser_take_screenshot(
            element=f"Target element: {selector}",
            ref=ref
        )

        # Extract computed styles via evaluation
        styles = await mcp.browser_evaluate(
            function="""
            (element) => {
                const computed = window.getComputedStyle(element);
                return {
                    display: computed.display,
                    flexDirection: computed.flexDirection,
                    padding: computed.padding,
                    margin: computed.margin,
                    backgroundColor: computed.backgroundColor,
                    color: computed.color,
                    fontSize: computed.fontSize,
                    fontWeight: computed.fontWeight,
                    borderRadius: computed.borderRadius,
                    boxShadow: computed.boxShadow,
                };
            }
            """,
            element=f"Target element: {selector}",
            ref=ref
        )

        # Generate code from extracted data
        return await self.generate_element_code(element_screenshot, styles)
```

### Workflow 3: Design Token Extraction

Extract design tokens from a live site:

```python
class TokenExtractionWorkflow:
    """
    Extract design tokens from a live website.
    """

    async def extract_tokens(self, url: str) -> DesignTokens:
        await mcp.browser_navigate(url=url)

        # Extract colors from key elements
        colors = await mcp.browser_evaluate(
            function="""
            () => {
                const elements = document.querySelectorAll(
                    'button, a, h1, h2, h3, p, [class*="bg-"], [class*="text-"]'
                );

                const colors = new Set();
                elements.forEach(el => {
                    const style = window.getComputedStyle(el);
                    colors.add(style.color);
                    colors.add(style.backgroundColor);
                    colors.add(style.borderColor);
                });

                return Array.from(colors).filter(c => c !== 'rgba(0, 0, 0, 0)');
            }
            """
        )

        # Extract typography
        typography = await mcp.browser_evaluate(
            function="""
            () => {
                const textElements = document.querySelectorAll('h1, h2, h3, h4, p, span, a');
                const fonts = new Map();

                textElements.forEach(el => {
                    const style = window.getComputedStyle(el);
                    const key = `${style.fontFamily}|${style.fontSize}|${style.fontWeight}`;
                    if (!fonts.has(key)) {
                        fonts.set(key, {
                            fontFamily: style.fontFamily,
                            fontSize: style.fontSize,
                            fontWeight: style.fontWeight,
                            lineHeight: style.lineHeight,
                        });
                    }
                });

                return Array.from(fonts.values());
            }
            """
        )

        # Extract spacing patterns
        spacing = await mcp.browser_evaluate(
            function="""
            () => {
                const elements = document.querySelectorAll('[class*="p-"], [class*="m-"], [class*="gap-"]');
                const spacings = new Set();

                elements.forEach(el => {
                    const style = window.getComputedStyle(el);
                    spacings.add(style.padding);
                    spacings.add(style.margin);
                    spacings.add(style.gap);
                });

                return Array.from(spacings);
            }
            """
        )

        return self.normalize_tokens(colors, typography, spacing)
```

---

## Live Inspection Patterns

### Pattern 1: Visual Debugging

Debug layout issues with visual feedback:

```python
class VisualDebugger:
    """
    Debug UI issues using browser inspection.
    """

    async def debug_layout(self, url: str, issue_description: str) -> DebugReport:
        await mcp.browser_navigate(url=url)

        # Take initial screenshot
        before = await mcp.browser_take_screenshot(filename="before.png")

        # Get page snapshot
        snapshot = await mcp.browser_snapshot()

        # Inject debug styles via evaluation
        await mcp.browser_evaluate(
            function="""
            () => {
                // Add debug overlay to all elements
                const style = document.createElement('style');
                style.textContent = `
                    * { outline: 1px solid rgba(255,0,0,0.2) !important; }
                    *:hover { outline: 2px solid red !important; }
                `;
                document.head.appendChild(style);
            }
            """
        )

        # Take debug screenshot
        debug_screenshot = await mcp.browser_take_screenshot(
            filename="debug-overlay.png"
        )

        # Analyze the issue
        analysis = await self.analyze_layout_issue(
            before=before,
            debug=debug_screenshot,
            snapshot=snapshot,
            issue=issue_description
        )

        return analysis

    async def compare_with_design(
        self,
        live_url: str,
        design_image_path: str
    ) -> ComparisonReport:
        """
        Compare live implementation against design mockup.
        """
        await mcp.browser_navigate(url=live_url)

        live_screenshot = await mcp.browser_take_screenshot(
            filename="live.png",
            fullPage=True
        )

        # Load and analyze both images
        prompt = """
        Compare these two images:
        1. Design mockup (what it should look like)
        2. Live implementation (what it actually looks like)

        Identify:
        - Color discrepancies (with specific values)
        - Spacing differences (estimate pixels)
        - Typography mismatches
        - Layout structural differences
        - Missing or extra elements

        Provide specific, actionable fixes.
        """

        return await self.compare_images(design_image_path, live_screenshot, prompt)
```

### Pattern 2: Responsive Testing

Test and capture across breakpoints:

```python
class ResponsiveTester:
    """
    Test UI across responsive breakpoints.
    """

    BREAKPOINTS = {
        "mobile": {"width": 375, "height": 812},
        "tablet": {"width": 768, "height": 1024},
        "desktop": {"width": 1440, "height": 900},
        "wide": {"width": 1920, "height": 1080},
    }

    async def capture_all_breakpoints(self, url: str) -> dict[str, str]:
        """
        Capture screenshots at all standard breakpoints.
        """
        await mcp.browser_navigate(url=url)

        captures = {}
        for name, dimensions in self.BREAKPOINTS.items():
            await mcp.browser_resize(**dimensions)
            await mcp.browser_wait_for(time=0.5)  # Let layout settle

            screenshot = await mcp.browser_take_screenshot(
                filename=f"responsive-{name}.png"
            )
            captures[name] = screenshot

        return captures

    async def analyze_responsiveness(self, url: str) -> ResponsivenessReport:
        """
        Analyze how well the UI responds to different sizes.
        """
        captures = await self.capture_all_breakpoints(url)

        prompt = """
        Analyze these screenshots at different viewport sizes.

        Check for:
        1. Layout breaks or overflow
        2. Touch target sizes on mobile (min 44x44px)
        3. Text readability at each size
        4. Navigation accessibility
        5. Image scaling issues
        6. Hidden content that shouldn't be

        Provide specific recommendations for each breakpoint.
        """

        return await self.analyze_screenshots(captures, prompt)
```

---

## MCP Tool Patterns

### Pattern: Snapshot + Screenshot Combo

Use both tools for complete understanding:

```python
async def comprehensive_capture(url: str) -> tuple[str, str]:
    """
    Capture both visual and structural representation.

    The snapshot gives you:
    - Element hierarchy
    - Text content
    - Interactive elements with refs
    - Accessibility tree

    The screenshot gives you:
    - Visual appearance
    - Colors, typography, spacing
    - Layout as rendered
    """
    await mcp.browser_navigate(url=url)

    # Snapshot for structure (better for understanding layout)
    snapshot = await mcp.browser_snapshot()

    # Screenshot for visual analysis
    screenshot = await mcp.browser_take_screenshot()

    return snapshot, screenshot
```

### Pattern: Interactive Exploration

Navigate and inspect interactively:

```python
async def explore_component(component_name: str):
    """
    Interactively explore a component's states.
    """
    # Get snapshot to find component
    snapshot = await mcp.browser_snapshot()

    # Find the component in snapshot
    # Snapshot returns refs like [12] for elements

    # Hover to see hover state
    await mcp.browser_hover(
        element=f"{component_name} component",
        ref="[12]"  # From snapshot
    )
    hover_screenshot = await mcp.browser_take_screenshot(filename="hover.png")

    # Click to see active/pressed state
    await mcp.browser_click(
        element=f"{component_name} component",
        ref="[12]"
    )
    active_screenshot = await mcp.browser_take_screenshot(filename="active.png")

    return {
        "default": await mcp.browser_take_screenshot(filename="default.png"),
        "hover": hover_screenshot,
        "active": active_screenshot,
    }
```

---

## Live Preview Workflows

### Pattern: Hot Reload Development

Combine code generation with live preview:

```python
class LivePreviewWorkflow:
    """
    Generate code and preview changes live.
    """

    async def iterate_with_preview(
        self,
        component_spec: str,
        preview_url: str
    ) -> FinalComponent:
        iterations = []

        for i in range(3):  # Max 3 iterations
            # Generate/refine component
            code = await self.generate_component(component_spec, iterations)

            # Write to file (triggers hot reload)
            await self.write_component(code)

            # Wait for hot reload
            await mcp.browser_wait_for(time=1)

            # Capture preview
            await mcp.browser_navigate(url=preview_url)
            screenshot = await mcp.browser_take_screenshot(
                filename=f"iteration-{i}.png"
            )

            # Analyze against spec
            feedback = await self.analyze_preview(screenshot, component_spec)

            if feedback.meets_spec:
                return code

            iterations.append({
                "code": code,
                "feedback": feedback.issues,
            })

            # Update spec for next iteration
            component_spec = self.refine_spec(component_spec, feedback)

        return code  # Return best effort
```

---

## DevTools Protocol Direct Access

### Advanced: CDP for Deep Inspection

Access Chrome DevTools Protocol directly for advanced use:

```python
async def advanced_style_extraction(url: str):
    """
    Use CDP for detailed style information.
    """
    # This would require CDP MCP or direct protocol access

    cdp_evaluate = """
    async function getDetailedStyles(selector) {
        const element = document.querySelector(selector);
        if (!element) return null;

        // Get all applied CSS rules
        const rules = [];
        for (const sheet of document.styleSheets) {
            try {
                for (const rule of sheet.cssRules) {
                    if (element.matches(rule.selectorText)) {
                        rules.push({
                            selector: rule.selectorText,
                            styles: rule.style.cssText,
                            specificity: calculateSpecificity(rule.selectorText),
                        });
                    }
                }
            } catch (e) {
                // Cross-origin stylesheets
            }
        }

        // Get computed styles
        const computed = window.getComputedStyle(element);

        // Get layout metrics
        const rect = element.getBoundingClientRect();

        return {
            appliedRules: rules,
            computedStyles: Object.fromEntries(
                Array.from(computed).map(prop => [prop, computed.getPropertyValue(prop)])
            ),
            layout: {
                x: rect.x,
                y: rect.y,
                width: rect.width,
                height: rect.height,
            },
        };
    }
    """

    return await mcp.browser_evaluate(function=cdp_evaluate)
```

---

## Integration Patterns

### With Agent Orchestration

```python
class BrowserInspectionAgent:
    """
    Agent that uses browser MCP for UI analysis.
    """

    tools = [
        "browser_navigate",
        "browser_snapshot",
        "browser_take_screenshot",
        "browser_evaluate",
    ]

    permissions = ["read_web", "capture_screenshot"]

    async def analyze_competitor(self, url: str) -> AnalysisReport:
        """
        Analyze competitor UI using browser tools.
        """
        # Navigate
        await self.use_tool("browser_navigate", url=url)

        # Multi-modal capture
        snapshot = await self.use_tool("browser_snapshot")
        screenshot = await self.use_tool("browser_take_screenshot")

        # Extract tokens
        tokens = await self.use_tool("browser_evaluate",
            function="() => extractDesignTokens()"
        )

        return await self.synthesize_analysis(snapshot, screenshot, tokens)
```

---

## Quick Reference

| Task | MCP Tool | Notes |
|------|----------|-------|
| Capture full page | `browser_take_screenshot(fullPage=true)` | Good for documentation |
| Get page structure | `browser_snapshot()` | Better for understanding layout |
| Capture element | `browser_take_screenshot(element, ref)` | Need ref from snapshot |
| Extract styles | `browser_evaluate()` | Run getComputedStyle |
| Test responsive | `browser_resize()` + screenshot | Loop through breakpoints |
| Debug interactivity | `browser_hover()`, `browser_click()` | Capture state changes |

---

## Best Practices

1. **Snapshot first**: Always get a snapshot before screenshots - it provides element refs
2. **Wait for render**: Use `browser_wait_for(time)` after navigation
3. **Combine modalities**: Visual + structural analysis yields best results
4. **Iterative capture**: Multiple screenshots at different states
5. **Token extraction**: Prefer evaluation over visual inference for exact values

---

## Related Skills

This skill works with:
- `agent-orchestration/ui-agent-patterns` - Browser agent in multi-agent workflows
- `llm-application-dev/prompt-engineering-ui` - Prompts for screenshot analysis
- `context-management/design-system-context` - Store extracted tokens

---

*"The browser is not just a renderer - it is an oracle for the living interface."*

© Diego Bodart · MIT · Ormus-Solutions/LibreUIUX-Claude-Code

Similar skills

All skills for Frontend and UI →

From the same set42

The whole set →
ui-synth The ui-synth command turns an interface request into a coordinated design and implementation plan, spanning visual direction, code, tests, and SEO. Use it to outline a component or feature across those stages. CX Codex +1 ★ 126repo stars major-arcana Maps the 22 Major Arcana cards to color systems, lighting, and UI moods. Use it when a design needs symbolic color schemes or when you reference a card like the Sun, Moon, or Hermit. CX Codex +1 ★ 126repo stars ui-agent-patterns ui-agent-patterns provides orchestration patterns to delegate UI development across AI agents, from single synthesis architectures to multi-agent pipelines. CX Codex +1 ★ 126repo stars design-system-context The design-system-context skill organizes design tokens and decisions for Claude Code UI work. Use it when generated screens drift from your design system or agents need consistent context. CX Codex +1 ★ 126repo stars smart-fix smart-fix — a Claude Code command that orchestrates multiple specialized agents to analyze and resolve production incidents. CX Codex +1 ★ 126repo stars libreuiux-hooks libreuiux-hooks adds three Claude Code hooks to detect your UI stack at session start, protect secrets from silent edits, and flag accessibility issues right after UI changes. ★ 126repo stars vibe-coding The vibe-coding skill helps create throwaway UI prototypes, compare design directions, and decide when a concept is ready for production work. Use it while validating interface ideas or user flows. ★ 126repo stars mcp-integrations mcp-integrations is a Claude Code plugin that uses MCP browser tools to inspect live interfaces. It can turn screenshots into UI code and extract design tokens. ★ 126repo stars

Project sponsors

Companies that keep this analytics open