# Modern Web Guidance 1.0 Helps AI Coding Agents Build for More Than One Browser

Install Modern Web Guidance in Codex or Claude Code, set browser support targets, scan legacy frontend code, and verify AI-generated fixes.

Canonical URL: https://aiidelist.com/blog/modern-web-guidance

Language: en

Published: 2026-11-20

Updated: 2026-11-20

## Key Takeaways

- **Modern Web Guidance 1.0** gives AI coding agents access to 200+ curated guides covering HTML, CSS, JavaScript, accessibility, and performance. Chrome released the stable version on November 10, 2026, with Firefox and Edge joining the project. 
- **Your browser support policy shapes the code.** The skill uses Baseline compatibility data and project instructions to help an agent decide when to adopt a native feature, add a fallback, or load a polyfill conditionally. 
- **Chrome reports a rise from about 51% to 91%** on its web development checks when agents use the skill. A trial in a real repository can show which improvements carry over to your components and browser tests. 

## What Is Modern Web Guidance?

Modern Web Guidance is an open-source agent skill and command-line tool for frontend development. When an agent encounters a task such as making a modal keyboard-accessible, it can look up a guide with implementation patterns, browser support details, and fallbacks. Teams from Chrome, Edge, Firefox, and MDN steward the repository alongside community contributors. 

The CLI combines **BM25 keyword search** with **local semantic search**. Keyword matching helps with exact API names such as `showModal()`. Semantic matching helps when a prompt describes the desired behavior, such as asking for confirmation before deleting an item. The agent retrieves selected guides by ID, keeping the rest of the catalog out of the model's context. 

Consider a modal that looks correct in a demo but lets keyboard focus leave the dialog. A native `<dialog>` opened with `showModal()` makes the rest of its document inert. The component still needs an accessible name, sensible initial focus, and a test that confirms focus returns somewhere useful on close. If the dialog runs inside an iframe, the browser makes only the iframe's document inert. 

## How to Install Modern Web Guidance in Codex or Claude Code

From your project root, run the recommended interactive installer and choose your coding agent. See the [official setup guide](https://developer.chrome.com/docs/modern-web-guidance/get-started) for other installation methods. 

```bash
npx modern-web-guidance@latest install
```

For **Codex CLI**, use the marketplace route if you manage skills through Codex plugins. 

```bash
codex plugin marketplace add GoogleChrome/modern-web-guidance
codex plugin add modern-web-guidance@googlechrome
```

For **Claude Code**, use the Chrome team's marketplace. If you installed the early preview through `claude-plugins-official`, follow the [repository's migration instructions](https://github.com/GoogleChrome/modern-web-guidance#updating) to receive current releases. 

```bash
claude plugin marketplace add GoogleChrome/modern-web-guidance
claude plugin install modern-web-guidance@googlechrome
```

To inspect what an agent can retrieve, try a search and open a documented guide directly. 

```bash
npx modern-web-guidance@latest search "animate a dialog modal backdrop"
npx modern-web-guidance@latest retrieve animate-to-from-top-layer
```

## Set a Browser Support Policy Before Generating Code

Modern Web Guidance defaults to **Baseline Widely available**, which describes features interoperable across the Baseline browser set for at least 30 months. Record your project's target in `AGENTS.md` or `CLAUDE.md`, along with any requirements for older iOS releases, embedded WebViews, or a fixed browser fleet. Embedded browsers and assistive technologies need their own checks. 

| Situation | Implementation rule |
| --- | --- |
| The feature meets the project's browser support target | Use it directly and test the user interaction. |
| An unsupported browser can safely skip a visual enhancement | Keep a usable default. Use `@supports` when related styles depend on the feature. |
| An unsupported browser would lose a core action | Feature-detect it and provide an equivalent interaction or load a polyfill where needed. |

A browser can skip a modal's opening animation while preserving the user's task. An explicit **Cancel** button also keeps dismissal available when optional backdrop-click behavior is unsupported. Check Escape, initial focus, focus restoration, and reduced motion on the browsers your users run. 

Make those acceptance criteria explicit in the prompt.

```text
Use Modern Web Guidance to review the account settings dialog.
Read the repository's browser support policy and reuse its dialog component if available.
Identify any browser-specific fallback before editing.
Verify keyboard opening, initial focus, Escape and Cancel dismissal, focus restoration, and reduced motion.
```

## Scan an Existing Frontend for Legacy Patterns

Version 1.0 adds `legacy-scan`. It matches patterns in source code and gives the agent criteria for verifying them in context. The documented launch scope covers about one fifth of the guide catalog. The remaining guides are available through regular lookup. 

```bash
npx modern-web-guidance@latest legacy-scan src --json
```

Start with one directory and ask the agent to verify each candidate before editing. Repeated `scrollHeight` reads in a textarea's input handler may be a candidate for `field-sizing: content`. The same property may help calculate layout in a virtualized list. For the textarea, check minimum height, maximum height, and overflow in browsers with and without native support before removing the existing sizing logic. 

## What the Benchmarks Measure

Chrome's [public evaluation dashboard](https://googlechrome.github.io/modern-web-guidance-src/) publishes coding tasks, per-job results, and Playwright grading details. On the subset of checks for feature detection and browser fallbacks, Chrome reports **43% passing without guidance and 87% with it**. Those percentages describe the selected tasks and graders. Automated accessibility checks cover behaviors such as focus and keyboard support, so add manual and assistive-technology testing for the interactions your users rely on. 

The published **note inc.** case study shows why prompting matters. Across 180 runs on clones of its Next.js codebase, one agent scored **60.8% with no guidance, 76.5% with the skill available, and 94.0% when explicitly prompted to consult it**. A second agent scored **75.8%, 86.2%, and 90.0%** under the corresponding conditions. The study assessed six UI scenarios against 19 criteria using automated Chromium and WebKit tests. 

For a pilot, use the same model version, starter commit, and acceptance tests. Compare runs with the skill absent, installed, and explicitly requested. Record whether the agent retrieved a guide, which browser tests passed, whether it added runtime dependencies, and how many reviewer corrections the patch needed. That gives you a way to distinguish an agent skipping the guide from an implementation that still needs work after reading it.

## Does Modern Web Guidance Work Offline?

Guide search and retrieval run locally once the package is available. The CLI also documents anonymous telemetry for events such as guide retrieval and agent-generated search terms. Set `DISABLE_TELEMETRY=1` in the environment that launches your agent to disable Modern Web Guidance telemetry. The coding agent's model provider and network settings are configured independently. 

## How Does It Fit with Chrome DevTools for Agents?

Modern Web Guidance supplies implementation advice. Chrome DevTools for agents provides runtime inspection and performance tracing in Chrome. For example, a guide can help choose an image-loading strategy, and a trace can identify the Largest Contentful Paint element and show when it renders. Run compatibility checks in the other browsers your project supports and compare field performance after rollout. 

## Conclusion

Install Modern Web Guidance in one frontend repository and document its browser targets. Pick a component with a concrete acceptance test, such as a modal that must dismiss by keyboard and restore focus. Ask your agent to consult the relevant guide, then run the same browser checks before and after the change. Use those results to decide which frontend tasks should explicitly invoke the skill.
