Modern Web Guidance 1.0: Chrome, Edge and Firefox Team Up to Stop Agents Writing Legacy Web Code
Chrome shipped Modern Web Guidance 1.0 on November 10, 2026: a free, open-source skill pack that teaches coding agents modern web features instead of legacy JavaScript patterns. It adds a legacy-code scanner, 203 guides covering 250 features, and Firefox and Edge as co-maintainers. The case-study numbers are impressive, but they are vendor-reported and preview-era, so treat them as a hypothesis to test on your own project.

The short version: a free crash course in modern front-end for your agent
On November 10, 2026, Google's Chrome team announced on the Chrome for Developers blog that Modern Web Guidance has reached its stable 1.0 release. This is not a new model, and not a new coding agent. It is a free, open-source pack of skills you install into the coding agent you already use, so it stops writing web code the old way. Chrome showed an early preview at Google I/O in May 2026; six months later, it is officially out of preview. Installation is one command, run from your project directory: npx modern-web-guidance@latest install. Or install it straight from the plugin marketplaces of Claude Code, Codex, Cursor, Antigravity, Copilot, WebStorm, Kimi Code, and Grok Build.
Put simply, here is the problem it solves: coding agents today write code fast, but the front-end code they write is often "it runs, but it is not good enough." They reach for a pile of JavaScript to do something the browser already supports natively. They write dialogs a keyboard cannot use. They miss accessibility details. And they stuff in polyfills for old browsers you never needed to support in the first place. Modern Web Guidance feeds the agent the knowledge of what the modern browser can actually do and what the right approach looks like, so it knows the correct answer before it starts typing.
My verdict up front: this is an update worth installing, and it costs almost nothing — free, open source, one command. But it is not magic. The only genuinely new thing in 1.0 is the modernization workflow that checks old code, and that scanner currently covers only about a fifth of the material. As for the success-story numbers in Chrome's blog post, the ones with 90% all over them, they are all self-reported by the vendors involved. Read them, but do not treat them as a promise about your own project.
"It runs" and "it is well written" are two different things
Chrome's post opens with a blunt point: the latest frontier coding models can "usually produce something that works." But ask a web expert to review AI-generated code, and they can almost always find ways to make it faster, more accessible, or more secure. That is a fair portrait of vibe coding as it stands today: the page renders, the buttons work, the feature functions — and the code underneath is a mess.
Where does the problem come from? Chrome's explanation is that models learn mostly from training data, and training data is full of old code. Years of tutorials, Q&As, and open-source projects teach the ways of their era: build everything with JavaScript, hand-roll your own dialogs, hand-roll your own animations, hand-roll your own form validation. Models learn from that and write the same old patterns. Worse, the result looks fine in your own browser, so you never notice it took the long way around.
Chrome groups the mistakes models most often make into four areas. First, accessibility: keyboard focus management, reduced-motion support, and accessible form validation — where errors cost the most. The post adds a pointed aside: bad ARIA is worse than no ARIA at all, because it sends screen readers down the wrong path. Second, user experience: swipe and touch gestures, dialog and popover transitions, and light/dark theme implementations. Third, performance: main-thread task scheduling, offscreen rendering isolation, and layout shift prevention. Fourth, security: safe HTML sanitization, strict Content Security Policies, and passkey credential management.
These pitfalls share one trait: you cannot spot a single one of them by checking whether the page loads. The page opens, the buttons click, the animation plays — and the problems all hide on paths only keyboard users, screen reader users, low-end phone users, or attackers ever walk. That is why this deserves a skill pack of its own. It does not fix "can it be written." It fixes "is it good enough once written."
So what is actually new in 1.0
From the May preview to the November 1.0, Chrome lists four changes. First, the new modernization workflow — the scanner for existing code, which gets its own section below, and the only genuinely new feature in this release. Second, an expanded guide library covering "hundreds of verified AI knowledge gaps," each one expert-reviewed with a cross-browser solution. By the project's own README, 1.0 ships 203 use-case guides covering 250 modern web features: 140 on CSS and layout, 74 on JavaScript and APIs, and 36 on HTML and DOM. Third, deeper human review for every guide: a tech lead signs off on each subject area, and the user-facing guides went through a dedicated accessibility review, tested with real assistive technologies. Fourth, full evaluation coverage: every guide has a corresponding public evaluation, with a public dashboard anyone can check to see the difference before and after installing the skills.
There is one more change that is not on the feature list but carries real weight: this has gone from a Chrome-only project to a cross-browser one. Firefox and Edge have formally joined, working with Chrome to maintain the project and contribute to it, so the guides are genuinely cross-browser rather than just good for Chrome. Chrome frames this as building on the earlier shared work on Baseline — the common standard that labels how widely a given web feature works across browsers.
Baseline is worth a few extra words, because the whole of Modern Web Guidance stands on it. Many modern features are not unusable; the problem is you do not know how many of your users' browsers can run them. The guides embed Baseline and browser compatibility data, and recommend features based on your project's browser support targets: native features where they fit, and fallbacks where they do not. You can even write one line in your project's AGENTS.md or CLAUDE.md — "This project's Baseline target is Baseline 2024" — and the agent picks its approach from that setting. For vibe coders, that turns "compatibility," which used to be a judgment call, into a line in a config file.
The most useful new thing: a health check for old code
As noted above, the one truly new feature in 1.0 is the modernization workflow. The reasoning is simple: most front-end work does not happen in brand-new projects. It happens in codebases that have accumulated years of outdated workarounds, unnecessary dependencies, and polyfills nobody needs anymore. If you never open them up, they just keep dragging the project down.
Here is how the workflow works: it scans your existing HTML, CSS, JavaScript, and package.json, finds opportunities to upgrade safely, and then walks your agent through the changes. A follow-up Chrome post on November 11 breaks the flow into four steps: scan, verify, report a plan, and modernize. You can trigger it by telling your agent "/modern-web-guidance Modernize the code in this directory," or by running the legacy-scan command directly in your terminal.
Now the cold water: the first version of the scanner uses static analysis and checks only a small set of confirmed patterns. According to Chrome's documentation, it currently covers roughly 20% of the roughly 200 guides. In other words, it catches the most common, most certain legacy patterns; the subtler old patterns in your code are still invisible to it. Chrome admits the narrow start is deliberate — predictable results first, broader coverage later. The plan is to eventually add agentic audits, where your agent reasons about your code directly instead of just matching known patterns.
That sets the right way to use it: treat it as a free first checkup, not a full audit. Run the scan, fix the batch of definite problems it flags, and still get a human review for everything else. The good news is the scan itself is free; a run costs a few minutes. The bad news is that a clean scan only means the 20% it knows how to check came back clean. It never looked at the other 80%.
Those shiny numbers deserve a discount first
The most eye-catching part of Chrome's blog post is the four company success stories, with numbers that look almost too good. Here they are, as reported — and then how to read them.
Pensionbazaar, a retirement planning platform from Indian fintech company Paisabazaar, paired Modern Web Guidance with Chrome DevTools for agents to build new pages, cutting turnaround by more than 90% — from about four days to a few hours — and reducing UI bugs on new screens by over 90%. Its sister platform Policybazaar, with more than 97 million registered customers, used the same tools to automate performance audits across about 30 high-traffic landing pages, cutting manual auditing effort by 92%. WeTV, Tencent's international video streaming platform, wired an AI coding agent into its CI/CD pipeline; the agent now automatically diagnoses and resolves 90% of failed performance checks, cutting debugging and resolution time by 87%, from four hours to 30 minutes. Note inc., one of Japan's largest creator platforms with over 90 million monthly active users, ran a 180-run evaluation on its production codebase: pass rates on modern web checks rose from 61% to 94%, and proper LCP image prioritization improved by 28% across 431 merged PRs. MetaMask's story is the most instructive: it runs Modern Web Guidance as an automated review bot on every pull request to its open-source browser extension, configured with a three-line prompt. In its first five weeks the bot reviewed roughly 480 pull requests and commented on 64 of them; engineers fixed 43 findings — mostly accessibility, HTML semantics, and forms issues that linters do not catch — with a median time of 15 minutes from comment to fix.
How much of this should you believe? On the believable side: these are not lab numbers invented by Chrome. They come from real companies and real projects, each with a named person behind it. The MetaMask story is especially credible because it reports process numbers — how many PRs were reviewed, how many findings were fixed — rather than a vague "improved by X%."
On the side that needs a discount: first, these are success stories Chrome chose to publish; the projects where it worked poorly or not at all are not in the post. That selection bias is built into the format. Second, the percentages all have different denominators — some measure time, some measure bug counts, some measure check pass rates — so they cannot be compared with each other. Third, and most important, most of these stories come from the preview period. They are not a promise that installing 1.0 today will reproduce them. Note's 61% to 94% came from its own production codebase and its own 180 evaluation runs; on your project, the result will be different, not the same.
There is one more set of numbers, from Google's public evaluation dashboard: nightly runs completed by November 8 show agents without the guidance passing 56% of automated checks on average, and 88% with it. But note the caveat: those runs used the preview-era guidance, not the 1.0 release, and the evaluation is Google's own — it wrote the tasks and the scoring. It shows the direction clearly enough — installing it is measurably better than not installing it, and by a lot — but it is not a promise about your project. The right attitude is to treat it as a hypothesis worth ten minutes of your time to test, not a result already delivered.
Chrome could not say this alone, so it brought in its rivals
The most interesting thing in this release is not a feature. It is one sentence: Firefox and Edge have joined. Browser vendors cooperating on web standards is nothing new — Baseline itself was a joint effort — but a skill pack started by Chrome, teaching AI to write code, being maintained together with its competitors, is a first.
Why does it matter? Because one of the worst habits of AI coding tools is that they only really know Chrome. Chrome's documentation dominates the training data, so the code that comes out quietly assumes you are using Chrome. Open it in Firefox or Safari and the experience degrades. For vibe coders, that means your agent writes code with "Chrome users" in mind, not "all browser users."
Firefox and Edge joining corrects that, at least in direction: the guides' solutions get reviewed cross-browser, and recommended features are checked against Baseline data instead of just Chrome support. Under the project's governance document, Chrome holds two of six owner seats, Edge holds one, Mozilla holds one, and the remaining two go to independent web platform experts. MDN is involved too, on the documentation side.
But there is a gap: Apple is not in it. Safari is the third major browser engine, and every iPhone user reaches your page through it. Neither Chrome's blog post nor the repository mentions Apple taking part, and none of the governance seats belongs to Safari. So "cross-browser" currently means Chrome, Edge, and Firefox plus MDN. Code your agent writes will still need you to test it on Safari yourself. That is not a reason to skip the tool, but it is worth knowing before you install it.
How to install it in your agent
Installation is the easy part. Run npx modern-web-guidance@latest install from your project directory and an interactive wizard walks you through it; if you installed the preview, run npx modern-web-guidance@latest update to move to 1.0. Beyond the CLI, you can install and update it directly through most popular coding agent plugin marketplaces: Claude Code, Codex, Cursor, Antigravity, Copilot, WebStorm, Kimi Code, and Grok Build are all on the supported list — their logos are the image on the announcement post.
Once installed, how does it work? Two things matter. First, the guides are fetched on demand: the agent looks up the relevant guide when it hits a specific task, instead of stuffing all 203 guides into context at once. That saves tokens and keeps irrelevant advice out of your code. Second, search runs locally and offline — no API keys, no sending your code to a third-party service to look things up. For indie developers, that means no new bill and no code leaving your machine for documentation lookups.
Two details are worth copying. First, write your Baseline target into your project's AGENTS.md or CLAUDE.md — for example, "This project's Baseline target is Baseline 2024" — so the agent has a clear setting to work from instead of guessing every time. Second, pair it with Chrome DevTools for agents: Modern Web Guidance tells the agent the right approach before it writes, and DevTools for agents verifies the result by actually running it — tracing performance, recording animations, hunting memory leaks. Chrome's own framing is that one handles "write it right" and the other handles "prove it runs," and together the agent reaches a better result in fewer turns. As an example, DevTools for agents can run a performance trace on a simulated low-end CPU to see whether any JavaScript task blocks the main thread for more than 50 milliseconds — a common cause of poor INP — while Modern Web Guidance tells the agent how to break those long tasks apart.
One more thing: the guides themselves work fine as reading material. Chrome says many developers told them the guides are useful on their own, as a learning resource. For vibe coders, this is an underrated use: you do not need to become a front-end expert first, but every time your agent cites a guide, you can click through and see why it recommends what it recommends. After a few rounds of that, your own instinct for "how modern front-end should be written" starts to form.
One line of advice for vibe coders: install it, but do not expect it to do your reviewing for you
Back to the verdict at the top. This is worth installing, for a simple reason: it is free, open source, one command, no new bill — and it patches exactly where vibe coding most often goes wrong: code that runs, but is not modern enough, not accessible enough, not fast enough. You do not need to learn front-end first to use it; it exists precisely so that people who do not know front-end step on fewer of the invisible rakes.
But know its limits. First, it is not a reviewer. The scanner covers about 20% of the guides; the rest still needs your own testing, human review, and verification runs with DevTools for agents. Second, its numbers belong to other people, not you. Note's 61% to 94%, WeTV's 90%, MetaMask's 43 fixed findings — all from someone else's codebase and someone else's process. The only reliable way to know whether it helps your project is to run it on your project, see what it actually flags, and check whether the fixes genuinely make things better. Third, Safari is not on the partner list, so Apple users still need an extra look from you.
In the end, Modern Web Guidance solves one very specific problem: AI-written code is not missing features; it is missing judgment. It packages what browser makers and standards experts know about "how this should be written now" into a form an agent can use directly. That step is the right one. The rest of the road is still yours to walk: run it, test it on real devices, get a real person to review it. A tool can keep you off the wrong turns, but it cannot walk to the finish line for you.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.