Google Links Stitch AI to Chrome DevTools to Build Web UIs From CSS

Vibe design to build incredible web UI — Chrome for Developers

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)

Reading summary

David East and Dion Almaer argue that CSS serves as a shared, precise design vocabulary for steering AI agents like Stitch, turning vague natural-language prompts into production-ready web interfaces. The Vibe Design Feedback Loop (3:06) East and Almaer describe "vibe design" as translating high-level aesthetic intent into production HTML and Tailwind CSS through specific CSS primitives rather than generic prompts. The development environment centers on the Antigravity IDE linked to two Model Context Protocol (MCP) servers: Stitch MCP and Chrome DevTools MCP. Stitch handles programmatic screen generation via tools like `generate_screen_from_text`, while Chrome DevTools MCP lets the agent inspect the live DOM tree, computed styles, and console logs. When configuring Antigravity, Almaer cautions against duplicating the outer `mcpServers` JSON key from GitHub documentation to avoid syntax errors. Layout Geometry and Centralized Design Tokens (4:48) To demonstrate layout control, East prompted Stitch to construct a four-column bento grid with a hero card spanning two columns and two rows (`repeat(4, 1fr)` and `col-span-2 row-span-2`). Local inspection via `npx @_davideast/stitch-mcp serve` verified the computed grid rules, and Stitch successfully added dynamic card reordering using vanilla JavaScript pointer events without breaking the underlying grid geometry. To ensure consistency across multiple views, Stitch generates a central `DESIGN.md` specification that codifies color palettes, typography scales, and component guidelines. These specifications compile into Tailwind CSS utility classes, such as `bg-primary`, `font-headline`, and `rounded-large`. Almaer notes that editing tokens in the central design system updates all associated views, and shipping `DESIGN.md` alongside code preserves design intent across downstream engineering and agent handoffs. Pure CSS Scroll-Driven Animations (10:04) Almaer and East demonstrated an editorial progress spine that elongates along the viewport in direct sync with page scrolling. By using the modern CSS scroll-driven animations specification—specifically `animation-timeline: scroll(root block)` and `transform-origin: top center`—the element scales along the Y-axis from 0 to 1 without JavaScript scroll listeners or resize observers. The generated structure placed an empty `div.editorial-spine` directly under the `<body>` element to prevent relative positioning from breaking fixed alignment. Centering was handled with `left: 50%` and `margin-left: -0.5px`, purposefully reserving the `transform` property for `scaleY`. Because the animated properties were restricted to transform and opacity, the browser executes the animation on the compositor thread with zero layout recalculations. Styling Native Select Menus with base-select (13:52) Addressing historically rigid form controls, East showcased the `appearance: base-select` property, which strips default operating system chrome from native `<select>` dropdowns while keeping underlying browser accessibility, focus rings, and keyboard navigation intact. Once declared, the select element can be styled like a standard container. Supplying Stitch with specific visual requirements—including `appearance: base-select`, a warm gray background, and a blue bottom border—generated a fully styled native dropdown on the first attempt, bypassing the need for third-party JavaScript wrapper libraries. East and Almaer conclude that modern CSS primitives—including Grid, scroll timelines, custom properties, and `appearance: base-select`—now function as an essential design vocabulary for AI-assisted development, allowing practitioners to direct generative agents with precision.

Source quotes

[0:00] David East: CSS is the shared language between you, design, code, and the agent. [0:00] Dion Almaer: Your CSS knowledge turns vague intent into precise direction. [13:52] David East: People built entire JavaScript component libraries just to get a decent-looking dropdown.

Original transcript

[0:00] [MUSIC PLAYING] [0:05] DAVID EAST: This screen uses the animation trigger property [0:08] that makes scroll-trigger animations buttery [0:11] smooth and incredibly easy. [0:13] And this Select dropdown uses a native select element styled [0:17] with appearance base-select. [0:20] Oh, and this layout uses CSS grid with non-uniform track [0:23] sizes, which tells the user where to look first, [0:27] establishing a spatial hierarchy. [0:30] And we didn't build this with an AI coding agent. [0:34] DION ALMAER: Well, it's not entirely true, right? [0:36] DAVID EAST: Well, OK, yeah, but we did build it [0:38] with a design agent. [0:41] DION ALMAER: This is Stitch. [0:42] It's an AI design tool. [0:44] You describe what you want your app to look and feel like, [0:47] and it's going to generate a design backed [0:49] by real HTML and Tailwind CSS. [0:51] DAVID EAST: And the most important part of this workflow [0:54] is that every feature we're covering in CSS maps [0:56] directly to a design principle. [0:59] Grid gives us structural hierarchy. [1:01] And scroll-triggered animations create a sense of continuity [1:04] as the user moves through the page. [1:07] And we know how to direct this design because we [1:09] use the vocabulary, descriptions, [1:11] and even the syntax of these CSS features. [1:13] DION ALMAER: I'm Dion, and I work on Stitch. [1:15] DAVID EAST: And-- and I'm David. [1:17] [STAMMERS] And I also work on Stitch. [1:19] And today, we're going to teach you how to vibe design with CSS. [1:24] DION ALMAER: So what is vibe design? [1:26] It's using your intent to build a design. [1:29] You describe what you want-- the layout, the feel, the behavior-- [1:33] and the tool builds it. [1:34] That's just the baseline, though. [1:37] What makes it more powerful is when [1:39] you use your CSS vocabulary. [1:41] Then your intent gets specific. [1:43] Instead of saying, make it look nice, [1:45] you say, use a non-uniform grid with a two-column hero span. [1:51] Instead of, add some animation, you can say, [1:53] bind a scale Y transform to the scroll timeline. [1:57] Your CSS knowledge turns vague intent into precise direction. [2:03] DAVID EAST: CSS is the shared language between you, design, [2:07] code, and the agent. [2:09] And that's the workflow that we're going to cover today. [2:12] We're going to go over how to go from a CSS idea [2:15] to a finished design using Stitch and the Chrome DevTools [2:19] MCPs together. [2:20] Then we'll start with layouts. [2:23] We'll build a grid with non-uniform track sizes that [2:26] showcases visual hierarchy because who [2:29] doesn't love a good grid? [2:31] And after that, we'll cover how to define your visual identity [2:35] and have every screen inherit from it-- [2:39] colors, typography, spacing, all of it in one source of truth. [2:43] Then we'll get into the weeds on the fundamentals [2:46] of scroll-triggered animations to create them [2:48] right from prompts. [2:50] And last and definitely not least, [2:52] we'll cover appearance base-select [2:54] to style a select element without any JavaScript [2:57] or any libraries. [2:59] And we're going to leave all of the prompts, the tools, [3:04] and everything we did in the description today. [3:06] DION ALMAER: So before we start prompting, [3:08] let's set up the development environment. [3:10] We're using two MCP servers that work together [3:14] with Antigravity as our IDE. [3:17] First, Stitch MCP. [3:18] This connects your coding agent to Stitch [3:20] so it can create projects, generate screens, and edit [3:23] designs programmatically. [3:26] Open the Antigravity MCP gallery, [3:28] find Stitch, and add it. [3:31] It will ask for an API key. [3:33] You can grab that from the Stitch Settings page. [3:36] Enter it into the Antigravity UI, and you're connected. [3:40] Your agent can now call tools like generate_screen_from_text, [3:44] edit_screens, and list_screens. [3:47] Second. [3:48] Chrome DevTools MCP. [3:51] This lets your coding agent inspect a live page in Chrome-- [3:54] read the dom, check computed styles, look at the console. [3:58] For this one, you just go to the GitHub repo. [4:01] You copy the Antigravity config block. [4:04] Then open the MCP settings in Antigravity. [4:07] Switch to the raw config editor, and paste it in. [4:11] Now, one little thing to watch for. [4:12] The GitHub config wraps the server in an MCP server's key. [4:17] But your config probably already has that parent. [4:20] So just paste the inner server block. [4:23] So the workflow is, one, design and stitch-- [4:26] prompt it with CSS concepts-- [4:29] two, inspecting Chrome-- use DevTools MCP to validate [4:33] the output-- [4:34] and, three, refine-- feed what you learn back [4:37] into the next prompt. [4:39] So design, inspect, refine-- [4:42] one loop. [4:43] And the CSS knowledge is what makes each iteration better [4:47] than the last. [4:48] DAVID EAST: All right, we have the tools set up, [4:50] so let's go build something. [4:52] And let's start with the layout. [4:56] And a quick note about this site. [4:58] It's a site about CSS features that [5:01] uses those same CSS features. [5:04] So it's a meta site. [5:06] So every card in this grid is a topic [5:08] that we're going to cover today built with the technique [5:12] that it's describing. [5:13] So I prompted Stitch to have this grid structure explicitly-- [5:18] four columns, the scroll animations card [5:21] spanning two columns, and two rows [5:24] as the hero, the Customizable Select [5:27] in a tall, single-column cell, and the secondary features [5:30] filling in around it. [5:33] So let's look at what came back. [5:36] So here is what Stitch did. [5:38] But let's actually get this into the IDE workflow. [5:44] So in Stitch, I right-click the screen, [5:46] and I can grab this link. [5:47] Then I can go into Antigravity, and I [5:49] paste in that link with a prompt to get the project info. [5:53] Antigravity talks to the Stitch MCP and returns [5:57] the project details, screen IDs, and everything that I need. [6:01] Now I need to see this in a real browser [6:04] so the Chrome DevTools MCP can access it. [6:07] So I wrote a small CLI tool for this, [6:09] which you can access at npx@_davideast/stitch-mcp. [6:14] You can use the serve command. [6:16] And this pulls the screen HTML down locally [6:19] and serves it on a local host. [6:22] And now that it's running locally, [6:25] the Chrome DevTools MCP can access the live dom. [6:29] So let's inspect what Stitch actually generated. [6:33] So if we look at the grid container, [6:35] Stitch used grid template columns repeat for [? 1 ?] [6:38] [? FR. ?] And the scroll animations card landed [6:41] in col-span-2, row-span-2. [6:44] And that's the hero card. [6:47] And the smaller feature cards all filled in around it. [6:51] But generating a static layout is like only half the story. [6:54] This is a bento grid. [6:56] And what's better than bento grid? [6:57] Well, a bento grid that you can drag and drop. [6:59] I wanted to see if Stitch can handle complex interactions [7:03] on top of this generated code, so I [7:05] asked it to make these cards draggable and re-orderable. [7:08] I was very specific in the prompt, [7:11] telling it to use standard vanilla JavaScript and pointer [7:14] events, so it just had pure performant code. [7:18] And let's see how it did. [7:21] Stitch generated a drag-and-drop bento box [7:23] that lets us reorder these cards while maintaining [7:26] their grid-span dimensions. [7:29] DION ALMAER: So before we start prompting screens, [7:31] we need to talk about the design system. [7:34] In Stitch, every project has something [7:36] called a DESIGN.md Think of it like that AgentMD for coding [7:40] agents, but for design. [7:42] It defines your colors, your typography, your spacing rules, [7:46] your component patterns. [7:48] And when the design agent reads it, every screen it generates [7:52] follows the same visual identity. [7:55] Without it, each screen is an island. [7:57] But with it, they all belong together. [8:00] Now, when you generate a screen, Stitch will automatically [8:03] create a design system for you. [8:05] Here, Stitch created the design system called the "technical [8:09] curator." [8:11] Every design system has a color scheme, typography hierarchy, [8:15] and components visualized. [8:18] There's also a written spec generated called DESIGN.md. [8:21] Now, this is a readable spec that [8:23] describes your visual identity and design [8:26] into an agent-readable document. [8:29] It contains colors with hex values and roles, [8:32] typography rules, component guidelines, dos and don'ts. [8:36] And you can export this file with your project, [8:40] and then any downstream developer or AI agent [8:43] can read it. [8:45] Now let me show you why this matters for the code. [8:49] When Stitch exports a screen, the design system tokens [8:52] become a Tailwind CSS config. [8:55] Our four color roles-- [8:57] primary, secondary, tertiary, neutral-- [9:00] each generates Tailwind CSS design tokens, [9:04] such as bg-primary, primary-container, [9:07] on-primary-container, and tokens for fonts, like font "headline," [9:12] font "body," and font "label," and even the corner radius scale [9:16] with tokens such as "rounded large," "rounded extra large," [9:19] "rounded full." [9:21] Every design decision I described in plain English [9:24] is now a utility class. [9:27] And here's the key thing. [9:29] Every screen we generate from this point [9:31] forward will inherit these tokens automatically. [9:34] The colors, the fonts, the spacing, they're all baked in. [9:39] And of course, if I want to change something later, [9:41] say I want to try a different accent color, I change it once [9:44] in the design system and apply it to screens. [9:47] And now everything will update. [9:49] That's the CSS custom properties model-- [9:52] one source of truth, many consumers. [9:56] Now, when you export the project, [9:57] the DESIGN.md file exports with it, [10:00] which means your design intent survives the handoff. [10:04] Let's look at what we're building next. [10:06] We're going to dive into scroll-driven animations. [10:10] Watch what happens as I scroll on this page. [10:14] One key thing is happening here. [10:16] This thin vertical spine grew from the top of the page [10:20] to the bottom. [10:21] And when I scroll back, it reverses. [10:25] That's a progress indicator bound directly [10:27] to the scroll bar. [10:29] There's no JavaScript scroll listeners. [10:31] It's all pure CSS. [10:34] One property is doing all of the work here. [10:36] It's the scroll timeline. [10:39] Here's the CSS that makes it work-- [10:42] a fixed position element with a scale Y [10:44] keyframe that goes from 0 to 1. [10:48] The magic is the raw animation timeline scroll. [10:52] That single declaration binds the animation progress [10:56] to the scroll position instead of time. [10:59] And "transform origin top center" [11:02] ensures it grows downward. [11:05] Now let's build this in Stitch. [11:09] The first step is the document structure. [11:11] I'm prompting Stitch to create an alternating two-column [11:15] layout-- [11:16] four sections, each a two-column grid, [11:19] alternating which side gets pros and which gets the code block. [11:24] There's no animations yet. [11:26] This is just the skeleton. [11:29] Now let's inspect the result using the Chrome DevTools. [11:33] Antigravity will get the screen ID and pull it up in Chrome. [11:37] The skeleton looks good. [11:39] So now let's pull in some animation. [11:41] This is step 2, the scroll-linked progress spine. [11:46] I want that thin vertical line fixed [11:49] to the center of the viewport so it grows as the user scrolls. [11:54] I'm going to ask my coding agent to generate a prompt that [11:57] leverages this CSS. [11:59] I'll specify using animation timeline scroll with a root [12:03] block axis, mapping the scale transform directly [12:07] to the scroll percentage. [12:09] And I'll make sure to specify "transform origin top center" [12:13] so it scales downward from the origin rather than the center. [12:18] Let's see what it gives us. [12:21] Before I run the prompt, look at what Antigravity came back with. [12:25] The agent understood the intent and broke it down [12:28] into exactly two pieces. [12:30] First, one empty div-- [12:32] editorial-spine as a direct child of the body. [12:37] That's really important because it [12:38] can't be nested inside a relatively positioned container [12:43] or the fixed positioning breaks. [12:45] Second, the CSS. [12:48] The agent centered the line with left 50%, [12:51] margin left minus 0.5 pixels, instead of translateX. [12:56] And that's a really good choice because it [12:58] keeps the transform property completely free for scale Y. [13:03] Then, the three lines that matter-- [13:05] "transform origin top center" animation, spine-draw linear, [13:10] and animation-timeline scrollroot block. [13:15] And notice what the agent called out about performance. [13:18] Because the only properties changing [13:20] are opacity and transform, the browser [13:22] handles this to the compositor thread. [13:25] Zero JavaScript listeners, zero layout recalculations. [13:31] Just like the original, when I scroll back, [13:33] it tracks my scroll position continuously [13:36] using the scroll timeline. [13:39] And the prompt that built it was specific about the mechanics, [13:43] the keyframes, and the timeline type. [13:47] The CSS vocabulary is what made the prompts precise enough [13:50] to get the right result. [13:52] DAVID EAST: OK, last demo. [13:54] Look at the left side of the screen. [13:56] That's a regular native select element. [13:59] It has a default system font, a default border, [14:02] an OS-rendered dropdown arrow that you can't change. [14:05] And for decades, this has been one [14:07] of the most frustrating elements in HTML to style. [14:11] I mean, people built entire JavaScript component libraries [14:14] just to get a decent-looking dropdown. [14:17] But now let's look at the right side. [14:19] This is the same element. [14:20] It's a real select, but it's styled [14:23] with appearance base-select. [14:26] It has a custom background, custom icon, custom typography, [14:30] and that blue bottom border. [14:33] Everything you see here is pure CSS on a native form element. [14:38] And that's what we're going to build. [14:41] So here's how it works. [14:43] One CSS property-- appearance base-select. [14:46] And that single declaration tells the browser [14:48] to stop rendering its own Chrome and hand control over to you. [14:53] Now, the select is just a box. [14:55] And I mean, you can put anything in the box. [14:58] So you could set the border. [14:59] You could set the font, everything [15:01] you do with any other element. [15:04] And the browser still handles all the accessibility [15:07] and keyboard behavior. [15:08] You just own the visuals. [15:11] So let's build that right side. [15:13] I'm telling Stitch exactly what I [15:15] want-- setting appearance base-select, [15:18] the warm gray background, the blue bottom border, [15:21] and the layers icon. [15:22] And I'm being really specific about the design tokens [15:25] because the more precise the prompt, [15:27] the closer that Stitch is going to get on the first try. [15:30] And here it is. [15:32] Remember that right side of the split screen? [15:35] Well, this is it running live. [15:37] It's the same thing-- that warm gray background, the blue accent [15:40] border, the Layers icon, all generated from that one prompt. [15:44] And if you tap to it from the keyboard, it just works. [15:48] And you can arrow through the options. [15:49] And the focus ring is there because it's just [15:52] a native select that looks like a custom component, [15:55] and it's all just CSS. [15:58] DION ALMAER: So your CSS knowledge [16:00] isn't just for implementation anymore. [16:02] It's your design vocabulary. [16:05] Every feature you learn, from grid, [16:07] to scroll-driven animations, custom select styling, custom [16:11] properties, clip path masking-- you name it-- it [16:14] gives you a new word in that vocabulary. [16:17] DAVID EAST: And don't forget to check [16:18] the description for all the links and tools and prompts. [16:21] And if you have any questions, I will literally [16:23] be the first comment on this talk. [16:25] So you can just ask. [16:26] DION ALMAER: So thank you so much for spending [16:28] this time with us. [16:29] And please, go design something. [16:31] DAVID EAST: And see you in the comments. [16:32] [MUSIC PLAYING]