Chrome Launches Tool to Stop AI Models Emitting Bloated Web Code

Unlock modern web capabilities in your AI coding workflows — Chrome for Developers

Chrome for Developers

AI coding assistants default to bloated, obsolete JavaScript because their training data reflects legacy browser constraints, requiring browser-directed guidance to deploy native platform primitives.

AI-assisted summary of Unlock modern web capabilities in your AI coding workflows — original source. Check the original for full context.

Source published:

Key ideas

  • AI coding agents routinely default to outdated, bloated implementations—such as generating 172 KB of JavaScript for a dropdown menu that modern web platform primitives can deliver in under 3 KB with zero JavaScript. (0:00)
  • Chrome launched Modern Web Guidance (`npx modern-web-guidance install`), an open, framework-agnostic skill package that indexes Chrome-vetted best practices into developer coding agents via local semantic search. (5:47)
  • The guidance architecture couples cutting-edge platform primitives with Baseline-driven cross-browser fallbacks, allowing agents to automatically emit or omit fallbacks based on targets declared in `AGENTS.md`. (13:05)
  • Chrome validates the guidance library daily against frontier models (Gemini 3.1, Claude Opus 4.7, and GPT 5.5) across 554 assertions, planning to deprecate specific guides once unguided models reliably internalize modern patterns. (14:31)

Detailed notes

## Background Presented by Philip Walton for Chrome for Developers at Google I/O 2026 and published on YouTube on May 21, 2026, this session addresses the gap between cutting-edge web platform capabilities and the code generated by AI assistants. The talk details how Chrome is equipping coding agents with up-to-date platform guidance, browser support baselines, and tailored fallback strategies so developers receive modern, project-appropriate code.

## TL;DR Philip Walton demonstrates how contemporary AI coding agents default to bloated legacy code—such as generating 172 KB of JavaScript for a dropdown menu that modern CSS can achieve in under 3 KB—due to outdated training data, knowledge cutoffs, and overcautious compatibility assumptions. To solve this, Chrome introduced Modern Web Guidance, an open CLI tool that semantically matches developer prompts against a vetted library of task-oriented guides with modern standards and Baseline-aware fallbacks. The system is validated through a daily 554-assertion evaluation testbed against frontier models like Gemini 3.1, Claude Opus 4.7, and GPT 5.5. Through live side-by-side demos in Antigravity, Walton shows how guided generation replaces clunky JavaScript listeners with native scroll-driven animations, view transitions, and scroll snap points, producing touch interactions that feel indistinguishable from native apps on both Android and iOS devices.

## Atmosphere & style The presentation blends the technical depth of an engineering deep-dive with the spontaneous energy of a live Google I/O keynote. Walton speaks with an easygoing, self-deprecating wit—laughing off phone buzzes about picking up his son from preschool while openly acknowledging the perils of live AI code generation. The narrative arc builds an engaging contrast between the frustrating, unnatural feel of generic AI-generated interfaces and the satisfying, tactile breakthrough of watching native-grade 60fps gestures snap smoothly into place across real physical hardware.

## Bulletin - [00:00](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=0s) AI coding agents routinely default to outdated, bloated implementations—such as generating 172 KB of JavaScript for a dropdown menu that modern web platform primitives can deliver in under 3 KB with zero JavaScript. - [05:47](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=347s) Chrome launched Modern Web Guidance (`npx modern-web-guidance install`), an open, framework-agnostic skill package that indexes Chrome-vetted best practices into developer coding agents via local semantic search. - [13:05](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=785s) The guidance architecture couples cutting-edge platform primitives with Baseline-driven cross-browser fallbacks, allowing agents to automatically emit or omit fallbacks based on targets declared in `AGENTS.md`. - [14:31](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=871s) Chrome validates the guidance library daily against frontier models (Gemini 3.1, Claude Opus 4.7, and GPT 5.5) across 554 assertions, planning to deprecate specific guides once unguided models reliably internalize modern patterns.

## Key takeaways - [01:54](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=114s) Current AI coding agents suffer from three structural failures: legacy code training bias, knowledge cutoff drifts on renamed specs, and overly conservative cross-browser compatibility defaults. - [01:54](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=114s) Models exhibit overconfidence on APIs they believe they know, generating obsolete drafts like `interesttarget` (renamed to `interestfor`) that fail silently in modern browsers without triggering live search. - [08:07](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=487s) Modern Web Guidance uses a local CLI semantic search across over 100 curated guides rather than dumping raw Markdown files into model context, preserving prompt tokens and retrieval accuracy. - [09:59](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=599s) Guides are authored around concrete developer use cases and user-facing intent rather than abstract API syntax, matching how engineers naturally prompt coding agents. - [11:40](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=700s) Each guide begins with an unconstrained, ideal modern implementation, followed by explicit fallback paths for features not yet categorized as Baseline Widely Available. - [13:05](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=785s) Configuring project browser requirements in `AGENTS.md` enables agents to cleanly discard legacy fallbacks when target runtimes (such as modern Electron releases) already support the modern APIs. - [14:31](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=871s) Daily automated evaluations spanning 554 assertions demonstrate that guided agents consistently outperform unguided frontier models on implementing modern web standards. - [17:44](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1064s) Chrome commits to shipping AI guidance documentation concurrently with every new platform feature reaching Chrome stable, collaborating with other browser vendors on cross-engine coverage. - [19:35](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1175s) While mobile web interfaces frequently look polished, they rarely feel native because unguided AI code uses abrupt event listeners rather than tracking continuous touch gestures. - [23:38](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1418s) Pairing CSS scroll-driven animations with CSS scroll snap points converts UI elements into scroll containers, unlocking native browser momentum, hardware acceleration, and touch-pinned physics without heavy JavaScript libraries. - [26:49](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1609s) Guided agents can orchestrate complex native app patterns—such as stack drilldown transitions, interactive swipe-to-back gestures, and parallax message headers—from high-level natural language prompts. - [31:25](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1885s) Real-device testing on Android and iOS confirms that modern CSS and view transition primitives deliver indistinguishable 60fps native feel across mobile engines without platform-specific code. - [33:32](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=2012s) New browser platform APIs only benefit end users when deployed in production; equipping AI coding agents with modern platform knowledge bridges the gap between standards and real-world codebases.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=0s) The 172 KB vs. 3 KB Mystery: How Modern AI Coding Recommends Legacy Web Code

Philip Walton opens with a direct visual comparison between two screen recordings of identical web demos. Both demos feature smoothly animated dropdown menus that slide in and out, boast full keyboard accessibility, support light dismiss, and work flawlessly across Chrome, Firefox, and Safari. Both were generated by an AI coding agent using the exact same underlying model and identical prompts. However, inspect the Network panel in Chrome DevTools and the architectural gap is startling: the default, out-of-the-box AI configuration delivered 172 kilobytes over the wire—minified, gzipped, and with production optimizations enabled, composed almost entirely of JavaScript. The alternative demo, created with one extra enhancement installed, shipped under 3 KB and executed entirely without JavaScript.

Walton concedes that the setup is somewhat contrived since production applications are rarely just isolated settings menus, and adding real-world application logic naturally requires JavaScript. Yet the core dilemma remains troubling for frontend engineering. Walton poses the central question of the talk:

> “Why are AI coding agents recommending a solution that requires almost 172 kilobytes of JavaScript when the same exact solution can be built in a way that requires no JavaScript at all and still works across browsers?”

[01:54](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=114s) Three Fundamental Failures of Current AI Coding Agents

While AI has transformed software development by letting engineers ship code at unprecedented speeds, Walton highlights the darker side of frontend generative AI. Many prominent web developers across social platforms routinely criticize the subpar HTML and CSS produced by popular agents. Despite rapid advancements across web standards over recent years, models almost never default to the newest web platform primitives. Most AI training corpuses reflect an era when engineers still had to account for legacy runtimes like Internet Explorer, entrenching obsolete workarounds into model weights.

Beyond historical bias, modern agents suffer from two additional structural defects: severe knowledge cutoffs and overly conservative cross-browser support logic. When Chrome launched more than 50 web platform features in a single year, models with older knowledge limits remained blind to them. While Retrieval-Augmented Generation (RAG) and search tools can offset unknown terms, models exhibit dangerous overconfidence on tasks they mistakenly believe they already master. Rather than querying the web, they spit out deprecated implementations or hallucinated drafts. Walton points to an agent attempting to implement a tooltip via the new Interest Invokers API: the model output `interesttarget`, a spec attribute proposed in 2023 that was renamed to `interestfor` shortly before shipping in Chrome, causing the code to fail silently in the browser. Furthermore, models avoid modern primitives out of exaggerated compatibility concerns, completely ignoring tools like Baseline that catalog cross-engine viability.

Walton summarizes the core diagnostic failures:

> “AI coding agents frequently recommend legacy patterns, even though better, more modern alternatives exist.”

- **Legacy pattern bias**: Training datasets heavily weighted toward historical codebases result in bloated JavaScript wrappers where modern HTML/CSS primitives suffice. - **Knowledge cutoffs and drift**: New or renamed standards (such as `interestfor` replacing `interesttarget`) fail silently because models generate obsolete syntax without performing retrieval. - **Overly defensive compatibility**: Agents deliver generic, one-size-fits-all recommendations instead of tailoring output to real-world browser support baselines.

[05:47](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=347s) Introducing Modern Web Guidance

To resolve these platform hurdles, the Chrome team created Modern Web Guidance—an expert-vetted package designed to feed Chrome's engineering standards and platform best practices directly into coding agents. Instead of tethering developers to a specific proprietary vendor, it operates as an open skill set compatible with any AI coding assistant or environment. The tool can be installed immediately via the command line or integrated through supported IDEs:

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

Walton acknowledges developer fatigue surrounding the deluge of AI skills hitting the market, emphasizing that many recent community releases amount to low-quality "slop." Modern Web Guidance represents more than six months of dedicated engineering by Chrome team members alongside contracted external subject-matter experts, backed by a long-term maintenance commitment from Google.

Walton underscores the fundamental design goal behind the tool's breadth:

> “And because these guides focus on core web platform features, they will work regardless of whatever framework or stack you're using, or anything like that.”

- **Broad compatibility**: Agnostic across front-end frameworks (React, Vue, Svelte, or vanilla web components). - **Two tiers of expertise**: Combines macro-level domain skills (accessibility, performance, UX, security) with granular platform feature guides. - **Ecosystem integration**: Available via standard npm invocation or native installation within leading developer IDEs.

```mermaid flowchart TD accTitle: Modern Web Guidance Agent Workflow accDescr: Diagram showing how a developer prompt triggers a local semantic search across guides before querying the model.

subgraph InputStage ["Input Stage"] U["Developer Prompt"] end

subgraph GuidanceLayer ["Modern Web Guidance CLI"] S{"Local Semantic Search<br/>(100+ Guides)"} M["Match Found:<br/>Append Relevant Guides to Context"] NM["No Match:<br/>Pass-through"] end

subgraph ModelStage ["AI Model Processing"] LLM["AI Model / Coding Agent"] OUT["Modern, Optimized Code Output"] end

U --> S S -->|"Matches Use Case"| M S -->|"No Matches"| NM M --> LLM NM --> LLM LLM --> OUT ```

[08:07](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=487s) Architecture: Local Semantic Search Over Markdown Sprawl

Walton breaks down the runtime architecture that differentiates Modern Web Guidance from ordinary skills packages. Typical AI skills rely on exposing individual, unindexed `SKILL.md` files directly to the model context. Because Modern Web Guidance contains over 100 dedicated guides—with plans to expand into hundreds more—stuffing separate Markdown files into the agent's top-level prompt context would rapidly overwhelm token windows and degrade retrieval performance.

Instead, the package provides a unified entry-point skill coupled with a local Command-Line Interface (CLI). When an engineer enters a prompt, the CLI performs a local semantic search over the guidance repository to pinpoint guides matching the requested use case. If relevant documentation is matched, only those specific guides are injected into the agent's active context window before generation occurs; if no guide matches, the agent responds normally.

Furthermore, Walton highlights a novel design choice in how low-level feature guides are written. Rather than organizing guides around raw API syntax or abstract browser specifications, each guide is anchored to a concrete user-facing use case unlocked or simplified by platform features. For instance, rather than simply documenting the View Transitions API in isolation, the guide centers explicitly around patterns like:

> “Visually connect persisting elements across different page [...]”

[09:59](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=599s) Structuring Guidance Around Real-World Developer Prompts

Philip Walton explains that developers rarely prompt coding agents with specific API names; rather, they prompt tools to accomplish practical tasks. To illustrate this, he points out that a guide might describe the goal as smoothly morphing an element's size, position, or styling properties across state changes or page navigations—such as expanding a thumbnail image in a product list into a full-bleed hero image in a product details view. Noticeably, this description never mentions the View Transition API directly. The guide instead mirrors developer intent: “And this is really important because developers don't generally prompt their coding agents to use specific features.” Developers often have no idea a specific API exists, which is why guides must match the actual language developers use when asking AI agents for help.

Beyond matching intent, the guides are intentionally authored for AI consumption rather than human reading. Walton emphasizes that they are concise, get straight to the point, and contain strictly the minimum context required for an AI agent to execute correctly. Relying on an agent to perform live web searches is inherently inefficient: even if the model discovers accurate information—which is far from guaranteed—it wastes valuable tokens digesting bloated web pages just to isolate relevant snippets. In contrast, the Modern Web Guidance files live locally on the user's machine, scoped directly to the use case, pre-vetted, and thoroughly tested.

```mermaid flowchart TD accTitle: Guided vs Web Search Flow for Coding Agents accDescr: Comparison between standard web search and Modern Web Guidance local files.

subgraph Search["Standard Web Search"] S1["Agent runs live web search"] --> S2["Consumes large token count reading results"] S2 --> S3["Risk of inaccurate or outdated APIs"] end

subgraph Guided["Modern Web Guidance"] G1["Task-based local prompt matching"] --> G2["Concise, pre-vetted local guide"] G2 --> G3["Optimized implementation with fallback strategies"] end ```

[11:40](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=700s) Modern Implementations and Cross-Browser Fallbacks

Walton considers the cross-browser fallback architecture to be the absolute best feature of Modern Web Guidance. Each guide begins with the ideal implementation using the most modern solution available, deliberately ignoring browser support constraints in this initial stage. This ensures full support for developers building Electron applications, browser extensions, internal company tools, or greenfield experiments where cross-browser limitations are irrelevant. Walton highlights Google's stance on tool enablement: “We don't want AI tools to prevent people from using new APIs if their situation allows for it.”

If any feature in that ideal modern implementation is not yet Baseline Widely Available, the guide supplies a vetted cross-browser fallback recommendation. Exceptions are rare and limited to APIs like WebMCP where no practical cross-browser fallback exists; in those cases, the guide explicitly indicates partial support and instructs the agent on proper feature detection. This layered approach—pairing an ideal cutting-edge implementation with explicit fallback branches—enables the coding agent to configure code specifically to a project's needs rather than defaulting to lowest-common-denominator legacy patterns.

- Ideal solutions assume zero browser support constraints to empower modern development environments. - Features not categorized as Baseline Widely Available include explicit fallback instructions. - Missing fallbacks (such as WebMCP) mandate standard feature-detection blocks. - Coding agents select between modern paths and fallback branches based on project configuration.

[13:05](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=785s) Baseline Integration and Project-Level Support Targets

To translate browser targets into precise code generation, Modern Web Guidance hooks directly into the Baseline standard. This capability requires two specific inputs: clear project browser support targets and granular compatibility data within the guides. While agents can occasionally infer target environments from existing project configuration files, Walton strongly recommends declaring support targets explicitly within the project's `AGENTS.md` file. In the absence of an explicit declaration, agents default to Baseline Widely Available.

Each guide embeds comprehensive compatibility metadata. When an agent reads project targets from `AGENTS.md`, it evaluates whether a fallback is actually needed. For instance, an Electron app configured to require Chrome 144 or newer does not need legacy JavaScript fallbacks for scroll-driven animations, which shipped back in Chrome 115. The agent identifies this compatibility overlap and discards the fallback entirely, keeping the codebase modern and clean.

```mermaid flowchart LR accTitle: Baseline Target Resolution Architecture accDescr: How AGENTS.md dictates whether the agent emits modern features or fallbacks.

A["AGENTS.md Configuration"] --> B{"Agent Checks Compatibility"} B -->|"Target exceeds feature milestone\n(e.g., Chrome 144 >= 115)"| C["Emit Modern Implementation Only"] B -->|"Target requires broader coverage\nor unspecified"| D["Emit Cross-Browser Fallback"] ```

[14:31](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=871s) Rigorous Daily Evals Across Major AI Models

To prove that Modern Web Guidance delivers real value, Walton addresses practical validation through rigorous evaluations. The Chrome team established a daily evaluation suite composed of 554 distinct assertions spanning their guidance library, targeting full coverage ahead of their stable release later in the year. The evaluation suite runs every single day against leading frontier models, including Gemini 3.1, Claude Opus 4.7, and GPT 5.5.

Walton presents aggregate performance metrics contrasting "guided" versus "unguided" agent performance. The guided pass rate shows agents performing meaningfully higher on assertions than unguided models across the board. While the pass rate has not reached 100% yet, both the evaluations and the guides are continually refined. Demonstrating an individual evaluation on scroll progress indicators, Walton shows how the test asserts that code uses scroll-driven animations rather than legacy scroll-event listeners; in that specific run, the guided agent passed every assertion, whereas the unguided agent failed completely.

Because browser ecosystems and model training sets change constantly, the team tracks pass rates over time to prune the library. Walton explains the lifecycle strategy: “Our plan here is to watch this closely, monitor the results, and then remove use cases once we start noticing that the unguided version is consistently performing as well as the guided version in all of the popular models.” Trimming guides once models internalize modern features ensures the package stays lightweight and token-efficient.

- The eval testbed currently features 554 distinct assertions covering guidance use cases. - Evaluations run daily against Gemini 3.1, Claude Opus 4.7, and GPT 5.5. - Guided models show a significant, measurable performance uplift over unguided baselines. - Guides will be deprecated dynamically once models reliably produce modern implementations unguided.

[17:44](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1064s) Future Roadmap and Live Demos

Modern Web Guidance launches its early preview with roughly a dozen high-level discipline guides and over 100 detailed use-case guides. Walton outlines an aggressive goal for the future: Chrome intends to provide guidance coverage for every single new web platform feature by the time it reaches Chrome stable. With Chrome shipping substantial platform additions in every release milestone on chromestatus.com, achieving this requires continuous authoring, and the team is collaborating with other browser vendors to incorporate cross-browser features as they emerge.

Summing up the core value proposition, Walton reiterates three key points: AI models exhibit knowledge gaps that default to legacy solutions; Modern Web Guidance fills those gaps with Chrome-engineered recommendations and cross-browser fallbacks; and Chrome will maintain these guides continuously so AI coding stays aligned with platform progress. Turning to the audience, Walton asks, “And with that, who wants to see some demos?” As the crowd erupts into applause, Walton laughs off an interrupting phone buzz, joking that his phone was going off because he was apparently supposed to be picking up his son from preschool right at that moment.

- Launch preview includes around 12 high-level discipline guides and more than 100 use-case guides. - The project commits to shipping AI guidance simultaneously with Chrome stable feature releases. - Chrome is actively coordinating with other browser engines to expand vendor coverage.

[19:35](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1175s) The Mobile Web Dilemma: Looking Good vs. Feeling Good

Philip Walton begins his live demonstration on an actual phone, presenting an email client application he has been building. While testing the display focus on the monitor, he explains that the specific application type does not matter as much as the broader goal: building a mobile web application that feels just as smooth, polished, and seamless as a native app on a smartphone. Reflecting on the evolution of front-end development over the past decade and a half, he highlights a persistent shortcoming across the industry. As Philip Walton puts it:

> “I think, as an industry—mobile first came out 15 years ago, and we got really good at building interfaces that look good on a mobile screen size. But we haven't really got good at building interfaces that feel good on a mobile screen size.”

To demonstrate the gap, Walton shows an interface modeled after Gmail, generated using Antigravity and Gemini. When he prompted the AI to build a sidebar navigation drawer with a hamburger menu that slides out on click, it generated a visually sound menu complete with all the expected links. However, the breakdown happens on touch interaction: placing a thumb on the drawer and attempting to swipe it closed fails completely. While virtually every native mobile app supports touch-driven swipe-to-close interactions, almost no mobile websites do. Simply asking the AI repeatedly for gesture controls rarely produces the desired default behavior, which sets the stage for using Modern Web Guidance to solve the problem.

[21:41](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1301s) Setting Up the Guided vs. Unguided Head-to-Head

Transitioning over to his laptop, Walton sets up a controlled head-to-head comparison to evaluate how AI handles the problem with and without structured guidance. He runs two distinct instances of the Antigravity editor side by side, branched off the exact same initial codebase: - An **unguided** version running in dark mode. - A **guided** version running in light mode.

In the guided workspace, Walton opens the integrated terminal and installs the guidance package by running `npx modern-web-guidance install`. Accepting the recommended installation defaults inside the project populates a `.agents` directory—a structure familiar to developers working with agent Skills—containing Modern Web Guidance. The unguided branch, by contrast, has no special skills or guides configured. He also launches two local dev servers in separate browser windows (one dark, one light) to test interactions in real time. Noting that the Antigravity environment had just been updated that morning following announcements at Google I/O, Walton decides to run both instances using the newly released Gemini 3.5 Flash, remarking that if the fast new model encounters issues, he can always fall back to Gemini 3.1.

```mermaid flowchart TD accTitle: Guided vs Unguided Architecture Setup accDescr: Diagram illustrating the two parallel Antigravity setups used to compare code generation with and without Modern Web Guidance.

subgraph UnguidedSetup ["Unguided Setup (Dark Mode)"] A1["Baseline Codebase"] --> B1["Antigravity Editor"] B1 --> C1["Gemini 3.5 Flash<br/>(Standard Prompts)"] C1 --> D1["Dev Server<br/>(Dark Window)"] end

subgraph GuidedSetup ["Guided Setup (Light Mode)"] A2["Baseline Codebase"] --> B2["npx modern-web-guidance install"] B2 --> C2[".agents Skills Directory"] C2 --> D2["Gemini 3.5 Flash<br/>(Guided Searches)"] D2 --> E2["Dev Server<br/>(Light Window)"] end ```

[23:38](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1418s) Prompt 1: Implementing a Native-Feeling Swipe-to-Close Drawer

Walton feeds an identical prompt into both the unguided and guided instances: *"The Navigation Drawer in this app looks fine, but I don't like that it can't swipe to close it. Can you fix that?"* Watching the guided editor's output console, Modern Web Guidance immediately triggers an `npx modern-web-guidance` search across its curated database, discovers a guide titled `navigation drawer`, and begins applying its architectural patterns. Both versions finish writing and building their code rapidly due to the speed of Gemini 3.5 Flash.

Testing the unguided implementation first, Walton admits the risk of live AI demos. When he opens the hamburger menu and drags his finger, the sidebar eventually closes, but the physical feel is noticeably unnatural. The unguided model simply hooked up a basic gesture listener: once a dragging threshold was reached, it fired a programmatic `close()` function, snapping shut while his finger was still held down against the glass rather than pinning the drawer directly to the movement of his thumb.

When Walton tests the guided implementation, the contrast is stark. As he clicks and drags, the drawer stays tightly pinned to his cursor and slides smoothly back and forth, earning cheers and applause from the audience. Walton breaks down the underlying modern web primitives that the guidance system injected into the prompt: - The backdrop smoothly dims and lightens in direct response to touch tracking via **CSS scroll-driven animations**. - The physical dragging interaction is managed using **CSS scroll snap points**, converting the drawer into an actual scrollable container. - Because it relies on native scrolling primitives, the interaction automatically inherits default browser physics, momentum, and hardware-accelerated rendering on the GPU without relying on heavy JavaScript drag-and-drop libraries.

[26:49](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1609s) Prompt 2: Stack Drilldown Navigation and Parallax

Moving quickly to a second interaction pattern, Walton submits another shared prompt to both environments: > “Now add a message view drilldown so that, when I click an email link in the inbox, it drills down into the full email message view with a Back button so that I can return to the inbox view. The message should also have standard email action buttons like Archive, Reply, Star, et cetera. But don't hook those up yet, just get the Back button working.”

In the guided terminal, Modern Web Guidance searches for relevant architectural patterns and retrieves a use-case guide labeled `stack-drill-down`. When Walton tests the unguided version upon completion, clicking an email loads the detailed view and the Back button returns to the inbox, but the transition is an abrupt, harsh visual jump lacking any mobile app polish or fluidity.

In the guided version, the experience mirrors native mobile operating system behavior. Clicking an email causes the message pane to slide in with a fluid view transition. Tapping Back reverses the transition cleanly. Furthermore, the interface supports an interactive swipe-to-go-back gesture: as Walton drags the view to navigate back, the incoming view exhibits an authentic parallax motion beneath the active sheet, powered entirely by scroll-driven animations. The implementation also synchronizes seamlessly with browser history, updating the URL bar on forward navigation and restoring the correct state on swipe or back navigation. Surprised by the depth of functionality produced without manual intervention, Walton highlights how the workflow removes implementation friction:

> “I didn't have to know how any of this stuff worked. I just typed it into the prompt.”

With both core interactions successfully matching native mobile behavior, he accepts the generated changes and prepares to layer on one final polish feature.

[29:46](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1786s) Implementing Swipe Gestures: Unguided vs. Guided Comparison

Philip Walton moves to the next capability demo for his email client interface, entering a prompt to add swipe actions directly into the message list: “In the Inbox view, make it so that I can quickly archive or snooze messages by swiping them left or right without having to open each one individually.” Walton jokes with the audience about how he handles overflowing inboxes, relating to anyone who deals with constant email clutter. He explains that rather than clicking into messages one by one, he spends most of his time in mobile mail applications just swiping through unread messages to dismiss them quickly.

```mermaid flowchart TD accTitle: Guided vs Unguided Swipe Gesture Handling accDescr: A comparison of how the unguided agent and the guided agent handle swiping gestures on inbox list items.

subgraph Unguided["Unguided Implementation"] U1["Detect swipe gesture"] --> U2["Trigger action on gesture end"] U2 -.-> U3["Card does not track or pin to finger"] end

subgraph Guided["Guided Implementation (Modern Web Guidance)"] G1["Track touch drag"] --> G2["Item pinned to finger in real time"] G2 --> G3{"Drag distance past 50% threshold?"} G3 -- "Yes" --> G4["Snap to end & trigger archive/snooze"] G3 -- "No" --> G5["Snap back to origin (native physics)"] end ```

When checking the unguided AI agent's output first, Walton notices familiar shortcomings. While the unguided tool successfully detects the swiping gesture itself and triggers the actions, the visual card does not stay pinned to the finger or drag smoothly during the interaction. Walton chuckles that while this attempt is surprisingly decent compared to previous test runs, it still falls short of modern expectations: “I've done this demo a bunch. This is maybe the best the unguided has ever done, but it's still not—it's still not exactly what I want.”

Switching over to the implementation generated with Modern Web Guidance, the resulting behavior mirrors production mobile mail clients like Gmail. Dragging from one side triggers a close or archive action, while dragging from the opposite edge activates snooze. The list items track touch movements cleanly rather than executing a disconnected gesture animation.

- **Prompt provided to both agents:** "In the Inbox view, make it so that I can quickly archive or snooze messages by swiping them left or right without having to open each one individually." - **Unguided agent behavior:** Successfully detects swipe triggers, but fails to pin the message card to the dragging finger. - **Guided agent behavior:** Implements directional swiping (archive to one side, snooze to the other) with interactive dragging comparable to Gmail.

---

[31:25](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1885s) Real-Device Testing: Native Physics on Pixel and iPhone

To truly demonstrate the difference that modern web capabilities make in touch feel and physics, Walton shifts from the desktop emulator to physical hardware, pulling out a Google Pixel phone connected to the presentation display. Working around the stage light reflections on the screen, he tests the swiping gesture interactively. He highlights how the implementation uses native-style scroll-snap physics: if an email is dragged less than halfway across the viewport and released, it immediately springs back to its starting position; if dragged past the halfway mark, it snaps completely to its destination snap point and dismisses the message.

Walton proceeds to test the broader navigation stack on the Pixel. He taps into an individual message view and performs the system-level Android predictive back swipe from the edge of the device to pop back into the inbox smoothly. To prove that these experiences are fully responsive and cross-browser rather than Chrome-only tricks, Walton pulls out an iPhone and reloads the identical web application. Swiping messages, tapping into individual emails, and triggering parallax header transitions all respond with identical fluid 60-plus-frames-per-second fidelity. Looking at the device, Walton remarks: “It feels like I can't tell this is not a native app as I'm using it, other than seeing the address bar down here at the bottom.”

- **Scroll-snap physics:** Pulling an email less than halfway springs it back to its original slot; pulling past 50% completes the snap action. - **System gesture compatibility:** Works seamlessly with native operating system navigation gestures, including the Pixel edge-swipe back gesture. - **Cross-platform verification:** Demonstrated back-to-back on Android (Google Pixel) and iOS (Apple iPhone) with zero divergence in touch responsiveness or parallax animations.

---

[33:32](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=2012s) Improving the Web Platform: Introducing Modern Web Guidance

Walton transitions back to the slide deck to wrap up the presentation with the broader philosophical mission behind the project. He emphasizes that the Chrome team invests heavily in expanding web platform standards specifically to empower developers and help web-based businesses succeed. However, he stresses that shipping new APIs in the browser engine does not solve real-world problems unless those primitives actually make their way into production web codebases.

Walton articulates the team's core realization about bridging platform standards and real-world deployment: “We have to actually improve the web because users don't visit the web platform, they visit the web, as it exists today, on the websites that they actually visit.” Because developers increasingly rely on AI coding assistants that default to outdated patterns, Chrome created Modern Web Guidance to inject current web platform best practices directly into AI development workflows. Walton invites all attendees and developers watching to experiment with the early preview, test it against their project use cases, and submit feedback via the provided resource links to help shape the future of modern web development.

- **The deployment disconnect:** Upgrading browser engine capabilities alone does not improve end-user experiences until websites implement those capabilities. - **Mission of Modern Web Guidance:** Provide AI coding agents with accurate, up-to-date platform context so they generate modern, high-performance web code out of the box. - **Call to action:** Developers are encouraged to test the early preview of Modern Web Guidance, report missing use cases, and contribute feedback at `https://goo.gle/4uaZsJt`.

## Notable quotes > [01:54](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=114s) AI coding agents frequently recommend legacy patterns, even though better, more modern alternatives exist. — Philip Walton

> [33:32](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=2012s) We have to actually improve the web because users don't visit the web platform, they visit the web, as it exists today, on the websites that they actually visit. — Philip Walton

> [00:00](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=0s) Why are AI coding agents recommending a solution that requires almost 172 kilobytes of JavaScript when the same exact solution can be built in a way that requires no JavaScript at all and still works across browsers? — Philip Walton

> [19:35](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=1175s) I think, as an industry—mobile first came out 15 years ago, and we got really good at building interfaces that look good on a mobile screen size. But we haven't really got good at building interfaces that feel good on a mobile screen size. — Philip Walton

> [11:40](https://www.youtube.com/watch?v=bo3i0FzDUYo&t=700s) We don't want AI tools to prevent people from using new APIs if their situation allows for it. — Philip Walton

## Mentioned Philip Walton, Chrome, Firefox, Safari, Internet Explorer, Interest Invokers API, Baseline, Modern Web Guidance, View Transitions API, WebMCP, Electron, Gemini 3.1, Claude Opus 4.7, GPT 5.5, Gemini 3.5 Flash, Antigravity, Google Pixel, Apple iPhone, Gmail, Google I/O 2026, Google

## Video description Discover how Chrome is bridging the knowledge gap for AI tools, ensuring your coding agents have up-to-date guidance on what features are available and how to use them properly. Equip them to understand the user and browser support requirements of your project, so you can go beyond one-size-fits-all answers to bespoke solutions tailored to your specific needs.

Resources: Modern Web Guidance → https://goo.gle/4uaZsJt

Speakers: Philip Walton

Watch the Chrome sessions from Google I/O 2026 → https://goo.gle/Chrome-at-IO2026

Subscribe to Chrome for Developers → https://goo.gle/ChromeDevs

#GoogleIO

Event: Google I/O 2026

Products Mentioned: Web, Chrome, AI/Machine Learning

[Source](https://www.youtube.com/watch?v=bo3i0FzDUYo)

Reading summary

Philip Walton presents Modern Web Guidance, a Chrome-engineered open skill set designed to prevent AI coding agents from generating obsolete, bloated code by injecting modern web platform standards and fallback strategies directly into development workflows. Why AI Coding Assistants Output Legacy Implementations (0:00) AI coding assistants frequently produce bloated and outdated frontend code even when modern, lightweight browser primitives exist. In an opening demonstration, identical prompts given to the same model produced two functional dropdown menus: an unguided setup delivered 172 KB of JavaScript over the wire, while a guided alternative required under 3 KB and executed entirely without JavaScript. Walton attributes this disconnect to three core factors: training datasets biased heavily toward historical codebases and workarounds for obsolete runtimes like Internet Explorer, severe knowledge cutoffs that cause models to generate deprecated or renamed drafts such as 'interesttarget' instead of 'interestfor', and overly defensive cross-browser compatibility logic that defaults to lowest-common-denominator scripts. Task-Oriented Guidance and Local Semantic Search Architecture (8:07) To keep context windows efficient, Modern Web Guidance replaces unindexed Markdown collections with a unified Command-Line Interface (CLI) backed by local semantic search across more than 100 guides. Instead of stuffing raw API documentation into prompts, the system anchors each guide to developer-centric tasks, such as visually connecting persisting elements across page navigations rather than referencing the View Transitions API by name. Running locally on developer machines via 'npx modern-web-guidance install', the CLI retrieves concise, pre-vetted guidance matching the user's intent. Guides begin with the ideal modern implementation assuming zero browser constraints—accommodating targeted runtimes like Electron or browser extensions—and layer on Baseline-compatible cross-browser fallbacks whenever an API lacks widespread availability. Agents evaluate project compatibility settings declared in 'AGENTS.md' to determine whether fallback code is needed or if it can be omitted entirely. Automated Validation and Dynamic Guide Deprecation (14:31) To ensure reliable output across changing model weights, the Chrome team established an automated evaluation suite containing 554 distinct assertions tested daily against frontier models including Gemini 3.1, Claude Opus 4.7, and GPT 5.5. Evaluation data demonstrates a measurable uplift in guided pass rates over unguided baselines, such as enforcing CSS scroll-driven animations over legacy JavaScript scroll-event listeners. Because model capabilities evolve, the team monitors evaluation results over time with plans to dynamically deprecate and remove specific guides once unguided models reliably produce modern implementations across all major frontier systems without assistance, preserving token efficiency. Mobile Interaction Fidelity Across Physical Hardware (19:35) Walton demonstrates that while modern web applications look visually acceptable on mobile viewports, they often fail to feel like native apps because AI tools default to rigid gesture thresholds. In live comparisons using Gemini 3.5 Flash inside the Antigravity editor, unguided implementations produced abrupt, snapping transitions and disconnected dragging behaviors. In contrast, guided agents utilized CSS scroll snap points and scroll-driven animations to build a swipe-to-close drawer, stack drilldown navigation with parallax transitions, and directional inbox swipe actions. Tested on both an Android Google Pixel and an Apple iPhone, the resulting web application achieved fluid touch tracking and system-gesture compatibility at 60-plus frames per second without reliance on heavy JavaScript libraries. Walton concludes that shipping new platform APIs inside browser engines fails to improve user experience unless those primitives are actively deployed in production web applications. While early preview coverage spans approximately a dozen discipline guides and over 100 use-case guides, achieving long-term parity requires continuously authoring guidance as new APIs hit Chrome stable and coordinating with other browser vendors to expand cross-engine coverage.

Source quotes

[1:54] Philip Walton: AI coding agents frequently recommend legacy patterns, even though better, more modern alternatives exist. [33:32] Philip Walton: We have to actually improve the web because users don't visit the web platform, they visit the web, as it exists today, on the websites that they actually visit. [0:00] Philip Walton: Why are AI coding agents recommending a solution that requires almost 172 kilobytes of JavaScript when the same exact solution can be built in a way that requires no JavaScript at all and still works across browsers? [19:35] Philip Walton: I think, as an industry—mobile first came out 15 years ago, and we got really good at building interfaces that look good on a mobile screen size. But we haven't really got good at building interfaces that feel good on a mobile screen size. [11:40] Philip Walton: We don't want AI tools to prevent people from using new APIs if their situation allows for it.

Original transcript

[0:00] [MUSIC PLAYING] [0:06] PHILIP WALTON: Hey, everybody. [0:07] My name is Philip Walton. [0:09] And today I want to start off by showing you a screen recording [0:12] that I made of two different demos. [0:15] Both of these demos look and function identically. [0:19] Both have dropdown menus that smoothly animate in and out. [0:22] They're both fully keyboard accessible. [0:25] They both support light dismiss. [0:27] And they both work in Chrome, Firefox, and Safari. [0:31] These demos were both also generated using AI. [0:34] In fact, they were generated using the same coding [0:36] agent, the same model, and the same prompt. [0:40] The difference, though, is the version on the left was [0:43] generated using an agent in its standard, default, [0:46] out-of-the-box configuration. [0:47] And the version on the right was generated using the same agent, [0:50] but with one extra thing installed, [0:53] and I'll get to that later. [0:55] But there is one more big difference [0:56] between these two demos. [0:59] If I open up DevTools, and I zoom in here on the Network [1:02] panel, you can see that the version on the left [1:04] loads 172 kilobytes, most of which is JavaScript. [1:08] Whereas, the one on the right loads less than 3k, [1:11] and uses absolutely no JavaScript. [1:13] And to be clear, that's 172 kilobytes over the wire, [1:18] minified and gzipped, with all of the production optimizations [1:21] turned on. [1:22] And I didn't modify this code at all. [1:24] This is what the AI suggested. [1:27] Now, admittedly, this is a bit of a contrived example [1:29] because no app is just a settings menu and nothing else. [1:33] Once you add more features, you might need [1:34] to add some more JavaScript. [1:36] Still, I do think this raises an interesting question. [1:39] Why are AI coding agents recommending a solution that [1:41] requires almost 172 kilobytes of JavaScript [1:45] when the same exact solution can be built in a way that [1:48] requires no JavaScript at all and still works across browsers? [1:54] So if you were at any of the talks [1:56] earlier today, you heard a lot about this, [1:58] a lot about how amazing AI is. [2:00] And don't get me wrong, AI is amazing. [2:03] It truly blows my mind every single day. [2:06] But that is just one side of the story. [2:09] The truth is that, while AI has transformed the software [2:11] industry, and it has enabled us developers [2:13] to write code way faster than ever before, there [2:17] is another side to the story. [2:18] AI is definitely not perfect. [2:20] And if you, like me, follow a lot of well-known frontend [2:24] developers on social media, then you'll [2:27] know that many of these folks are definitely not [2:29] shy about pointing out just how not perfect [2:32] these AI coding agents are, especially when it [2:36] comes to writing HTML and CSS. [2:43] And, you know, these folks, they're not wrong. [2:45] There have been so many amazing developments [2:47] on the web over the past few years [2:49] and, yet, if you ask a coding agent [2:51] to go build something for you on the web, [2:53] it's most likely not going to reach for the latest web [2:55] platform features to do it, even if those features really [2:58] are the best tool for the job. [3:00] And this isn't all that surprising [3:01] if you consider that most of the training data used [3:04] by these models was written during a time when [3:06] most developers had to support legacy browsers like Internet [3:09] Explorer. [3:10] But regardless of the reason, the reality [3:12] is that, for frontend web development, [3:14] coding agents do tend to recommend legacy solutions even [3:18] when there are better, more modern alternatives. [3:23] Another big problem we see with AI models [3:25] is that they have a knowledge gap. [3:27] Every model has a knowledge cutoff date [3:29] where any new developments on the web that [3:32] occurred after that date are just not included [3:34] in the model's training. [3:36] In the past year alone, Chrome has shipped more than 50 brand [3:38] new web features. [3:40] But due to these knowledge cutoffs, many of these features [3:42] are just completely unknown to these models. [3:45] And while techniques like RAG and web search [3:47] can help with this problem, they don't eliminate it entirely. [3:51] And if you ask a coding agent to use a feature that it's never [3:54] heard of, it'll usually do a web search. [3:56] But if you ask it to do something [3:58] that it thinks it already knows how to do, [4:00] then it'll often just reply confidently [4:02] right away without checking for more up-to-date information. [4:06] For example, here's some code that an agent generated [4:09] after I asked it to build a tooltip using the new interest [4:12] invokers API. [4:13] Now, if you look closely at the highlighted line of code, [4:16] you can see that the model used the interesttarget attribute, [4:19] which is not correct. [4:21] interesttarget was the attribute name when this API was first [4:24] proposed back in 2023. [4:26] But right before the API shipped in Chrome last fall, [4:28] the name was changed to interestfor. [4:31] And so that means that the code you see on the screen [4:33] will silently fail when run in a browser, which will [4:35] make it pretty hard to debug. [4:37] Now, this specific problem is probably [4:39] going to be fixed for this API in the next generation [4:41] of the models. [4:43] But the larger problem is not going away anytime soon. [4:47] A third problem we see is how AI models [4:49] make cross-browser support decisions. [4:51] In our testing, AI is way more conservative [4:54] than it needs to be when it comes to cross-browser support. [4:57] It's understandable that these models or these tool makers [5:00] would want to optimize for broad compatibility. [5:02] But now that we have initiatives like Baseline, which [5:05] includes compatibility data for nearly every web feature, [5:08] there's really no excuse for not using it. [5:11] Agents should not be making generic, [5:13] one-size-fits-all browser support recommendations. [5:16] They should be tailoring their recommendations [5:17] to the specific needs of your project. [5:22] So that's a quick overview of the main problems [5:24] we see with AI coding agents when it comes to modern web [5:26] development. [5:27] To recap, AI coding agents frequently [5:30] recommend legacy patterns, even though better, more modern [5:33] alternatives exist. [5:34] Second, AI models have blind spots and either aren't aware of [5:37] or have incorrect information about the latest web [5:40] platform features. [5:41] And third, AI models tend to make outdated, [5:44] one-size-fits-all browser support recommendations. [5:47] But the good news is that here, in Chrome, we [5:49] believe that these problems are all very solvable. [5:52] And we've been hard at work on a solution [5:54] that we're excited to share with you all today, an early preview. [5:57] We call it Modern Web Guidance. [6:02] Modern Web Guidance is a comprehensive and expert-vetted [6:07] set of skills covering all of Chrome's best practices [6:10] on building for the modern web. [6:13] This package embeds decades of Chrome's web platform experience [6:16] expertise directly into your coding agents. [6:19] And because it's based on skills, [6:21] it works with any AI coding platform. [6:25] You can install Modern Web Guidance [6:26] with this single command, npx modern-web-guidance install. [6:32] Or if you're using any of the IDEs [6:34] or coding agents shown here on the screen, [6:36] you can find and install Modern Web Guidance [6:38] directly from within these tools. [6:42] So I know, right now, the market is absolutely flooded [6:47] with new skills releases. [6:49] And as a developer, it can be challenging to keep up, [6:51] overwhelming, even. [6:53] It's also especially hard to determine [6:55] which skills are good and worth using and which skills are-- [6:59] let's face it-- basically just slop. [7:02] So I want to stress here that Modern Web Guidance is not [7:04] your ordinary skills pack. [7:06] This is something that we on the Chrome team [7:08] have been investing in a ton over the past six months. [7:10] And it's something that we're committed to investing in [7:12] for the long term. [7:14] So let's dive in and take a closer look at what's included [7:16] and how it works. [7:18] So Modern Web Guidance is comprised of two distinct levels [7:22] of guidance. [7:23] First, we have a set of high-level guides codifying [7:26] the best practices for broad web disciplines [7:28] like performance, accessibility, security, [7:32] user experience, and many more. [7:34] In addition to these high-level guides, [7:36] we also have a set of very specific low-level guides [7:39] covering web features that have been recently added [7:41] to the platform. [7:42] And we've seen that AI models just [7:43] don't yet have a good understanding of how [7:45] to use them properly. [7:47] All of these guides have been created by members of the Chrome [7:50] team, in collaboration with a number of external subject [7:53] matter experts that we've hired to contribute to this project. [7:56] And because these guides focus on core web platform features, [8:01] they will work regardless of whatever framework [8:04] or stack you're using, or anything like that. [8:07] Now, before I dig deeper into the specifics of these guides, [8:10] I want to give you all a quick overview of how [8:12] the tool works at a high level. [8:15] So when you're using a coding agent out of the box, [8:17] the flow is pretty simple. [8:20] The user types a prompt into the tool. [8:22] The prompt is given to the AI model, which then [8:24] produces an output response. [8:27] If you're using Modern Web Guidance, [8:29] then, before the AI produces an output, [8:31] it'll perform a semantic search locally [8:34] within the Modern Web Guidance package [8:36] to see if any of our guides match [8:37] the use case in the prompt. [8:39] If there are no matches, then those guides [8:41] will get added to the context window. [8:43] And if they're-- sorry. [8:44] If there are matches, those guys will add it [8:46] to the context window. [8:47] If there are no matches, the AI will respond as normal. [8:50] Now, note that this is a bit different from how [8:52] most skills work where each skill is [8:54] a distinct skill that MD file. [8:56] With Modern Web Guidance, we expose a single entry point [8:59] skill that has access to a CLI that does the search. [9:04] And we do this because we currently have [9:06] more than 100 distinct guides. [9:09] And we plan to add likely hundreds more. [9:11] So it just doesn't scale to expose these all as single, [9:15] top-level skilled MD files. [9:17] So let's take a closer look at what these guides look like. [9:21] Now, I mentioned before that we have both high-level discipline [9:24] skills and low-level feature guides. [9:26] The high-level guides are very similar to the skills [9:28] that you've probably seen before. [9:30] But for the low-level feature guides, [9:31] we took a different approach that I think is pretty novel, [9:34] and so I want to talk about it. [9:36] First, rather than focusing on the features themselves [9:39] and documenting how those features work, [9:41] instead, each of these guides focuses on a distinct use case [9:46] that one of these features unlocks [9:48] or makes easier to implement. [9:50] For example, one of the use cases that we identified [9:52] for the View Transitions API that's been unlocked was [9:56] "Visually connect persisting elements across different page [9:59] states or navigations by smoothly morphing their size, [10:03] position, or other styling properties," for example, [10:07] expanding a thumbnail image in a product list view [10:10] into a full-bleed hero image in a product details view. [10:14] Now, you'll notice that use case doesn't mention the View [10:17] Transition API at all. [10:19] Instead, it describes a task that the developer [10:22] might want to implement or to accomplish, [10:24] where the View Transition API happens [10:26] to be the best choice to implement it with. [10:29] And this is really important because developers [10:31] don't generally prompt their coding agents [10:33] to use specific features. [10:36] They might not even know that those features exist. [10:38] Instead, they prompt their tools to implement use cases. [10:41] And so we need our guides to match the prompts [10:45] that developers are actually using. [10:48] So the second aspect of each of these guides [10:50] is that they're optimized for AI consumption. [10:52] And by that, I mean that each guide is concise, [10:55] it gets straight to the point, and it [10:56] contains only the minimum amount of information needed for the AI [11:00] to properly follow it. [11:02] This is more efficient than doing web search [11:04] because, even if the agent finds up-to-date and accurate [11:07] information on the web, which is not guaranteed, [11:10] it still has to read through all of that content, [11:12] use all of those tokens, just to find the bits that [11:15] are relevant to your use case. [11:17] Or perhaps not. [11:18] It might not find it. [11:20] Our guides are already scoped to the use case. [11:22] They're already vetted and tested for accuracy. [11:24] And they're already locally on your device. [11:28] So third, every guide, we include a section [11:31] that documents our specific recommendations and fallback [11:34] strategies to ensure that the implementation of the use case [11:37] works across browsers. [11:40] Now, I want to dig into that last part [11:42] because this cross-browser fallback guidance is, [11:45] in my opinion, the absolute best feature of this tool. [11:47] So let me explain how it works. [11:50] For each guide, we start by documenting [11:52] the ideal implementation using the most [11:54] modern solution available. [11:56] For this part of the guide, we do not take browser support [11:58] into consideration at all. [12:00] We assume that any feature can be used, [12:01] and we pick the best feature for the task at hand. [12:04] And we do this because we want to support people [12:06] who are experimenting with new features, [12:08] people who are building extensions, Electron apps, [12:11] building internal company tools, or really [12:13] any situation where cross-browser support is not [12:15] a major concern. [12:16] We don't want AI tools to prevent people [12:18] from using new APIs if their situation allows for it. [12:22] However, if any of the features in the ideal implementation [12:26] are not Baseline widely available, [12:29] then we always include a fallback recommendation. [12:31] And whenever possible, we make sure [12:33] that fallback recommendation works across browsers. [12:36] The only exception to this is things [12:37] like WebMCP, where there really is no cross-browser fallback. [12:41] But in all other cases, if there is a cross-browser fallback, [12:44] we use it. [12:44] And if there's not, we make it crystal clear [12:46] that the feature is only available in some browsers, [12:48] and we show how to properly feature detect for it. [12:52] And the reason we take this two-layered approach, [12:54] starting with the fully modern and then going [12:56] with the fallbacks, is so that the agent can pick and choose [13:00] how to implement the use case based on your site's browser [13:03] support requirements. [13:05] And that brings me to the final feature [13:06] I want to talk about in this package, [13:08] our Baseline integration. [13:11] I said that we want coding agents [13:13] to be able to customize their implementation based [13:15] on your browser support requirements. [13:17] And for this to work, two things need to happen. [13:20] First, you need to tell your agent what baseline [13:23] target or browsers you support. [13:25] Agents can sometimes guess or infer [13:27] this information from various config files in your project, [13:30] but we think it's better to be explicit, [13:32] and we recommend putting this information directly [13:34] into your AGENTS.md file. [13:37] If you don't declare any specific browser support [13:39] information, then the agent will assume [13:41] based on widely available. [13:43] Second, in the fallback section of each of our guides, [13:47] we include detailed browser compat data [13:50] so that the agent can then determine whether or not [13:53] it needs to use a particular fallback based on the browser [13:57] support requirements that you put in your AGENTS.md file. [13:59] For example, if you're building an Electron app [14:02] and you set in your AGENTS.md file [14:03] that you only need to support Chrome 144 or newer, then [14:07] if the agent encounters a fallback for something [14:09] like, say, scroll-driven animations-- which shipped [14:12] in Chrome 115-- then the agent can ignore that recommendation [14:15] and just stick with the modern implementation. [14:18] This allows the agent to custom tailor each guide's [14:20] implementation to the specific browser support [14:23] requirements of your project, rather [14:25] than always having to take a lowest common denominator [14:28] approach. [14:31] So that's a quick overview of Modern Web Guidance. [14:34] And I assume, at this point, many of you [14:36] are probably thinking, sounds great, [14:38] but how well does it actually work in practice? [14:42] So I do have some demos that I'm going to show, [14:44] so you will get to see it working. [14:45] But before I show those, I do want [14:47] to address this question directly because I [14:49] think it's an important one. [14:50] I think it's important that we, as an industry, [14:53] are able to evaluate the effectiveness of the skills [14:55] that we're using. [14:57] When we started this project, one of the main requirements [14:59] we had was to ensure that we had rigorous evals [15:02] for every single feature that we used. [15:06] As of now, our eval suite includes 554 distinct assertions [15:12] covering most of our guidance. [15:13] And we plan to expand that to full coverage [15:15] before our stable launch later this year. [15:18] And we run this full eval suite every single day [15:21] against many of the popular AI-coding models, [15:24] which right now includes Gemini 3.1, Claude Opus 4.7, and GPT [15:28] 5.5. [15:30] Here, on the screen, you can see a visualization [15:32] of the aggregate results of all of these evals [15:35] across all of these coding models. [15:37] The number in green on the right shows the average pass rate [15:40] of eval assertions for agents running with Modern Web [15:43] Guidance installed. [15:44] And the number on the left shows the average pass rate [15:47] for the exact same set of assertions, [15:49] but this time from agents running without Modern Web [15:51] Guidance installed. [15:52] And we call this the guided versus unguided pass rate. [15:56] So as you can see, the guided pass rate, [15:58] the guided agent performs meaningfully better [16:01] than the unguided agent. [16:03] It's not yet at 100%, but we're actively [16:06] fine-tuning both our guides and our evals [16:08] because we want this number to be as high as it can be. [16:11] So what do these individual evals look like? [16:14] Well, they're effectively prompts [16:15] that we give an agent followed by a set of assertions or tests [16:19] that we run against the agent's output. [16:21] Here's an example of a recent eval from our scroll progress [16:24] indicator use case. [16:26] We run the prompt that you can see on the screen, [16:28] along with the following assertions [16:30] to test compliance with the guides. [16:33] For this use case, the test checks [16:35] to see that the implementation correctly [16:36] uses scroll-driven animations rather than relying [16:39] on scroll-event listeners. [16:41] As you can see, with this particular instance [16:43] for this particular run, with our guidance, [16:46] all the tests passed. [16:46] And without our guidance, all of them failed. [16:50] So this is a snapshot of how these models are performing [16:52] right now, but it's not hard to imagine [16:53] this changing in the future. [16:56] At some point, as the models improve [16:58] and as the browser landscape changes, [16:59] we fully expect that many of these evals [17:02] will start passing even without our guidance. [17:04] So I mentioned that we've run these evals daily. [17:06] Our plan here is to watch this closely, monitor the results, [17:10] and then remove use cases once we start [17:12] noticing that the unguided version is consistently [17:15] performing as well as the guided version in all [17:18] of the popular models. [17:19] This will allow us to keep the pack small, token efficient, [17:23] and focus just on the features that are new and not well known [17:27] by the models and not covered in the training. [17:30] But also keep in mind that new features [17:31] are shipping in browsers every single month, [17:34] and knowledge cutoffs continue to lag far behind. [17:37] So we believe this type of guidance [17:39] is going to continue to be necessary long into the future. [17:44] And speaking of the future, I now [17:45] want to talk a bit about how we see this project evolving [17:48] over time. [17:49] For this early preview, we're launching [17:51] with about a dozen high-level discipline [17:52] guides and more than 100 detailed use case guides, [17:56] but we're definitely not going to stop there. [17:58] Our plan is to continue adding more guides to give us [18:01] better coverage of the existing web platform, [18:03] but we're also going to be covering [18:05] new features as they land. [18:06] In fact, our goal with this tool is [18:08] to ensure that every single new web platform feature [18:11] that ships in Chrome is covered by this tool [18:14] by the time it lands in Chrome stable. [18:19] If you take a look at chromestatus.com, [18:20] you'll see that Chrome releases a lot of new features [18:23] every single milestone, so this is definitely an ambitious goal. [18:26] But it's one that we think is critical to support [18:28] the ongoing health and success of the web [18:30] in this new agentic world. [18:33] We're also currently engaging with other browser vendors [18:35] to try to get coverage for the features they're [18:37] shipping as well. [18:40] OK, so to recap what we've covered today-- first, [18:43] AI models have a knowledge gap and blind spots. [18:45] They recommend legacy solutions even when [18:47] there are newer and better alternatives. [18:50] Second, Modern Web Guidance fills those knowledge gaps [18:53] with vetted recommendations from Chrome experts. [18:56] This helps ensure coding agents have [18:57] a full and complete understanding of the modern web [19:00] platform, with clear instructions on how [19:02] to implement those features in a way that [19:04] is compatible across browsers. [19:06] And third, Chrome is committed to keeping Modern Web Guidance [19:09] up to date as the platform evolves [19:11] so that agentic coding will always [19:13] be at the forefront of modern web development, [19:16] rather than constantly lagging behind. [19:20] And with that, who wants to see some demos? [19:23] [CHEERS, APPLAUSE] [19:24] Demos? [19:25] [APPLAUSE] [19:27] All right. [19:28] I don't know if you guys could hear my-- sorry about that. [19:31] My phone was going off. [19:31] I was supposed to pick my son up from preschool right now, [19:34] I guess. [19:35] Hopefully, my wife's doing that. [19:37] All right, here we are. [19:42] So I want to start here on this phone. [19:44] I want to show you all an app that I'm building. [19:47] Now, I don't know if it's not-- [19:52] how's the focus? [19:59] Can you read it? [20:01] OK, this monitor is a bit weird. [20:02] OK. [20:03] So this is an email application. [20:06] It doesn't really matter what the application is. [20:08] I'm doing a project here where I want to build-- [20:11] I want to build a mobile website. [20:14] And my goal here is to make the mobile website function [20:17] when I'm using it on my phone as smoothly [20:20] and polished and seamless as the native applications [20:23] that I use in my phone. [20:25] I think, as an industry-- mobile first came out 15 years ago, [20:28] and we got really good at building interfaces that look [20:33] good on a mobile screen size. [20:34] But we haven't really got good at building interfaces that feel [20:36] good on a mobile screen size. [20:38] So that's my goal with this. [20:39] And so I was prompting Gemini-- [20:42] I was using Antigravity. [20:43] And I asked it to build something [20:44] that looks similar to Gmail, and it did this. [20:48] And then I said, OK, build me a sidebar navigation [20:51] drawer with a hamburger menu. [20:53] And when I click the hamburger menu, I want it to slide out. [20:57] So it does that, and it looks OK. [21:01] It had all the links that I wanted. [21:03] But there's one thing here that's missing. [21:06] And you might be able to guess what it is. [21:07] When I put my thumb here and try to slide it closed, [21:12] it's not working. [21:14] Now, I assume everyone has experienced this at some point. [21:16] You go to a mobile website, you try [21:18] to slide the navigation drawer closed, it doesn't work. [21:20] Literally every single native application [21:22] supports this functionality. [21:24] Pretty much no websites do. [21:26] And so I want to change that. [21:28] And the AI wasn't really helping me here. [21:30] I asked it to do this, and I could keep prompting, [21:33] but I wanted it to do that by default. [21:35] So let's talk about how we could fix this using Modern Web [21:37] Guidance. [21:41] So let's switch over to my laptop. [21:44] I have Antigravity here. [21:47] And I want to talk through how I'm [21:49] going to approach doing this. [21:50] But I want to do something a little bit different. [21:52] I have actually two versions of Antigravity running. [21:54] I have this Antigravity in light mode, my editor's in light mode. [21:57] That's how you tell the difference. [21:59] And then-- hold on. [22:01] And then this is Antigravity running in dark mode. [22:04] If you look here on the right, it says unguided. [22:07] And then, when I switch back, it says guided. [22:09] So I have two branches off a single branch. [22:12] They're the exact same code base. [22:14] And I'm running two versions of Antigravity. [22:16] One, I'm going to say, is guided, and one is unguided. [22:19] So here in the guided version, let's go ahead and load up [22:22] the terminal. [22:23] I got it running, but I'm going to install Modern Web Guidance. [22:28] And so you can see I'm just running the command npx [22:30] modern-web-guidance install. [22:32] And it's going to go through the flow. [22:34] Let me Expand this so you can see it. [22:37] It's going to install it. [22:38] I'm just going to go ahead and click the default [22:40] recommendations. [22:41] I'm going to do it in my project. [22:44] Proceed with Installation. [22:45] And so if you look over here-- and actually, [22:47] let me go ahead and rerun the dev server. [22:51] OK. [22:51] So if you look over here, it added this .agents folder. [22:55] Luckily, my project-- if you've used Skills, [22:56] you're used to this flow. [22:58] And if I open this up, you can see [23:00] Modern Web Guidance is installed here in the guided one. [23:04] And then, if I switch back to the unguided, there's no skills. [23:08] So that's where we're starting. [23:10] I also have two browser windows open, one in dark mode. [23:14] This is the unguided version running its local dev server. [23:17] And this is the guided version running its local dev server. [23:20] They're both-- like I said, they both started [23:22] from the same exact branch. [23:24] I can open up the sidebar, and I'm [23:26] trying to swipe it closed here. [23:28] You can see it's dragging behind, [23:30] but the sidebar is not closing, so let's fix this. [23:34] I have some prompts prepared, so you [23:36] don't have to watch me typing. [23:38] And let's go back into Antigravity. [23:40] I'm going to start with the unguided version. [23:41] Oh, I'll also mention they updated all of our Antigravities [23:47] today. [23:47] Obviously, you probably heard the announcement. [23:49] So I'm going to try doing this with Gemini 3.5 Flash. [23:52] Never tried that before. [23:53] Hopefully, it will work. [23:54] If it doesn't work, we'll go back to 3.1. [23:57] But I want to try it. [23:58] We'll see if it works. [23:58] So I'm going to paste this in. [23:59] I'm going to do it here, and then I'm [24:01] going to switch back to the guided version, [24:03] and then I'll read the prompt. [24:04] So I say the Navigation Drawer in this app looks fine, [24:06] but I don't like that it can't swipe to close it. [24:09] Can you fix that? [24:11] So we can see here what it's doing. [24:12] I'm going to go ahead and close this sidebar. [24:15] I'm going to zoom this over so we can watch what's happening. [24:18] So if you look up at the top, it is running npx-- [24:22] Modern Web Guidance is doing a search command, [24:24] which is what I mentioned. [24:25] It's searching through the guide database. [24:26] It found a guide. [24:27] It looks like it found a guide. [24:29] Can I move this over? [24:30] Found a guide called navigation drawer, [24:34] and so it's starting to implement that. [24:36] And then, if we go back and look at the unguided version, [24:40] it's doing some things. [24:41] It looks like this is already done. [24:42] I'm going to go ahead and Accept these changes. [24:45] Let's go back to the guided version. [24:47] Is that done? [24:48] Looks like it's almost done because it's [24:49] running the npx build. [24:50] OK, look, that one's done as well. [24:53] This is why I decided to do a Flash because it is quite fast. [24:56] So I didn't want you all to have to sit here and watch [24:59] this running. [25:00] So here we are in the unguided version. [25:03] Now, this is an AI demo, so it's very risky. [25:05] I don't know what's going to happen, so bear with me in case [25:08] this totally fails. [25:09] I'm going to click the Hamburger menu and see what happens. [25:11] OK, now I'm going to try to close it with a swipe. [25:15] OK. [25:16] So it did swipe to close. [25:17] You probably couldn't pick up on what [25:19] was happening because you don't see-- you [25:21] didn't feel what I was doing. [25:22] Let me do this again because something felt weird about this. [25:26] I am dragging here. [25:28] I don't know if you can see behind. [25:29] I'm dragging this. [25:30] OK, they're closed. [25:32] I didn't pick my finger up. [25:33] I my finger down, I was dragging, [25:34] and then I didn't pick my finger up and it closed. [25:36] So I've done this demo a couple times. [25:39] It seems like Flash is doing a similar thing. [25:41] What I'm pretty sure is happening here [25:43] is that it is trying to detect the swipe gesture, [25:45] and then it is calling a close function. [25:47] But what I want it to do is I wanted [25:49] to literally pin the sheet to my finger as I'm moving it. [25:52] This is what I would expect. [25:55] And so again, it kind of works, but it doesn't-- it's definitely [25:59] better than without it, but it's not quite what I want. [26:01] So let's go back to the guided version [26:03] and let's see how it did. [26:05] Fingers crossed. [26:07] OK, it opens up. [26:09] I'm going to click. [26:10] I'm going to drag. [26:13] Click and drag. [26:14] [CHEERS, APPLAUSE] [26:18] And so you might even notice here, [26:19] the backdrop is fading ever so slightly as I'm dragging. [26:24] And this-- because I know what guide it used. [26:26] This is using scroll-driven animation [26:28] to do that backdrop fade. [26:29] And it's tracking with the scroll gesture. [26:32] The dragging here is being handled [26:34] using scroll snap points. [26:36] So it's actually a scroll interface, [26:38] which means it uses the browser's default [26:41] physics and all of the hardware acceleration of scrolling. [26:44] So I can swipe it to close, and I can swipe it like that, [26:47] and that looks great. [26:49] OK. [26:49] But we got to do some more features, so let's keep moving. [26:53] All right. [26:54] I'm going to add this-- copy of this next prompt. [26:56] Let's go to the unguided version, [26:58] paste it in, and then go to the guided version, paste it in, [27:01] and I'll read what the prompt is. [27:03] OK. [27:04] So the prompt is, now add a message view drilldown so [27:07] that, when I click an email link in the inbox, [27:09] it drills down into the full email message view [27:13] with a Back button so that I can return to the inbox view. [27:15] The message should also have standard email action buttons [27:18] like Archive, Reply, Star, et cetera. [27:21] But don't hook those up yet, just [27:22] get the Back button working. [27:24] All right, so Modern Web Guidance is doing its thing. [27:27] It's looking for some guides. [27:31] Let's go back and see what the unguided version is doing. [27:33] It's still working as well. [27:39] And so I can see here that Modern Web [27:40] Guidance is retrieving a guide called stack-drill-down. [27:43] This is just the ID of the use case that it's retrieving. [27:46] And if we have some time, I can-- [27:51] if it's not going to finish yet-- [27:52] it looks like this one finished. [27:55] I might show the guides if you have some time. [27:57] But since it's finished, I'm going to go back, [27:58] and I'm going to check the unguided version [28:00] to see what happens. [28:01] So I'm going to click an email message in the inbox view, [28:04] and I want it to show me the full message. [28:08] OK, so show me the full message. [28:11] It didn't animate our transition in. [28:13] Like I mentioned, I want this to feel like a native application. [28:16] Does the Back button work? [28:17] OK, the Back button works, but this [28:19] is kind of a harsh transition. [28:24] So let's see if the other one is done. [28:26] And let's see-- [28:27] OK, it looks like it says I've successfully [28:30] integrated the stack drilldown transition [28:32] module into the main-- [28:33] OK, it did it. [28:34] It's using some of the-- describes here what it's doing. [28:38] Now let's go and check to see what it looks like. [28:42] Again, fingers crossed. [28:44] OK, so it worked. [28:46] It smoothly transitioned in. [28:48] I can click the Back button, and it transition out. [28:51] Now let's see if I can Swipe to go backwards. [28:57] OK, I can Swipe to go backwards. [28:58] That's nice. [28:59] [APPLAUSE] [29:02] I'm also noticing a little bit of parallax going on here as I'm [29:07] swiping it, which is also done using scroll-driven animations. [29:14] And actually, I'm looking up here in the Navigation bar, [29:19] and I see that, when I click, it updates the history. [29:22] And then let's see, if I click the Back button, swipes back. [29:26] I didn't have to know how any of this stuff worked. [29:29] I just typed it into the prompt. [29:31] Let's do one more thing. [29:33] Let's just try to get a little bit of a cherry-on-top situation [29:35] here. [29:36] All right. [29:37] Let's go into the-- let me go back and Accept [29:39] these Changes for now. [29:41] OK, go back into the unguided version, [29:43] and then again the guided version. [29:46] All right. [29:46] In the Inbox view, make it so that I can quickly [29:49] archive or snooze messages by swiping them left or right [29:53] without having to open each one individually. [29:58] So I don't know if you guys are like me. [29:59] You have your email app. [30:00] You get a lot of email that you don't care about. [30:02] I spend most of my time in my mail app just going [30:04] like this-- swiping, swiping, swiping [30:06] all of the unread emails-- or, that way. [30:08] I don't want to have to click into each of them individually. [30:14] OK, it says this one is done also. [30:16] Is this one done? [30:17] Yeah, this one's still working. [30:18] So let's go check and see what the unguided version did. [30:25] OK. [30:29] So it's doing the same thing it did before where [30:31] it's not pinned to my finger. [30:33] It's not dragging with my finger, [30:34] but it is detecting a swipe gesture. [30:37] And OK, it looks like it does support both-- [30:42] I'll be honest. [30:42] I've done this demo a bunch. [30:43] This is maybe the best the unguided has ever done, [30:46] but it's still not-- it's still not exactly what I want. [30:50] OK, let's see if the other one is done. [30:51] Switching back to the guided version. [30:53] OK, it looks like it is done. [30:56] All right. [30:57] And let's check how that one did. [31:04] OK, much better. [31:05] I mean, this kind of looks very similar to how Gmail looks. [31:09] I can swipe it from that side, swipe them all closed. [31:13] I can snooze it from this side. [31:18] So this is great. [31:20] But this is the kind of thing that you really [31:22] can't know-- you watching me do this, [31:24] you don't really know how it is. [31:25] But I think if we switch back to the phone. [31:27] I want to pull this up on my phone, [31:29] and I want you to watch me doing it on the phone just [31:30] to get the full effect. [31:35] OK, so let's see. [31:36] We click this-- oh, you can-- hold on. [31:39] Let's see. [31:40] There's that reflection. [31:41] So I can swipe this closed. [31:46] And this is the kind of thing where, if I put it halfway, [31:48] and I let go, it swipes back. [31:50] And if I do it more than halfway and let go-- [31:52] sorry, it wasn't quite more than halfway. [31:56] It's a little hard for me to see because it's reflecting [31:59] on my face, but yeah. [32:01] So it scrolls now. [32:02] The way that it works is the same way [32:04] that the native app physics work where, [32:06] if you do it more than halfway, it'll [32:08] finish-- it'll snap to it's snap point, which is great. [32:12] If I click on a message, I can click on any of these messages. [32:17] And then I think it should work as [32:18] well if I do the Back gesture. [32:22] Not very good at this. [32:23] There we go-- the back gesture on Pixel. [32:26] And then, if I swipe through the emails-- [32:33] you know, snooze-- the whole thing feels really nice. [32:38] It feels really nice and smooth to me. [32:40] And just to show that what I said earlier is not a lie, [32:44] I have an iPhone right here. [32:49] Refresh. [32:50] Do the same thing. [32:52] Swipe. [32:55] Click into a-- click into a message. [32:59] The whole parallax thing. [33:03] Sorry, I'm trying to get this so you don't see the reflection. [33:08] It all feels very smooth. [33:09] It feels like I can't tell this is not a native app as I'm [33:11] using it, other than seeing the address bar down here [33:13] at the bottom. [33:13] [CHEERS, APPLAUSE] [33:20] So let's switch back to the slides. [33:28] Oops. [33:30] We pressed at the same time. [33:31] All right. [33:32] So to wrap up, in Chrome, we care deeply [33:37] about the health of the open web, [33:39] and we invest a ton into improving the platform so [33:41] that developers can build better experiences, [33:44] and so that businesses that are built on the web [33:48] can ultimately be more successful. [33:50] But the truth is that improving just the web platform, [33:53] it's not good enough. [33:55] We have to actually improve the web [33:58] because users don't visit the web platform, [34:01] they visit the web, as it exists today, [34:04] on the websites that they actually visit. [34:06] So if we want to make the web better, [34:08] then, at the end of the day, we're [34:09] going to actually have to make it as easy as possible for you [34:12] developers to use all of these amazing features [34:15] that Chrome is adding to the platform. [34:18] And that's why we built Modern Web Guidance. [34:20] But also, that's why we want to hear from you all. [34:23] We want to make sure that this tool works for you, [34:25] and that it helps you build better experiences. [34:27] So we'd love for everyone to try out this early preview [34:29] and give us feedback. [34:31] If you're running into problems, or if there are use cases [34:33] that you feel are missing, then definitely let us know. [34:36] The link on the screen here will take you [34:38] to a site with information on how you can contribute and give [34:41] feedback. [34:42] And with that, thank you all very much. [34:44] [APPLAUSE] [34:46] [MUSIC PLAYING]