Chrome for Developers
Technical CSS vocabulary replaces vague visual prompts to let AI agents generate accessible, production-ready web interfaces without JavaScript wrapper libraries.
AI-assisted summary of Vibe design to build incredible web UI — original source. Check the original for full context.
Source published:
Key ideas
- Stitch and Antigravity integrate via Model Context Protocol (MCP) servers with Chrome DevTools to create a closed-loop agentic workflow: prompt design, inspect live computed styles, and refine. (3:06)
- Precise modern CSS terminology—such as scroll timelines, asymmetrical CSS Grid geometry, and native select styling—serves as the primary semantic prompt language needed to steer AI agents accurately. (0:00)
- Stitch centralizes visual design tokens in a portable `DESIGN.md` specification that automatically compiles into Tailwind CSS utilities to guarantee cross-screen consistency and seamless engineering handoffs. (7:29)
- New browser features like `appearance: base-select` and `animation-timeline: scroll()` allow developers to replace bloated JavaScript libraries with high-performance, accessible native CSS implementations. (13:52)
Detailed notes
## Background Published on YouTube by Chrome for Developers on May 21, 2026, this Google I/O 2026 session features Dion Almaer and David East detailing how to accelerate frontend development through a "Vibe Design" workflow. According to the page description, the talk explains how to lead with aesthetic intent rather than syntax, utilizing Stitch and Chrome DevTools Model Context Protocol (MCP) servers to translate high-level design concepts directly into production code.
## TL;DR Presenters David East and Dion Almaer introduce "Vibe Design with CSS," an agentic workflow where technical CSS vocabulary serves as the guiding semantic language for AI design agents. They demonstrate an integrated feedback loop within the Antigravity IDE using Stitch MCP and Chrome DevTools MCP to prompt, inspect live computed styles, and refine code in real time. Practical walkthroughs illustrate building an asymmetrical CSS Grid bento layout, maintaining cohesive multi-screen tokens via a centralized `DESIGN.md` file compiled into Tailwind utilities, authoring pure CSS scroll-driven animations with `animation-timeline: scroll()`, and customizing native dropdown menus using `appearance: base-select`. Throughout the session, they show that mastering modern web platform primitives allows developers to steer generative agents with surgical accuracy rather than vague trial and error.
## Atmosphere & style The presentation carries the polished, upbeat energy of a premier Google I/O developer showcase, blending forward-looking tech demos with practical, grounded engineering advice. David East and Dion Almaer display an easy, collaborative chemistry, trading duties between conceptual exposition and live code inspection while troubleshooting common setup pitfalls like MCP configuration quirks. Watching the session feels inspiring and pragmatic, demonstrating how emerging AI tools and deep browser fundamentals complement each other to make modern web development feel fluid, fast, and creative.
## Bulletin - [03:06](https://www.youtube.com/watch?v=nC7TrzUYvig&t=186s) Stitch and Antigravity integrate via Model Context Protocol (MCP) servers with Chrome DevTools to create a closed-loop agentic workflow: prompt design, inspect live computed styles, and refine. - [00:00](https://www.youtube.com/watch?v=nC7TrzUYvig&t=0s) Precise modern CSS terminology—such as scroll timelines, asymmetrical CSS Grid geometry, and native select styling—serves as the primary semantic prompt language needed to steer AI agents accurately. - [07:29](https://www.youtube.com/watch?v=nC7TrzUYvig&t=449s) Stitch centralizes visual design tokens in a portable `DESIGN.md` specification that automatically compiles into Tailwind CSS utilities to guarantee cross-screen consistency and seamless engineering handoffs. - [13:52](https://www.youtube.com/watch?v=nC7TrzUYvig&t=832s) New browser features like `appearance: base-select` and `animation-timeline: scroll()` allow developers to replace bloated JavaScript libraries with high-performance, accessible native CSS implementations.
## Key takeaways - [00:00](https://www.youtube.com/watch?v=nC7TrzUYvig&t=0s) "Vibe design" shifts AI web generation from vague aesthetic requests to prompt instructions grounded in precise CSS concepts. - [00:00](https://www.youtube.com/watch?v=nC7TrzUYvig&t=0s) Stitch functions as an AI design agent that compiles descriptive intent into production-ready HTML and Tailwind CSS utility classes. - [03:06](https://www.youtube.com/watch?v=nC7TrzUYvig&t=186s) The developer loop connects the Antigravity IDE agent to Stitch MCP and Chrome DevTools MCP, enabling real-time style and DOM inspection. - [03:06](https://www.youtube.com/watch?v=nC7TrzUYvig&t=186s) When configuring Chrome DevTools MCP in Antigravity, developers must paste only the inner server block to avoid duplicate `mcpServers` parent keys. - [04:48](https://www.youtube.com/watch?v=nC7TrzUYvig&t=288s) Using explicit CSS Grid definitions in prompts enables agents to produce structured bento box layouts with accurate multi-span hierarchies. - [04:48](https://www.youtube.com/watch?v=nC7TrzUYvig&t=288s) Serving generated screens locally via `@_davideast/stitch-mcp serve` allows DevTools MCP to evaluate computed styles and live browser behavior directly. - [07:29](https://www.youtube.com/watch?v=nC7TrzUYvig&t=449s) A central `DESIGN.md` specification functions as a system prompt for design agents, defining semantic color roles, typography, and component rules. - [07:29](https://www.youtube.com/watch?v=nC7TrzUYvig&t=449s) Design tokens from `DESIGN.md` compile directly into Tailwind CSS configuration classes such as `bg-primary` and `rounded-large`. - [07:29](https://www.youtube.com/watch?v=nC7TrzUYvig&t=449s) Exporting `DESIGN.md` alongside codebase files ensures downstream engineers and external AI agents adhere to original design system rules. - [10:04](https://www.youtube.com/watch?v=nC7TrzUYvig&t=604s) Declaring `animation-timeline: scroll()` replaces JavaScript scroll event listeners and `requestAnimationFrame` loops with pure CSS scroll-driven animations. - [11:49](https://www.youtube.com/watch?v=nC7TrzUYvig&t=709s) Positioning an animated element as a direct child of the body avoids parent relative-positioning traps and keeps fixed alignment intact. - [11:49](https://www.youtube.com/watch?v=nC7TrzUYvig&t=709s) Using `left: 50%` and negative margins for element centering leaves the `transform` property unencumbered for `scaleY` scroll animations. - [11:49](https://www.youtube.com/watch?v=nC7TrzUYvig&t=709s) Confining scroll-driven animations to opacity and transform properties offloads rendering entirely to the browser's compositor thread with zero layout recalculations. - [13:52](https://www.youtube.com/watch?v=nC7TrzUYvig&t=832s) Declaring `appearance: base-select` strips default OS chrome from native `<select>` dropdowns while fully preserving native accessibility and keyboard navigation. - [15:58](https://www.youtube.com/watch?v=nC7TrzUYvig&t=958s) Modern CSS features represent high-fidelity semantic handles that enable developers to eliminate ambiguity when prompting generative design agents.
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=nC7TrzUYvig&t=0s) Defining "Vibe Design" and Leading with CSS Vocabulary
David East opens the session by demonstrating a series of advanced, modern web interface features running live: scroll-triggered animations driven by the CSS animation trigger property, a native `<select>` dropdown fully customized using `appearance: base-select`, and an asymmetrical CSS Grid layout utilizing non-uniform track sizes to establish clear spatial hierarchy. While viewers might assume these interfaces were produced by an AI coding agent, David and Dion Almaer clarify that they were created with a specialized AI design agent called Stitch. Stitch takes high-level descriptive intent regarding look, feel, and behavior, and compiles it into real, production-ready HTML paired with Tailwind CSS.
The core philosophy presented is "vibe design with CSS." Rather than divorcing visual aesthetic from implementation details, the workflow treats CSS as the bridge connecting user intent, graphic design, and the agent. General prompts like "make it look nice" produce generic results, but framing visual goals through precise CSS concepts yields targeted, professional UI. Directing the agent with terms such as "use a non-uniform grid with a two-column hero span" or "bind a `scaleY` transform to the scroll timeline" gives developers surgical control over the design output. As David East puts it: “CSS is the shared language between you, design, code, and the agent.” Dion Almaer reinforces how technical literacy elevates generative workflows, observing that “your CSS knowledge turns vague intent into precise direction.”
- **Techniques previewed**: Modern scroll-triggered animations, native stylable select menus via `appearance: base-select`, and non-uniform CSS Grid layouts. - **Underlying stack**: Stitch generates structured HTML and Tailwind CSS utility classes directly from agent prompts. - **Session roadmap**: Four practical stages covering CSS Grid visual hierarchy, centralized design systems in `DESIGN.md`, pure CSS scroll-driven animations, and JavaScript-free select styling.
---
[03:06](https://www.youtube.com/watch?v=nC7TrzUYvig&t=186s) Setting Up the Development Loop: Antigravity, Stitch MCP, and Chrome DevTools MCP
Before writing any prompts, Dion details how to assemble the development environment around the Antigravity IDE using two Model Context Protocol (MCP) servers. The first integration is the Stitch MCP server, which connects the coding agent directly to Stitch's backend. Developers locate Stitch in the Antigravity MCP gallery and paste in an API key generated from their Stitch Settings page. Once configured, the IDE agent can execute programmatic design tasks using native tool calls such as `generate_screen_from_text`, `edit_screens`, and `list_screens`.
The second tool is the Chrome DevTools MCP server, which allows the coding agent to inspect live web pages directly inside Google Chrome by querying the DOM tree, computing styles, and reading console logs. Setting it up involves copying the configuration block from its GitHub repository and pasting it into the Antigravity raw config editor. Dion issues a specific configuration warning: the GitHub documentation nests the configuration within an outer `mcpServers` parent key; because Antigravity's settings file usually already defines that parent key, developers must paste only the inner server block to avoid syntax errors. Together, these tools form an iterative feedback loop: you prompt the design in Stitch, inspect the live computed styles in Chrome DevTools, and refine the prompt based on observed layout behavior. Dion Almaer emphasizes this cadence: “So design, inspect, refine-- one loop. And the CSS knowledge is what makes each iteration better than the last.”
```mermaid flowchart LR accTitle: The Vibe Design MCP Loop accDescr: An iterative cycle of designing in Stitch, inspecting in Chrome DevTools, and refining prompts in Antigravity. subgraph Loop["Iterative Vibe Design Cycle"] D["1. Design in Stitch<br/>(CSS-informed prompting)"] I["2. Inspect in Chrome<br/>(Chrome DevTools MCP)"] R["3. Refine Prompt<br/>(Antigravity Agent)"] D --> I I --> R R --> D end ```
- **Stitch MCP setup**: Installed via the Antigravity MCP gallery using an API key from Stitch settings; exposes `generate_screen_from_text`, `edit_screens`, and `list_screens`. - **Chrome DevTools MCP setup**: Ingests live browser state (DOM, computed styles, console logs) via a server config block pasted into Antigravity's raw MCP config editor. - **Config trap**: Prevent duplicate parent `mcpServers` JSON keys when pasting raw configuration blocks into Antigravity.
---
[04:48](https://www.youtube.com/watch?v=nC7TrzUYvig&t=288s) Building and Inspecting an Interactive Bento Grid Layout
David moves to practical execution by constructing a layout for a "meta site"—a web page designed to explain CSS features while actively being styled by those exact features. To demonstrate spatial hierarchy through a bento box layout, David prompts Stitch with an explicit CSS grid specification: four columns wide, an overarching hero card for scroll animations spanning two columns and two rows, a tall single-column card dedicated to Customizable Select, and smaller secondary cards populating the remaining grid cells.
To bridge Stitch’s web interface into the local IDE workflow, David right-clicks the generated screen inside Stitch, copies its URL, and pastes it into Antigravity with a prompt requesting project details. The Stitch MCP parses the URL, returning project metadata and unique screen IDs. To allow the Chrome DevTools MCP to evaluate live computed DOM properties, David serves the HTML locally using a custom CLI package by executing `npx @_davideast/stitch-mcp serve`. Inspecting the live container in DevTools confirms Stitch generated exact grid properties: `grid-template-columns: repeat(4, 1fr)` on the container, with the hero card receiving `col-span-2 row-span-2`. To push the agent further, David asks Stitch to turn the static bento grid into a drag-and-drop interface, explicitly requesting vanilla JavaScript and pointer events to guarantee clean, performant execution without external libraries. Stitch successfully renders an interactive grid where cards can be dynamically reordered while preserving their defined grid-span geometry.
- **Meta site concept**: Every card in the grid represents a session topic built using the specific CSS technique it describes. - **Prompted grid geometry**: Four equal columns (`repeat(4, 1fr)`), with the primary hero card occupying `col-span-2 row-span-2` alongside complementary vertical and standard cells. - **Local serving workflow**: Screen HTML is pulled locally via `npx @_davideast/stitch-mcp serve` so Chrome DevTools MCP can inspect the live DOM tree and computed styles. - **Complex interaction**: The agent implemented drag-and-drop card reordering using pure pointer events without disrupting the CSS Grid dimensions.
---
[07:29](https://www.youtube.com/watch?v=nC7TrzUYvig&t=449s) Standardizing Visual Identity with DESIGN.md and Tailwind Tokens
Dion transitions to managing long-term design consistency across multi-screen web projects. In Stitch, every project relies on a central specification file called `DESIGN.md`. Dion compares this file to `AGENT.md` guidelines used for coding agents: it codifies color palettes, typographic scales, spacing systems, and component conventions into a format that design agents can reliably interpret. When creating a screen, Stitch analyzes the visual output and automatically synthesizes a cohesive design system—in this example, a system called the "technical curator." This system visualizes font hierarchies and components while generating the accompanying markdown spec complete with hex codes, semantic role assignments, and explicit design dos and don'ts. Dion Almaer explains the risk of omitting this system: “Without it, each screen is an island. But with it, they all belong together.”
Crucially, Stitch’s design system bridges directly into codebase utility classes during export. The tokens generated in `DESIGN.md` are compiled into a custom Tailwind CSS configuration. Semantic color roles—primary, secondary, tertiary, and neutral—translate directly into utility classes like `bg-primary`, `primary-container`, and `on-primary-container`. Typography tokens become utility classes such as `font-headline`, `font-body`, and `font-label`, while corner radii map to tokens like `rounded-large` and `rounded-full`. Subsequent screens generated within the project inherit these tokens by default. If an accent color needs to be modified, updating it in the centralized design system propagates changes across all screens. Dion Almaer describes the architectural benefit: “That's the CSS custom properties model-- one source of truth, many consumers.” When developers export the project, `DESIGN.md` ships alongside the code, ensuring original design intentions persist across handoffs to downstream engineers or external AI agents.
- **`DESIGN.md` spec**: Contains exact hex values, semantic role assignments, component rules, typography pairings, and explicit architectural dos and don'ts. - **Tailwind compilation**: Color roles map to semantic utilities (`bg-primary`, `primary-container`, `on-primary-container`), fonts map to semantic weights, and borders follow a defined scale (`rounded-large`, `rounded-full`). - **Inheritance & updates**: New screens inherit system tokens automatically; single-point edits in the design system update all associated views. - **Handoff integrity**: Exporting `DESIGN.md` alongside codebase files ensures agents and human developers maintain design system constraints downstream.
---
[10:04](https://www.youtube.com/watch?v=nC7TrzUYvig&t=604s) Pure CSS Scroll-Driven Animations: The Progress Spine
Dion introduces scroll-driven animations by previewing an interactive page where a thin vertical progress spine expands continuously from the top of the viewport to the bottom in sync with the user's scroll depth. Scrolling backward reverses the animation in real time. Rather than relying on JavaScript scroll event listeners or `requestAnimationFrame` loops, the entire interaction is powered by pure CSS using the modern scroll-driven animations specification.
The implementation relies on binding a CSS animation to a dynamic scroll timeline instead of standard elapsed time. The progress spine is assigned fixed positioning and runs a `@keyframes` rule scaling along the Y-axis from `0` to `1`. Setting `transform-origin: top center` forces the element to anchor at the top and stretch downward, while `animation-timeline: scroll()` synchronizes the transformation directly with viewport travel. Dion Almaer explains: “That single declaration binds the animation progress to the scroll position instead of time.” Dion begins constructing this feature in Stitch using a two-step prompting strategy: step one establishes a clean structural skeleton consisting of an alternating two-column layout across four content sections, alternating explanatory prose and code snippets. After validating the rendered layout in Chrome via Antigravity, Dion prepares to layer the scroll-linked progress spine directly over the skeleton.
- **Scroll-driven mechanism**: `animation-timeline: scroll()` replaces time-based animation progression with scroll container position tracking. - **Keyframe scaling**: The element applies a `@keyframes` rule transitioning `transform: scaleY(0)` to `scaleY(1)` anchored via `transform-origin: top center`. - **Zero-runtime overhead**: No JavaScript scroll listeners or resize observers are used to calculate progress indicators. - **Staged prompting**: Laying down the static layout skeleton first (an alternating two-column grid) allows validation in Chrome DevTools before injecting dynamic animation rules.
[11:49](https://www.youtube.com/watch?v=nC7TrzUYvig&t=709s) Implementing Scroll-Driven Animations with Precise CSS Vocabulary
To build a dynamic center editorial spine that elongates as a visitor navigates down the page, the speaker turns to their coding agent to draft an implementation grounded in modern CSS. The instructions provided to the agent are intentionally explicit: use `animation-timeline: scroll()` targeting the root block axis, mapping the scale transform straight to scroll progression, paired with `transform-origin: top center` so the line anchors at the top and extends downward rather than expanding symmetrically from its midpoint.
When the coding agent—Antigravity—returns its response, it neatly isolates the implementation into two minimal, highly deliberate components. First, it generates an empty `div` with the class `editorial-spine`, designated as a direct child of `<body>`. Placing it as an immediate child of the body element is critical, because nesting it inside any container with relative positioning would break its fixed viewport alignment. Second, the agent constructs the styling using a clever CSS centering technique: `left: 50%` combined with `margin-left: -0.5px`, avoiding `transform: translateX()`. This conscious choice leaves the element's `transform` property completely unencumbered for the animation's `scaleY` changes.
```mermaid flowchart TD accTitle: Scroll-Driven Spine Architecture accDescr: Flow diagram showing how specific CSS prompts generate compositor-thread scroll animations without JavaScript.
subgraph Prompt ["Agent Prompting"] A["Author Intent & CSS Mechanics"] --> B["Antigravity Coding Agent"] end
subgraph Output ["Generated Code Structure"] B --> C["Direct Body Child<br/>div.editorial-spine"] B --> D["Pure CSS Rules<br/>Fixed, Centered, Scroll Timeline"] end
subgraph Runtime ["Browser Engine Execution"] C --> E["Compositor Thread"] D --> E E --> F["Zero Layout Recalculations<br/>Zero JavaScript Event Listeners"] end ```
The core animation relies on three essential lines: declaring `transform-origin: top center`, an animation titled `spine-draw linear`, and `animation-timeline: scroll(root block)`. Because the animated properties are strictly confined to opacity and transform, the browser offloads the entire rendering workload to the compositor thread. When scrolling back and forth across the page, the line responds continuously and fluidly without any lag. As the speaker highlights: “The CSS vocabulary is what made the prompts precise enough to get the right result.”
- The agent avoided `translateX(-50%)` to ensure the `transform` property remained reserved exclusively for `scaleY` transformations. - Offloading the scroll tracking directly to the CSS scroll timeline eliminated layout recalculations and abolished the need for JavaScript scroll event listeners entirely.
---
[13:52](https://www.youtube.com/watch?v=nC7TrzUYvig&t=832s) Styling Native Form Controls with appearance: base-select
David East moves to the final demonstration by setting up a split-screen comparison of a dropdown menu. On the left sits a standard native HTML `<select>` element in all its default styling: a generic system font, an unalterable OS-rendered arrow, and a stubborn default border. East notes that web developers have spent decades fighting the element's rigid styling, recounting: “I mean, people built entire JavaScript component libraries just to get a decent-looking dropdown.” On the right side sits the exact same underlying native element, but completely transformed with custom background hues, refined typography, a custom icon, and a crisp blue bottom accent border.
```mermaid flowchart LR accTitle: appearance base-select Workflow accDescr: Diagram illustrating how appearance base-select strips OS chrome while preserving accessibility.
subgraph Input ["CSS Declaration"] A["appearance: base-select"] end
subgraph Engine ["Browser Behavior"] A --> B["Strips Default OS Chrome"] A --> C["Preserves Native Core"] end
subgraph Visuals ["Styling & Access"] B --> D["Full CSS Customization<br/>Borders, Fonts, Custom Icons"] C --> E["Built-in Accessibility<br/>Keyboard Navigation & Focus Rings"] end ```
This transformation is enabled entirely by a single property: `appearance: base-select`. East explains: “And that single declaration tells the browser to stop rendering its own Chrome and hand control over to you.” Once the property is declared, the select element behaves as a standard box model container that accepts any background, border, typography, or internal layout rules. Critically, while the developer takes complete control over the visual presentation, the browser engine continues to manage all accessibility trees, focus handling, and native keyboard navigation.
East feeds these exact visual tokens into Stitch—requesting `appearance: base-select`, a warm gray background, a blue bottom border, and a "Layers" icon. Thanks to the concrete CSS declarations in the prompt, Stitch generates the live, production-ready element on the very first try. Testing the generated control via keyboard proves that it retains full native functionality: users can tab directly into the element, arrow through the dropdown items, and rely on the native focus ring, achieving the look of a tailored custom design system purely through standard CSS.
- Native `<select>` elements styled with `appearance: base-select` retain full default keyboard behaviors, including arrow-key option navigation and accessibility compliance. - Feeding exact token specifications (such as warm gray backgrounds and distinct border accents) into AI authoring tools like Stitch produces working, single-prompt UI elements without extraneous component wrapper libraries.
---
[15:58](https://www.youtube.com/watch?v=nC7TrzUYvig&t=958s) CSS as the New Design Vocabulary
Closing out the presentation, Dion Almaer and David East reflect on the shifting role of technical web knowledge in an era of agentic, AI-assisted development. Technical syntax is no longer just a hurdle for manual coding; it forms the precise conceptual lexicon needed to guide AI agents accurately. Almaer argues: “So your CSS knowledge isn't just for implementation anymore.” Instead, he insists, “It's your design vocabulary.”
Every foundational modern CSS feature—ranging from CSS Grid and scroll-driven animations to `appearance: base-select`, clip-path masking, and custom properties—acts as a high-fidelity semantic handle that allows developers and designers to express intent without ambiguity. Rather than relying on fuzzy natural-language descriptions that leave agents guessing, knowing the web platform's capabilities lets creators prompt with exact primitives. East wraps up by urging viewers to inspect the provided links, tools, and prompts in the video description, promising to be the first commenter below the video to answer questions, while Almaer bids the audience farewell with an invitation to jump in and start designing.
- Platform capabilities—such as CSS Grid, scroll-driven timelines, custom properties, and clip paths—give creators the exact terminology required to prompt generative design agents effectively. - All code samples, tools, and prompts from the session are provided in the video description for developers to explore and adapt into their own workflows.
## Notable quotes > [00:00](https://www.youtube.com/watch?v=nC7TrzUYvig&t=0s) CSS is the shared language between you, design, code, and the agent. — David East
> [00:00](https://www.youtube.com/watch?v=nC7TrzUYvig&t=0s) Your CSS knowledge turns vague intent into precise direction. — Dion Almaer
> [13:52](https://www.youtube.com/watch?v=nC7TrzUYvig&t=832s) People built entire JavaScript component libraries just to get a decent-looking dropdown. — David East
## Mentioned Dion Almaer, David East, Chrome for Developers, Google I/O 2026, Stitch, Antigravity, Chrome DevTools, Model Context Protocol, Tailwind CSS, DESIGN.md, GitHub
## Video description Learn how to ship web UIs faster by collapsing design and build into one Vibe Design workflow. Vibe Design is all about leading with aesthetic instead of syntax. Learn how to use Stitch and Chrome DevTools MCP servers to translate ideas directly into code with agentic workflows.
Resources: Stitch Beta - Design at the speed of AI → https://goo.gle/4nbHNyw Design.md Google Labs code samples → https://goo.gle/4d8Xwdk
Speakers: Dion Almaer, David East
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, Design
[Source](https://www.youtube.com/watch?v=nC7TrzUYvig)