
Chrome DevTools Agent
OfficialFreeAutomate and debug web applications effortlessly.
Free · Opens the source repo
What Chrome DevTools Agent does
The Chrome DevTools Agent is a specialized skill designed to facilitate comprehensive control and inspection of a live Chrome browser. Built on the chrome-devtools MCP server, this skill enables developers and designers to perform a variety of tasks essential for web development, including browser automation, debugging, and performance analysis. With capabilities ranging from simple navigation to detailed performance profiling, it is an invaluable tool for anyone involved in web application development.
This skill allows for extensive interaction with web pages, enabling users to automate navigation, fill out forms, and handle dialogs seamlessly. It also supports visual inspection through features like screenshot capturing and text snapshots, which are crucial for verifying the appearance and functionality of web applications. Additionally, the debugging capabilities allow users to inspect console messages, evaluate JavaScript in the context of the page, and analyze network requests, making it easier to identify and resolve issues.
For performance analysis, the Chrome DevTools Agent provides tools to record and analyze performance traces, helping users pinpoint bottlenecks and optimize their applications. The emulation features allow for testing under various conditions, such as different viewport sizes or network speeds, ensuring that applications perform well across diverse environments. This skill is particularly useful for developers looking to enhance their workflow and improve the quality of their web applications.
In summary, the Chrome DevTools Agent is a powerful tool that streamlines the process of web development and debugging. It is particularly suited for developers and designers who require a robust solution for automating browser tasks, inspecting web page elements, and analyzing performance metrics.
When to use it
Use this skill when you need to automate tasks in a Chrome browser, debug web applications, or analyze performance metrics.
When not to use it
This skill may not be suitable for tasks outside of browser automation or for applications that do not run in a web environment.
What you can build with it
Automating Form Submissions
Use the skill to automatically fill and submit forms on web applications, saving time during testing.
Debugging JavaScript Errors
Quickly identify and troubleshoot JavaScript errors by inspecting console messages and network requests.
Performance Testing
Record performance traces to analyze and optimize the loading speed and responsiveness of your web applications.
How to install Chrome DevTools Agent
View source1. Install with the skills CLI
npx skills add github/awesome-copilot/chrome-devtools --agent claude-code2. Or install it manually
Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.
Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs
Inside SKILL.md
Written by githubChrome DevTools Agent
Overview
A specialized skill for controlling and inspecting a live Chrome browser. This skill leverages the chrome-devtools MCP server to perform a wide range of browser-related tasks, from simple navigation to complex performance profiling.
When to Use
Use this skill when:
- Browser Automation: Navigating pages, clicking elements, filling forms, and handling dialogs.
- Visual Inspection: Taking screenshots or text snapshots of web pages.
- Debugging: Inspecting console messages, evaluating JavaScript in the page context, and analyzing network requests.
- Performance Analysis: Recording and analyzing performance traces to identify bottlenecks and Core Web Vital issues.
- Emulation: Resizing the viewport or emulating network/CPU conditions.
Tool Categories
1. Navigation & Page Management
new_page: Open a new tab/page.navigate_page: Go to a specific URL, reload, or navigate history.select_page: Switch context between open pages.list_pages: See all open pages and their IDs.close_page: Close a specific page.wait_for: Wait for specific text to appear on the page.
2. Input & Interaction
click: Click on an element (useuidfrom snapshot).fill/fill_form: Type text into inputs or fill multiple fields at once.hover: Move the mouse over an element.press_key: Send keyboard shortcuts or special keys (e.g., "Enter", "Control+C").drag: Drag and drop elements.handle_dialog: Accept or dismiss browser alerts/prompts.upload_file: Upload a file through a file input.
3. Debugging & Inspection
take_snapshot: Get a text-based accessibility tree (best for identifying elements).take_screenshot: Capture a visual representation of the page or a specific element.list_console_messages/get_console_message: Inspect the page's console output.evaluate_script: Run custom JavaScript in the page context.list_network_requests/get_network_request: Analyze network traffic and request details.
4. Emulation & Performance
resize_page: Change the viewport dimensions.emulate: Throttling CPU/Network or emulating geolocation.performance_start_trace: Start recording a performance profile.performance_stop_trace: Stop recording and save the trace.performance_analyze_insight: Get detailed analysis from recorded performance data.
Workflow Patterns
Pattern A: Identifying Elements (Snapshot-First)
Always prefer take_snapshot over take_screenshot for finding elements. The snapshot provides uid values which are required by interaction tools.
1. `take_snapshot` to get the current page structure.
2. Find the `uid` of the target element.
3. Use `click(uid=...)` or `fill(uid=..., value=...)`.
Pattern B: Troubleshooting Errors
When a page is failing, check both console logs and network requests.
1. `list_console_messages` to check for JavaScript errors.
2. `list_network_requests` to identify failed (4xx/5xx) resources.
3. `evaluate_script` to check the value of specific DOM elements or global variables.
Pattern C: Performance Profiling
Identify why a page is slow.
1. `performance_start_trace(reload=true, autoStop=true)`
2. Wait for the page to load/trace to finish.
3. `performance_analyze_insight` to find LCP issues or layout shifts.
Best Practices
- Context Awareness: Always run
list_pagesandselect_pageif you are unsure which tab is currently active. - Snapshots: Take a new snapshot after any major navigation or DOM change, as
uidvalues may change. - Timeouts: Use reasonable timeouts for
wait_forto avoid hanging on slow-loading elements. - Screenshots: Use
take_screenshotsparingly for visual verification, but rely ontake_snapshotfor logic.
Frequently asked questions about Chrome DevTools Agent
Similar skills
Spring Boot Testing
Master testing techniques for Spring Boot 4 applications.
GitHub Issues
Manage GitHub issues efficiently with MCP tools.
Geofeed Tuner
Optimize your IP geolocation feeds in CSV format.
Batch Files
Master Windows batch scripting for automation and task management.
Adobe Illustrator Scripting
Automate your Illustrator workflows with ExtendScript.
Plugin Structure
Create and organize Claude Code plugins effectively.
