Chrome Devtools logo

Chrome Devtools

OrganizationPopular
github
chrome-devtools

Expert-level browser automation, debugging, and performance analysis using Chrome DevTools MCP. Use for interacting with web pages, capturing screenshots, analyzing network traffic, and profiling performance.

Overview

Publishergithub
Repositoryawesome-copilot
Skill namechrome-devtools
Stars
39.6K
Forks
5K
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by github on GitHub. Read the source before you install it.

Installation

Install the Chrome Devtools AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/github/awesome-copilot/tree/main/skills/chrome-devtools
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/github/awesome-copilot.git /tmp/awesome-copilot
mkdir -p .claude/skills
cp -r /tmp/awesome-copilot/skills/chrome-devtools .claude/skills/chrome-devtools
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Chrome Devtools in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Chrome Devtools on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Chrome Devtools is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Chrome 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 (use uid from 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.

markdown
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.

markdown
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.

markdown
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_pages and select_page if you are unsure which tab is currently active.
  • Snapshots: Take a new snapshot after any major navigation or DOM change, as uid values may change.
  • Timeouts: Use reasonable timeouts for wait_for to avoid hanging on slow-loading elements.
  • Screenshots: Use take_screenshot sparingly for visual verification, but rely on take_snapshot for logic.

Frequently asked questions

What does the Chrome Devtools AI skill do?

Expert-level browser automation, debugging, and performance analysis using Chrome DevTools MCP. Use for interacting with web pages, capturing screenshots, analyzing network traffic, and profiling performance.

Why use Chrome Devtools on TypingMind?

Because you install it once and use it with any model. Chrome Devtools is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Chrome Devtools in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/github/awesome-copilot/tree/main/skills/chrome-devtools. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Chrome Devtools?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Chrome Devtools?

As many as you like. As long as a model supports skills, you can use Chrome Devtools with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Chrome Devtools AI skill free?

Yes. It is published on GitHub by github under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇