---
title: "Modern Web Guidance 1.0 Lifts Coding Agents 39 Points, and Their Token Bills Too"
description: "Chrome shipped Modern Web Guidance 1.0 with Firefox and Edge on board. Its dashboard shows a 39 point lift, graders built around Chrome's own patterns, and 4k to 16k extra tokens per task, plus how I would roll it out."
author: "Jahanzaib Ahmed"
date: 2026-11-11
category: "ai-agents"
readingTime: "8 min read"
tags: ["ai news", "modern web guidance", "chrome", "coding agents", "claude code", "web development"]
canonical: https://www.jahanzaib.ai/blog/modern-web-guidance-coding-agents
source: https://www.jahanzaib.ai
---
# Modern Web Guidance 1.0 Lifts Coding Agents 39 Points, and Their Token Bills Too

Chrome released [Modern Web Guidance 1.0](https://developer.chrome.com/blog/modern-web-guidance-v1) on November 10, 2026, with Firefox and Edge now backing it. It is a set of agent skills plus a local CLI that hands coding agents expert web platform guides and Baseline browser data before they write code. Chrome's public eval dashboard shows agents passing 91% of its web checks with the guidance and 52% without. It also shows the price the announcement leaves out: in the November 11 runs, 32% to 110% more uncached tokens per task.

## What Chrome shipped in Modern Web Guidance 1.0

After a May preview at Google I/O, version 1.0 adds four things, per Philip Walton's announcement:

-   A modernization workflow that scans old code for legacy patterns.
-   More guides, aimed at hundreds of verified AI knowledge gaps.
-   Expert review of every guide, with user facing guides tested on real assistive technologies.
-   Eval coverage for every guide, on a [public eval dashboard](https://googlechrome.github.io/modern-web-guidance-src/).

The [GitHub README](https://github.com/GoogleChrome/modern-web-guidance) now lists the Chrome, Edge, Firefox and MDN teams as stewards, with the code under Apache 2.0 and the guides under CC BY 4.0. The npm package reached version 1.0.0 the same day. Installing it is one command from your project folder:

```
npx modern-web-guidance@latest install
# already on a preview build?
npx modern-web-guidance@latest update
```

It is in agent plugin marketplaces too; for Claude Code, the [official docs](https://developer.chrome.com/docs/modern-web-guidance) give `claude plugin install modern-web-guidance@claude-plugins-official`.

## How the skill finds the right guide

When a task touches the web platform, the agent runs `modern-web-guidance search "<query>"`. The CLI matches the query against its guides with an offline embedding model and BM25 search. Nothing leaves the machine and no key is needed. The agent then runs `retrieve <guide-id>` and pulls one guide into its [context window](https://www.jahanzaib.ai/glossary/context-window), with code patterns, gotchas and fallbacks.

Guides carry Baseline data, so advice matches the browsers you support. Origin Trial and volatile single engine features stay locked until you opt in through a `.mwgrc` file you commit for the team. And fallbacks stay small: the README prefers case specific code under 50 lines to heavy polyfills.

The gaps it targets come from Chrome's own evals, which found frontier models [falling short](https://developer.chrome.com/blog/modern-web-guidance-v1#reinforce_best_practices_that_models_often_miss) on focus and `inert` management, reduced motion, accessible form validation, dialog transitions, main thread scheduling, layout shift, HTML sanitization, strict Content Security Policies and passkeys. Feeding that knowledge in at the right moment is context engineering, a theme of my breakdown of [Google's vibe coding whitepaper](https://www.jahanzaib.ai/blog/google-vibe-coding-whitepaper-explained).

## Reading the public eval dashboard

The dashboard runs Claude Code, Codex CLI and Antigravity CLI on identical tasks with and without the guidance, then grades the output in a real browser with Playwright assertions. Task prompts never mention the skill, so the agent has to recognize when a guide applies.

![Modern Web Guidance eval dashboard showing a 39 point lift, from 52% to 91% best practice pass rate across 1,104 task runs](https://cdn.sanity.io/images/qajb7q5q/production/7f994da33441da8b3e2bd055d93279f1651bbf44-1600x571.png?w=1200&q=75&auto=format&fit=max)

_Chrome itself notes the accessibility score (56% to 92%) is not a full WCAG audit, so treat it as a floor._

That headline pools the latest run of each model from the past week. Claude Code's 50% to 91% blends a Sonnet 5.5 run and an Opus 5.5 run, so per run numbers below differ slightly.

One caveat. Chrome wrote both the guides and the graders, so the score partly measures how closely an agent follows Chrome's preferred pattern. In the paired run below, the first assertion requires menu triggers built with `commandfor` and `command="toggle-popover"`. An accessible menu built another way would still fail it. I count the lift as real, but it is a lift toward one house style.

![Paired eval run for an action menu task in Claude Code: 0 of 25 checks passed without Modern Web Guidance, 14 of 25 with it](https://cdn.sanity.io/images/qajb7q5q/production/268d49d5d59c0dbb766b10ff4b116812fff025b5-1600x780.png?w=1200&q=75&auto=format&fit=max)

_One November 11 run, not an average: guided Claude Code passed 14 of 25 checks on this nested menu, up from zero._

## The token and time cost of better code

The dashboard lists median uncached tokens and duration for both arms of every run:

| Agent, model and run | Pass rate | Median uncached tokens | Median time |
| --- | --- | --- | --- |
| Codex CLI, gpt-6.1-sol, Nov 11 | 49% to 84% | 14.3k to 30.1k (+110%) | 1m 35s to 1m 52s |
| Claude Code, claude-opus-5-5, Nov 11 | 54% to 92% | 28.2k to 37.2k (+32%) | 50s to 58s |
| Antigravity CLI, gemini-4-argon, Nov 11 | 57% to 97% | 46.4k to 62.7k (+35%) | 3m 33s to 3m 15s |
| Claude Code, claude-sonnet-5-5, Nov 9 baseline | 44% to 89% | 24.5k to 28.5k (+16%) | 21s to 24s |
| Claude Code, claude-opus-5-5, Nov 9 baseline | 58% to 94% | 27.4k to 34.9k (+27%) | 48s to 56s |

That is roughly 4k to 16k extra uncached tokens per task. Codex's 110% looks large because it starts lean: even guided, it uses fewer tokens than Antigravity does unguided.

My read: pay it, but choose the model with the guidance in mind. In the November 9 baseline runs, Sonnet 5.5 with the guidance passed 89% of checks on 28.5k tokens in 24 seconds. Opus 5.5 without it passed 58% on 27.4k tokens in 48 seconds. The task counts differ slightly (215 and 221), so treat it as a strong hint, not a controlled comparison. Opus with the guidance still leads, 94% to 89%, for about 6k more tokens and more than twice the time. Cost per task is what matters, which is why I modeled a 40 turn loop in my [GPT-6 Sol and Opus 5.5 cost comparison](https://www.jahanzaib.ai/blog/gpt-6-sol-luna-pricing-prompt-caching-agent-costs). Then track spend by team, which is what [Rippling's audit of its own token bill](https://www.jahanzaib.ai/blog/rippling-ai-spend-console-token-roi) came down to.

## Legacy scan: modernizing code that already works

The [modernization workflow](https://developer.chrome.com/docs/modern-web-guidance/modernization-workflow) is the 1.0 feature I would try first, because, as Chrome puts it, most web development happens in existing codebases. Ask your agent to "modernize" a folder and it runs `npx modern-web-guidance legacy-scan <path> --json`. That scan parses HTML, CSS, JavaScript, TypeScript, framework components and `package.json` locally with AST, DOM and CSS parsers, with zero model calls.

![Modern Web Guidance modernization workflow: static scan, agent verification, plan review, refactor, then rescan and test](https://cdn.sanity.io/images/qajb7q5q/production/d45e11e6d94b8bab71e685dd54cc17c107008682-1376x768.png?w=1200&q=75&auto=format&fit=max)

_The scanner finds candidates cheaply; the agent then reads the surrounding code and drops intentional fallbacks._

Chrome tuned the rules on about 45,000 open source repositories, graded on a held out half. A rule ships only at 80% matcher precision or better, and 90% after verification. Each match carries keepWhen and dropWhen rubrics, so the agent drops cases such as a scrollHeight read inside virtual scrolling. There is deliberately no `--fix` flag. Today the scan covers about 20% of roughly 200 guides, and CI integration is still in development.

| Legacy pattern it flags | Modern replacement |
| --- | --- |
| JavaScript textarea resizing on every keystroke | CSS field-sizing: content |
| Enter key submit handlers that break Japanese, Chinese or Korean input | An isComposing guard |
| max-height: 9999px accordion animations | interpolate-size: allow-keywords |
| CDN scripts without Subresource Integrity | integrity and crossorigin attributes |

## Pairing it with Chrome DevTools for agents

Guidance shapes the code up front. [Chrome DevTools for agents](https://developer.chrome.com/docs/devtools/agents) checks how it runs afterwards, letting the agent trace performance on a throttled CPU, record an animation, test `prefers-reduced-motion` and watch memory. Chrome's suggested target is no main thread task over 50 milliseconds, so nothing feeds a poor INP score.

![Modern Web Guidance flow: prompt, local guide search, expert guide, agent writes code, Chrome DevTools check loop, verified change](https://cdn.sanity.io/images/qajb7q5q/production/77d68f5244d26a64aed01dc06864c8ad7becf1d2-1376x768.png?w=1200&q=75&auto=format&fit=max)

_The guide steers the first draft and the DevTools loop repeats until the trace meets the target, which Chrome says takes fewer turns._

In Claude Code, add the marketplace with `/plugin marketplace add ChromeDevTools/chrome-devtools-mcp`, then run `/plugin install chrome-devtools-mcp@chrome-devtools-plugins`. Give the browser its own profile, for the reasons in my [Playwright MCP setup guide](https://www.jahanzaib.ai/blog/playwright-mcp-server-setup).

## Results from four early adopters

| Team | Setup | Reported result |
| --- | --- | --- |
| Pensionbazaar and Policybazaar | Both tools for new pages, DevTools for audits | New pages in hours instead of about four days; 92% less manual audit effort |
| WeTV | A CI agent diagnosing performance regressions | 90% of failed checks fixed automatically; four hours down to 30 minutes |
| note inc. | Next.js codebase with its own design system | 61% to 94% on modern web checks over 180 runs |
| MetaMask | A Cursor Automation review bot with a three line prompt | About 480 pull requests in five weeks, comments on 64, 43 of 102 findings fixed, median 15.2 minutes from comment to fix |

The note inc. study has the finding I would act on first. With the skill merely present, its primary model rose from 60.8% to 76.5%, and reached 94.0% only when the prompt told the agent to consult the guidance. Its second model gained less from the prompt (75.8%, 86.2%, 90.0%). Chrome's evals never name the skill and still see a 39 point lift, so naming it is not required. In note's production repository it added about 18 points for one model, which is worth one line in `AGENTS.md`.

> The issues MWG caught would have otherwise required a human reviewer familiar with these modern web techniques.
> 
> Francis Nepomuceno, UX Engineer at MetaMask, [Chrome announcement](https://developer.chrome.com/blog/modern-web-guidance-v1)

## My rollout plan for a frontend repository

On a production codebase, cheapest step first:

1.  **Install it in one frontend repo.** Commit the `.mwgrc` file.
2.  **Name it in your agent instructions.** Tell the agent in `AGENTS.md` or `CLAUDE.md` to consult Modern Web Guidance for HTML, CSS and browser API work.
3.  **Scan one folder, plan only.** Review the modernization plan before letting the agent refactor and rescan with your tests.
4.  **Add a pull request reviewer.** MetaMask's bot shows a short prompt is enough; Chrome says most of its fixes were accessibility, semantics and forms issues that linters miss.
5.  **Verify at runtime.** Add DevTools for agents and a performance target, and track pass rates in your own [eval harness](https://www.jahanzaib.ai/glossary/eval-harness), not only Chrome's dashboard.

If you want this wired into your repository and CI, measured against your own baseline, that is the kind of [AI agent work I build](https://www.jahanzaib.ai/agents).

[Video: Modern Web Guidance in your AI workflow: What is Modern Web Guidance?](https://www.youtube.com/watch?v=PsrHq5F_BAc)

_Chrome's launch overview: why agents reach for outdated code, and how Baseline targets shape the advice._

## Frequently asked questions

### What is Modern Web Guidance?

Modern Web Guidance is an open source set of agent skills from Chrome, now backed by Firefox, Edge and MDN. It gives coding agents expert reviewed guides on modern HTML, CSS and browser APIs, with Baseline compatibility data, through a local CLI the agent calls before it writes web code.

### Is Modern Web Guidance free to use?

Yes. The code is Apache 2.0 licensed, the guides are CC BY 4.0, and the CLI runs locally with no API key. The real cost is extra context: in Chrome's November 11 eval runs, guided agents used 32% to 110% more median uncached tokens per task than unguided ones, depending on the agent.

### Does Modern Web Guidance work with Claude Code and Cursor?

Yes. Chrome lists plugin marketplace installs for Claude Code, Cursor, Codex, Copilot, Antigravity and others, and its docs also give an `npx skills add` route for other agents. Claude Code is one of three agents on the public eval dashboard, where Opus 5.5 went from 54% to 92% in the November 11 run.

### How is legacy-scan different from a linter?

It finds candidates with local parsers, like a linter, but every match carries a rubric the agent checks against the surrounding code, which drops intentional fallbacks and lookalikes. There is no automatic fix flag: the agent proposes a plan, refactors with the matching guide, then rescans and runs your tests.

## Related

- [Claude Got Past a Fetch Tool's URL Limit With a Link Shortener](https://www.jahanzaib.ai/blog/claude-unintended-actions-url-shortener-fetch-tool)
- [Microsoft Decision-1 Matches Jev on Price and API Shape](https://www.jahanzaib.ai/blog/microsoft-decision-1-foundry-jev)
- [How to Choose an LLM Router for AI Agents](https://www.jahanzaib.ai/blog/llm-router-ai-agent-routing)

---

Canonical HTML version: https://www.jahanzaib.ai/blog/modern-web-guidance-coding-agents
