# Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments - Harald Kirschner

Harald Kirschner

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/i1uPAN6uW4s-vibe-coding-at-scale-customizing-ai-assistants) · [Video](https://www.youtube.com/watch?v=i1uPAN6uW4s)

## Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments

A Copilot hydration-app demo shows how open-ended prototyping develops into a repeatable enterprise workflow through templates, instructions, review gates, and specifications.

Basic familiarity with VS Code, frontend project setup, and Git will help you follow the workflow.

### From experiments to maintainable code

[0:17](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=17s)

How do you keep the speed of asking an AI to build something while producing code another engineer can maintain? The environment for this walkthrough is VS Code Insiders. Harald Kirschner describes it as incorporating the team’s latest changes, with twice-daily builds, compared with the monthly stable release. These are recording-era details: his forecast of a release the following week on the 11th preceded the [VS Code 1.101 release](https://code.visualstudio.com/updates/v1_101), which ultimately shipped on June 12, 2025.

The starting point is the idea Kirschner attributes to Andrej Karpathy: give yourself over to the experiment and stop thinking about the code. That freedom makes a prototype exciting. It also leaves a gap between getting a website on screen and operating it responsibly. Kirschner describes the familiar failure mode: an experiment reaches production, things gradually fall apart, and bills rise. Speed, simplification, creativity, and fast learning are useful goals, but they do not establish production readiness.

![A screenshot of Andrej Karpathy’s post behind a large quotation: “Fully give in to the vibes, Embrace exponentials, And forget that the code even exists.”](https://ai.engineer/api/talk-essay-media/a55ef108ea0120e3726f675c95e3fb9859322795d6b021b95bb61348f5dc1266)

Karpathy’s vibe-coding premise: embrace the vibes and forget the code exists.

He introduces three provisional names for progressively more constrained workflows:

| Workflow | Main purpose | What constrains generation |
| --- | --- | --- |
| YOLO vibes | Explore and learn quickly | The desired outcome |
| Structured vibes | Produce maintainable work for handoff | Stack choices and conventions |
| Spec-driven vibes | Make reliable changes in large codebases | A specification and implementation plan |

**The transition is about making generated code fit its destination.** Structured work puts guardrails around the model’s creativity; spec-driven work aims to preserve that fit as the codebase and the number of contributors grow. In the exploratory starting point, however, the interaction remains outcome-focused: describe what you want, preferably in natural language or speech, and judge what appears.

### Accept, reset, and learn

[3:12](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=192s)

In the exploratory loop, accepting changes automatically is part of the bargain. You ask for an outcome, inspect the result, and let the implementation accumulate without reviewing every edit. When the direction goes wrong, undo it or discard the code and start again. This works for rapid prototypes and proofs of concept because the implementation is still disposable.

It can also be a way to learn an unfamiliar stack. Kirschner’s example moves from making a Rust game to making Frogger, then to making a neon, flickering Rust Frogger. Once there is something interesting to inspect, look at the code and ask the AI to explain how it works. Personal projects occupy a similar space: he describes building an app with his children over a weekend to meet a family need, explicitly without shipping it to production. The value is exploration and understanding, without assuming a long-term maintenance commitment.

![YOLO Vibe Coding slide lists outcome-first focus, natural-language iteration, and auto-accept with undo; recommended uses include rapid prototyping, learning unfamiliar technologies, and personal projects without maintenance concerns.](https://ai.engineer/api/talk-essay-media/5842a9f24d7041d3a019e7d3bc5b53e760fa28b07327a899fbd24a5ebb6fcfbb)

YOLO vibe coding pairs outcome-first iteration with auto-accept and undo.

### Dictating a hydration tracker

[4:16](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=256s)

The live example begins in a new VS Code Insiders window with **Copilot agent mode** selected. Agent mode was not yet the default in the demonstrated build. Kirschner then shows Auto Approve, which suppresses confirmation prompts and, in that version, can be enabled for the workspace alone. He presents it with caveats as a way to keep an exploratory session moving, not as a general production setting.

The microphone provides another way to remove friction. Kirschner describes local speech recognition and notes that spoken responses can also be enabled; his shortcut for the interaction is `Command+I`. The privacy boundary matters: [VS Code Speech](https://code.visualstudio.com/updates/v1_84) supplies local transcription through an extension. Local dictation does not mean that the subsequent Copilot interaction runs entirely on the machine.

He dictates a concrete request: build a water-hydration tracking app in React and Vite, use Material UI, and follow an Apple-esque visual design. Copilot first invokes its create-new-workspace tool. An audience question establishes that this is ordinary Copilot agent mode, rather than a separate application-building product. After Kirschner chooses a location, the agent can continue inside the new workspace.

Copilot shares a high-level plan reflecting the requested stack and design, then proceeds with scaffolding and installation work while the presentation returns to the slides. Kirschner refers to install and development commands as the work continues. This is a demonstration of delegating the setup and implementation process; the recording does not establish a completed, tested, or deployed hydration app.

### Model choice and the iteration controls

[7:06](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=426s)

Asked which model is doing the work, Kirschner identifies **Claude Sonnet 4**, which he likes for this UI example. His experience running the same request with different models produces an informal comparison:

| Model named in the talk | Kirschner’s aesthetic impression |
| --- | --- |
| Claude Sonnet 4 | Good at UI, but can overuse dark backgrounds, gradients, and large lettering |
| **4.1** | More like a wireframe |
| **2.5 Pro** | A distinctive, variable design sense |

These are observations about generated designs, not benchmark results. His warning about Sonnet is especially concrete: insufficient direction can yield something resembling a blockchain landing page, regardless of the application’s actual purpose.

The surrounding controls make the prototype easier to steer and recover:

- **Workspace creation:** The new-workspace flow reduces setup work, but requesting a new app from inside an existing project can trigger it unexpectedly.
- **Visual context:** Kirschner describes opening the result in VS Code’s browser preview and selecting specific page elements to guide subsequent changes. He does not demonstrate a finished hydration app using this interaction.
- **Continuous updates:** Delayed auto-accept and auto-save can keep changes flowing into a running preview.
- **Recovery:** Undo and revert let the developer back out of an unwanted direction.

Together with agent mode and voice dictation, these controls support a short cycle of asking, inspecting, and revising.

### What the agent can see when something fails

[8:29](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=509s)

An audience question exposes an important boundary: how does the agent learn about errors? For failed terminal commands, Kirschner explains a direct feedback loop. The agent reads command output, identifies a problem such as a missing dependency, and can issue another command to address it. His example is a change in the shadcn installation process: if an error tells the agent to use a different package, that message can guide the next attempt.

The audience then distinguishes browser-console errors from terminal output. Kirschner responds by discussing background terminals and ongoing work to make their output discoverable. That does not establish comprehensive browser-console visibility. **An error can guide the agent only if it reaches the agent’s context.** Selecting a browser element and reading a failed terminal command provide different kinds of evidence; neither should be assumed to capture every runtime failure.

This is why open-ended experimentation has value beyond the prototype itself. It builds a personal baseline for what the AI handles well, where it struggles, and how much steering it needs. Kirschner chooses React and Vite because they provide familiar, stable grounding for the demo. With newer frameworks, he recommends being explicit about where the documentation lives and how the agent should consult it. Treat the work like a whiteboard: erase an approach, restart, or refine one part, while deliberately learning from each iteration.

### Put the enterprise defaults in the starting point

[10:01](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=601s)

Structured work begins by replacing the blank canvas with a **shared template**. A repository or development container can already contain the internal stack. A contributor checks it out, opens it in VS Code, enables agent and voice modes, and starts exploring. Even a nontechnical teammate working on UX can begin from the same foundations as engineering. The template carries instructions that guide Copilot toward the team’s existing conventions.

Custom tools, including MCP integrations, extend that foundation by giving the agent access to information and context it would otherwise lack. The UI-library choice illustrates the difference. The hydration prompt explicitly requested Material UI; without that constraint, the model might have selected another framework, such as Tailwind. In an organization using Fluent UI, the template can instead specify Fluent UI and where to obtain its package. A repeated architectural decision becomes part of the starting context rather than something every contributor must remember to request.

The intended result is a greenfield prototype that engineering can accept without rejecting its basic stack choices. Extra instructions also help when a framework or version is less familiar to the model. Kirschner uses a particular Spring Boot version as an example: give the agent the missing guidance instead of expecting its default knowledge to match the project.

For the customization walkthrough, he opens the [Frontend Vibes Template](https://github.com/digitarald/frontend-vibes-template) under his `digitarald` GitHub account. This is a separate template example from the hydration app being generated in the background. The focus now shifts from requesting an application to defining the environment in which future requests will run.

### Encode the workflow and its approval boundary

[12:33](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=753s)

The first customization is a **chat mode**. In the demonstrated version, files under `.github/chatmodes` define the mode’s instructions and available tools, and the developer selects that mode in place of the usual agent behavior. VS Code later [renamed custom chat modes to custom agents](https://code.visualstudio.com/updates/v1_106) and introduced `.github/agents`; the recording uses the earlier terminology and directory.

Kirschner’s example mode applies test-driven development. The red, green, and refactor framing becomes a concrete interaction sequence:

1. Have the agent write tests first.
2. Pause for the developer to review those tests and explicitly confirm that implementation should proceed.
3. Have the agent write the implementation and make the tests pass, with refactoring as part of the workflow.

**The approval boundary sits before implementation.** Kirschner prefers reviewing the proposed tests because they are easier for him to assess than reviewing all the generated code afterward. The mode describes how the agent should work; the presentation does not show this test sequence being executed to completion.

Reusable prompts serve a different purpose: they package tasks that a team repeats. A design team needing micro-landing pages can reuse a prompt defining how those pages should be structured across successive requests. Instruction files under `.github/instructions` supply another layer, explaining particular areas of the codebase. Modes define workflow behavior, prompts define repeatable requests, and instructions supply the local conventions those requests must respect.

### Preserve working states, then scale the plan

[13:46](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=826s)

The final layer connects customization to the development feedback already present in the workspace. Kirschner recommends workspace instructions and reusable prompts, with instructions applied dynamically to the relevant parts of the codebase. MCP can bring in further context and tools, although it is not demonstrated here; he points to his companion [Full Spec MCP talk](https://ai.engineer/talks/full-spec-mcp-hidden-capabilities-of-the-mcp-spec-harald-kirschner-microsoft-vs-code) for those examples.

Configured VS Code tasks, linters, and the Problems view give the agent evidence of mistakes as it works. That turns existing development checks into corrective context: generated code produces diagnostics, and those diagnostics can guide the next edit. Once the code reaches a working state, preserve it in a commit. Kirschner points out the commit UI’s sparkle control, but the substantive practice is frequent checkpoints so a later experiment does not destroy the last recoverable version. Review changes, begin with reported errors, and pause the agent when inspection is needed.

![Your Structured Toolbox slide has two columns covering workspace instructions, dynamic instructions, custom context tools, problems and task tools, auto-generated commits, and fine-grained review.](https://ai.engineer/api/talk-essay-media/c28acf57ec4d95663508514d42ec3a6e23fd2d2af16c2947e3f81060bdf253d5)

The structured toolbox combines instructions, context tools, diagnostics, commits, and review.

The closing extension is **specification → plan → implementation**. Start by describing the required change, turn that specification into a plan, and then implement the plan. Kirschner presents this briefly as the direction for larger codebases, supported by reusable prompts, additional MCP integrations, and tools tailored to the task. The same ability to generate code remains, but the work now proceeds inside an explicit account of what should change and how it should fit.

## Resources

- [Frontend Vibes Template](https://github.com/digitarald/frontend-vibes-template) — Kirschner’s public frontend template, with a Next.js starter and workspace configuration.
- [VS Code 1.101: custom chat modes and MCP](https://code.visualstudio.com/updates/v1_101) — Historical release notes covering custom chat modes and expanded MCP support.
- [VS Code 1.100: prompts, diagnostics and visual context](https://code.visualstudio.com/updates/v1_100) — Explains reusable prompts, diagnostic feedback, workspace creation and selecting browser elements as chat context.
- [From chat modes to custom agents](https://code.visualstudio.com/updates/v1_106) — Documents the later custom-agent terminology and configuration directory.
- [Full Spec MCP: Hidden Capabilities of the MCP Spec](https://ai.engineer/talks/full-spec-mcp-hidden-capabilities-of-the-mcp-spec-harald-kirschner-microsoft-vs-code) — Kirschner’s companion presentation on richer MCP capabilities through VS Code examples.

## Slides

### Vibe Coding at Scale

Harald Kirschner introduces his talk on customizing AI assistants for enterprise environments and invites viewers to follow along in VS Code. Some examples use the Insiders pre-release.

[0:26](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=26s) [Title slide for Harald Kirschner’s talk on customizing AI assistants for enterprise environments.](https://assets.ai.engineer/sites/aiecode2025/sha256/4eac2b192cbf360b5221bbb7f0e039408bb685fc91fe290dfa751233c3a2d9d0.webp)

Microsoft

Vibe Coding at Scale
Customizing AI Assistants for Enterprise Environments

Harald Kirschner

AIE
Microsoft
smol ai

### The vibe coding idea

Kirschner introduces Karpathy’s idea of vibe coding: give in to the vibes, accept changes without reading diffs, and forget that the code exists.

[0:50](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=50s) [A quotation about embracing the vibes and forgetting that code exists, over a post by Andrej Karpathy.](https://assets.ai.engineer/sites/aiecode2025/sha256/ed88aed4b1dfde5c4858ae6fc8c52887e706d2a7f7688b7470b908b1cfa6697f.webp)

Fully give in to the vibes,
Embrace exponentials,
And forget that the code even exists

Andrej Karpathy
@karpathy

There's a new kind of coding I call "vibe coding", where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. It's possible because the LLMs (e.g. Cursor Composer w Sonnet) are getting too good. Also I just talk to Composer with SuperWhisper so I barely even touch the keyboard. I ask for the dumbest things like "decrease the padding on the sidebar by half" because I'm too lazy to find it. I "Accept All" always, I don't read the diffs anymore. When I get [illegible]

Interface text:
AIE
Microsoft
smol ai

### YOLO Vibe Coding

YOLO vibe coding focuses on outcomes: iterate in natural language, auto-accept changes, and undo when needed. Kirschner suggests it for prototypes, learning, and personal projects without maintenance concerns.

[3:00](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=180s) [Slide lists outcome-first focus, natural-language iteration, automatic acceptance, and suitable uses.](https://assets.ai.engineer/sites/aiecode2025/sha256/ba8c64157973761cf09996cd26236482c06d7dd47fb0b4f30cae82f6ca813e22.webp)

YOLO Vibe Coding

1. Outcome-first focus, ignore the code
2. Iterate with natural language
3. Auto-accept changes, undo if needed

Best for:
• Rapid prototyping and proof-of-concepts
• Learning unfamiliar technologies or frameworks
• Personal projects with no maintenance concerns

AIE
Microsoft
smol ai

### YOLO Vibe Coding

Kirschner introduces a VS Code demo after describing an app he built with his kids for personal use.

[4:14](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=254s) [Illustrated YOLO Vibe Coding title with a laptop user and an AI figure.](https://assets.ai.engineer/sites/aiecode2025/sha256/4347e844aca03db1d9f97ae135743aaa971f859908f33e976497e3501fcff484.webp)

YOLO VIBE CODING

AIE
Microsoft
smol ai

### Copilot Agent Mode and Settings

Kirschner shows VS Code settings beside Copilot’s Agent Mode. The panel describes choosing files, running terminal commands, and iterating on errors across multiple requests.

[4:53](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=293s) [VS Code settings are open beside the Copilot agent-mode panel.](https://assets.ai.engineer/sites/aiecode2025/sha256/998cc4e06cb4db01438f9041ed566ef19ac5141f2e87baf40bad7d6aa34c7638.webp)

Commonly Used

Editor: Font Size (Also modified in Markdown > User)
Controls the font size in pixels.
17

Editor: Format On Save
Format a file on save. A formatter must be available and the editor must not be shutting down. When Files: Auto Save is set to afterDelay, the file will only be formatted when saved explicitly.

Files: Auto Save
Controls auto save of editors that have unsaved changes.
afterDelay

Editor: Default Formatter (Modified elsewhere)
Defines a default formatter which takes precedence over all other formatter settings. Must be the identifier of an extension contributing a formatter.
None

Edit with Copilot
Agent Mode

Ask Copilot to edit your files in agent mode. Copilot will automatically use multiple requests to pick files to edit, run terminal commands, and iterate on errors.

Copilot is powered by AI, so mistakes are possible. Review output carefully before use.

or type # to attach context

Interface text:
04:52
Settings
Search settings
User
Last synced: 0 secs ago
CHAT
Add Context...
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4 (Preview)
AIE
Microsoft
smol ai

### Copilot Auto Approve

Kirschner shows the experimental Auto Approve setting enabled. It skips tool confirmation prompts, and he notes that it can be enabled for a workspace only.

[5:05](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=305s) [VS Code settings search shows the experimental Chat Tools Auto Approve option checked.](https://assets.ai.engineer/sites/aiecode2025/sha256/b6b0d7a0727054030b9bd3f2c7ca9d1fec2fac3ed18056ec915e9ec8ba1f6129.webp)

Chat › Tools: Auto Approve  Experimental
Controls whethe[illegible]approved.

Edit with Copilot
Agent Mode

Ask Copilot to edit your files in agent mode. Copilot will automatically use multiple requests to pick files to edit, run terminal commands, and iterate on errors.

Copilot is powered by AI, so mistakes are possible. Review output carefully before use.

or type # to attach context

Interface text:
05:01
Settings
Search
approve
1 Setting Found
User
Last synced: 0 secs ago
chat.tools.autoApprove - Modified
CHAT
Add Context...
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4 (Preview)
AIE
aws

[5:14](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=314s) [VS Code settings show Chat Tools Auto Approve enabled beside the Copilot agent panel.](https://assets.ai.engineer/sites/aiecode2025/sha256/eb6493143557f914da95ad2910d638e25c9bf2bfb4a555c322cb6dc238cc1378.webp)

Chat › Tools: Auto Approve  Experimental
Controls whether tool use should be automatically approved.

Edit with Copilot
Agent Mode

Ask Copilot to edit your files in agent mode. Copilot will automatically use multiple requests to pick files to edit, run terminal commands, and iterate on errors.

Copilot is powered by AI, so mistakes are possible. Review output carefully before use.

or type # to attach context

Interface text:
05:11
Settings
Search
approve
1 Setting Found
User
Last synced: 0 secs ago
CHAT
Add Context...
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4 (Preview)
AIE
Microsoft
smol ai

### Voice chat control

Kirschner points to VS Code’s microphone button for chatting with AI. He says it uses a local model and nothing leaves the machine.

[5:28](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=328s) [Close-up of the pointer over the microphone button in the Copilot chat input.](https://assets.ai.engineer/sites/aiecode2025/sha256/dd5b1e33712c5e3eac890fad996d3ec68530bfc83b913f972530cffb818c2630.webp)

### Start voice chat

Kirschner highlights the microphone control to start a Copilot voice chat. He says the voice feature uses a local model, so nothing leaves the machine.

[5:39](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=339s) [Copilot agent chat with the Start Voice Chat tooltip visible over the microphone control.](https://assets.ai.engineer/sites/aiecode2025/sha256/f515a02b87f23cd413a64aa17c329d22b2f31257ee4498ea8de8865902da6e19.webp)

Edit with Copilot
Agent Mode

Ask Copilot to edit your files in agent mode. Copilot will automatically use multiple requests to pick files to edit, run terminal commands, and iterate on errors.

Copilot is powered by AI, so mistakes are possible. Review output carefully before use.

or type # to attach context

Interface text:
CHAT
Show All Commands ⇧ ⌘ P
Open File or Folder ⌘ O
Open Recent ⌃ R
New Untitled Text File ⌘ N
Open Chat ⌃ ⌘ I
Add Context...
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4 (Preview)
Start Voice Chat (⌘I)
Search
AIE
Microsoft
smol ai

### Voice chat listening

Kirschner activates Copilot voice chat and dictates a request for a hydration tracker using React, Vite, Material UI and Apple-esque design.

[5:47](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=347s) [Copilot chat displays “I'm listening” with the microphone active.](https://assets.ai.engineer/sites/aiecode2025/sha256/df6ee71082a79f2df9dbf81494b4dfa223299489f7ed57bb99866e6a12aff422.webp)

Edit with Copilot
Agent Mode

Ask Copilot to edit your files in agent mode. Copilot will automatically use multiple requests to pick files to edit, run terminal commands, and iterate on errors.

Copilot is powered by AI, so mistakes are possible. Review output carefully before use.

or type # to attach context

Interface text:
AIE
Code - Insiders
File  Edit  Selection  View  Go  Run  Terminal  Window  Help
Search
CHAT
Show All Commands  ⇧ ⌘ P
Open File or Folder  ⌘ O
Open Recent  ⌃ R
New Untitled Text File  ⌘ N
Open Chat  ⌃ ⌘ I
Add Context...
I'm listening
Agent
Claude Sonnet 4 (Preview)
Stop Listening (Escape)
aws

### Copilot hydration app demo

Kirschner dictates a hydration-tracking app request. Copilot responds by starting its Create New Workspace tool for the React app.

[6:02](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=362s) [Copilot chat contains a dictated request for a hydration tracking app using React and Material UI.](https://assets.ai.engineer/sites/aiecode2025/sha256/d5e9e6f572d013f365d2cf22f4933008c39e480d8792868780f3a763da14c006.webp)

Edit with Copilot
Agent Mode

Ask Copilot to edit your files in agent mode. Copilot will automatically use multiple requests to pick files to edit, run terminal commands, and iterate on errors.

Copilot is powered by AI, so mistakes are possible. Review output carefully before use.

or type # to attach context

Let's make an app for water hydration tracking in React and White. It should use Material UI and follow nice Apple esque design principles.

Interface text:
CHAT
Show All Commands ⇧ ⌘ P
Open File or Folder ⌘ O
Open Recent ⌃ R
New Untitled Text File ⌘ N
Open Chat ⌃ ⌘ I
Add Context...
Agent
Claude Sonnet 4 (Preview)
Stop Listening (Escape)
AIE
Microsoft
smol ai

[6:09](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=369s) [VS Code Copilot responds to a request for a hydration-tracking app and begins creating a workspace.](https://assets.ai.engineer/sites/aiecode2025/sha256/a66ebb0fc989b1b72a950a498ffb8ea9cff1309e9dc4c7a1c79248f0b3fdc08e.webp)

Let's make an app for water hydration tracking in React and White. It should use Material UI and follow nice Apple esque design principles.

GitHub Copilot

I'll help you create a water hydration tracking app in React with Material-UI and Apple-esque design principles. Let me start by creating a new workspace for this project.

Using "Create New Workspace"

Interface text:
CHAT
Show All Commands ⇧ ⌘ P
Open File or Folder ⌘ O
Open Recent ⌃ R
New Untitled Text File ⌘ N
Open Chat ⌃ ⌘ I
Add Context...
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4 (Preview)
AIE
aws

### Creating a React hydration app

Copilot lays out a plan for the hydration app, then starts scaffolding a React and TypeScript project with Vite. The selected model is Claude Sonnet 4 (Preview).

[6:52](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=412s) [Copilot displays a developing plan to scaffold a React and TypeScript project with Vite and install Material UI.](https://assets.ai.engineer/sites/aiecode2025/sha256/d3e0c6f7bc5ec9c067c569bf413184c8ad21dd0347645cd173988ea5b3055a03.webp)

Using "Create New Workspace"

Continue with #new workspace setup

GitHub Copilot
I'll create a new React workspace for your water hydration tracking app with Material-UI and Apple-esque design principles.

Generating plan to create a new workspace

Perfect! I'll create a React water hydration tracking app with Material-UI and Apple-esque design. Let me start by getting the project setup information and then scaffold the project.

High-Level Plan:
1. Get React project template using Vite
2. Scaffold the project with Vite + React + TypeScript
3. Install Material-UI

Interface text:
vibing-demo-0229834
CHAT
Show All Commands
Go to File
Open Chat
Open Settings
Find in Files
Add Context...
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4 (Preview)
AIE
Microsoft
smol ai

[6:57](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=417s) [VS Code Copilot displays a hydration app plan while a Vite scaffold command runs in the terminal.](https://assets.ai.engineer/sites/aiecode2025/sha256/fb761880ca9d6cec7122b1342a7a92c697142b79262671f6561bab94438469d2.webp)

GitHub Copilot
I'll create a new React workspace for your water hydration tracking app with Material-UI and Apple-esque design principles.

Generating plan to create a new workspace

Perfect! I'll create a React water hydration tracking app with Material-UI and Apple-esque design. Let me start by getting the project setup information and then scaffold the project.

High-Level Plan:
1. Get React project template using Vite
2. Scaffold the project with Vite + React + TypeScript
3. Install Material-UI dependencies
4. Create the hydration tracking app with Apple-inspired design
5. Set up the development environment and tasks

Let me begin:

Getting setup information

Now I'll scaffold the React project with TypeScript using Vite:
npx create-vite@latest . --template react-ts

Terminal:
npx create-vite@latest . --template react-ts
~/vibing-demo-0229834
❯ npx create-vite@latest . --template react-ts

Interface text:
vibing-demo-0229834
CHAT
PROBLEMS
DEBUG CONSOLE
TERMINAL
PORTS
OUTPUT
Copilot
Add Context...
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4 (Preview)
AIE
aws

### Tips for better YOLO Vibing

Kirschner recommends experimenting to learn AI’s strengths and limits, using familiar frameworks, and treating iteration like a whiteboard: erase, redraw, and start over when needed.

[9:06](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=546s) [Three tips: build AI intuition, use known frameworks, and iterate like a whiteboard.](https://assets.ai.engineer/sites/aiecode2025/sha256/e072e1ea15c16563ce174212df820a25e16dad93d7658728af2cb40240372a20.webp)

Tips for better YOLO Vibing

Build AI Intuition
Vibe-code to discover what AI does well, how to steer it, and its limits.

Use Known Frameworks
Choose popular stacks with clear, consistent conventions

Iterate like a whiteboard
Wipe, redraw, and zoom out until the shape emerges.

Interface text:
AIE
aws

### Structured Vibe Coding

A starter template fixes the tech stack, instructions guide conventions, and custom tools supply context. This can help greenfield projects produce work that fits an engineering team’s practices.

[10:04](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=604s) [Slide describing templates, instructions and custom tools for structured vibe coding, with suggested uses.](https://assets.ai.engineer/sites/aiecode2025/sha256/22ec18ad8eb0bf85ed6150deda0d4e25567fb62098d684c1ff5dd834c300277b.webp)

Structured Vibe Coding

• Starter template as consistent tech stack
• Instructions define conventions & guardrails
• Custom tools for expert

Best for:
• Faster and more consistent than YOLO
• Bootstrapping greenfield projects
• Out-of-the-mainstream workloads stacks

AIE
Microsoft
smol ai

### Test-Driven Development Assistant Demo

The open TDD chat mode specifies tools and a prompt that directs the assistant through Red → Green → Refactor, starting with requirements and clarification.

[12:17](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=737s) [Code editor showing a test-driven development assistant configuration beside an AI chat pane.](https://assets.ai.engineer/sites/aiecode2025/sha256/5860507f4396b02714f36cce5ac348645d3b06949afd9fe6b380c73503e91895.webp)

---
description: 'Test-Driven Development (TDD) assistant that enforces writing tests before implementation'
tools: ['codebase', 'usages', 'problems', 'testFailure', 'findTestFiles', 'editFiles']
---

# Test-Driven Development (TDD) Assistant

You are a Test-Driven Development specialist that strictly enforces the TDD cycle: Red → Green → Refactor.

## Core TDD Principles

You MUST follow this exact sequence for every feature request:

### 1. UNDERSTAND (Clarification Phase)
- Always start by clearly understanding the requirements
- Ask clarifying questions if the requirements are ambiguous
- Break down complex features into smaller, testable units
- Identify edge cases and error conditions upfront
- Confirm your understanding with the user before proceeding

Chat pane:
Context Matters: GitHub metrics provide only partial insights. Different project phases naturally produce varying activity patterns. A developer solving complex architectural challenges might commit less frequently but provide more value.

Quality Over Quantity: Research shows that developer satisfaction is actually a stronger indicator of productivity than raw commit counts or deployment metrics. Happy developers write better code and solve harder problems.

Balanced Approach: The most effective productivity measurement combines GitHub metrics with qualitative factors like:
- Code quality and impact
- Mentoring and knowledge sharing
- Process improvements
- Team collaboration effectiveness

Best Practices for Implementation
1. Focus on Trends: Look at patterns over time rather than absolute numbers
2. Team Context: Consider team size, project complexity, and development phase
3. Multiple Perspectives: Combine quantitative metrics with developer feedback
4. Actionable Insights: Ensure metrics lead to improvements, not just measurement
5. Avoid Gaming: Be aware that focusing too heavily on specific metrics can lead to counterproductive behaviors

Would you like me to help implement any specific GitHub productivity metrics in your current Next.js application? I can see you have a dashboard structure already set up in your components.

Interface text:
.github/chatmodes — frontend-vibes
spec.md
spec.prompt.md M
TDD.chatmode.md U
EXPLORER
FRONTEND-VIBES
.devcontainer
devcontainer.json
.github
chatmodes
TDD.chatmode.md U
instructions
frontend.instructions.md
prompts
plan.prompt.md M
spec.prompt.md M
copilot-instructions.md
.vscode
mcp.json
tasks.json
src
app
favicon.ico
global-error.tsx
globals.css
layout.tsx
page.tsx
components
dashboard
layout
header.tsx
ui
alert.tsx
avatar.tsx
badge.tsx
Configure Tools...
CHAT
Add Context...
TDD.chatmode.md
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4 (Preview)
Ln 8, Col 81
Spaces: 4
Chat Mode
AIE
Microsoft
smol ai

### Frontend template repository

Kirschner shows the frontend-vibes-template repository on GitHub before beginning a quick roundup of chat modes.

[12:33](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=753s) [A browser shows the frontend template repository on GitHub.](https://assets.ai.engineer/sites/aiecode2025/sha256/f6af24d87fec0e1b831201898ec87673c74b493f6a2e2ca08d59a4993ee96763.webp)

digitarald / frontend-vibes-template

Interface text:
https://github.com/digitarald/frontend-vibes-template
refs/gh/queue/mas...
github/code_view
Feedback
Rails
Code
Issues
Pull requests
Actions
Pr[illegible]
AIE
Microsoft
smol ai

### TDD chat mode instructions

The TDD chat mode file defines its tools and guides the assistant to clarify requirements, then write failing tests before implementation.

[12:38](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=758s) [VS Code displays a custom TDD chat mode with instructions to understand requirements and write failing tests first.](https://assets.ai.engineer/sites/aiecode2025/sha256/62517164e8b25420154adfdb7c845afc3f261842a59bacbc4b1bed6f36d714e8.webp)

---
description: 'Test-Driven Development (TDD) assistant that enforces writing tests before implementation'
tools: ['codebase', 'usages', 'problems', 'testFailure', 'findTestFiles', 'editFiles']
---

Test-Driven Development (TDD) Assistant

You are a Test-Driven Development specialist that strictly enforces the TDD cycle: Red → Green → Refactor.

Core TDD Principles

You MUST follow this exact sequence for every feature request:

1. UNDERSTAND (Clarification Phase)
- Always start by clearly understanding the requirements
- Ask clarifying questions if the requirements are ambiguous
- Break down complex features into smaller, testable units
- Identify edge cases and error conditions upfront
- Confirm your understanding with the user before proceeding

2. RED (Write Failing Tests First)
- Write comprehensive tests BEFORE any implementation code
- Cover happy path, edge cases, and error scenarios
- Ensure tests are specific, readable, and focused
- Run tests to confirm they fail for the right reasons

Interface text:
.github/chatmodes — frontend-vibes
spec.md
spec.prompt.md M
TDD.chatmode.md U
EXPLORER
FRONTEND-VIBES
.devcontainer
devcontainer.json
.github
chatmodes
TDD.chatmode.md U
instructions
frontend.instructions.md
prompts
plan.prompt.md M
spec.prompt.md M
copilot-instructions.md
.vscode
mcp.json
tasks.json
src
app
favicon.ico
global-error.tsx
globals.css
layout.tsx
page.tsx
components
dashboard
layout
header.tsx
ui
alert.tsx
avatar.tsx
badge.tsx
Configure Tools...

CHAT
Context Matters: GitHub metrics provide only partial insights. Different project phases naturally produce varying activity patterns. A developer solving complex architectural challenges might commit less frequently but provide more value.

Quality Over Quantity: Research shows that developer satisfaction is actually a stronger indicator of productivity than raw commit counts or deployment metrics. Happy developers write better code and solve harder problems.

Balanced Approach: The most effective productivity measurement combines GitHub metrics with qualitative factors like:
- Code quality and impact
- Mentoring and knowledge sharing
- Process improvements
- Team collaboration effectiveness

Best Practices for Implementation
1. Focus on Trends: Look at patterns over time rather than absolute numbers
2. Team Context: Consider team size, project complexity, and development phase
3. Multiple Perspectives: Combine quantitative metrics with developer feedback
4. Actionable Insights: Ensure metrics lead to improvements, not just measurement
5. Avoid Gaming: Be aware that focusing too heavily on specific metrics can lead to counterproductive behaviors

Would you like me to help implement any specific GitHub productivity metrics in your current Next.js application? I can see you have a dashboard structure already set up in your components.

Add Context...
TDD.chatmode.md
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4 (Preview)
Ln 8, Col 81
Spaces: 4
Chat Mode
AIE
Microsoft
smol ai

### Selecting a custom chat mode

Kirschner opens the chat mode menu, where the custom TDD mode appears alongside the built-in modes. Its file defines tools and instructions for writing tests before implementation.

[12:51](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=771s) [VS Code displays the chat mode menu with TDD listed under custom modes.](https://assets.ai.engineer/sites/aiecode2025/sha256/5a3b0da6e051cff5fbf7db930430cd9563992b35977b502efc9bbdce7b801552.webp)

---
description: 'Test-Driven Development (TDD) assistant that enforces writing tests before implementation'
tools: ['codebase', 'usages', 'problems', 'testFailure', 'findTestFiles', 'editFiles']
---

Test-Driven Development (TDD) Assistant

You are a Test-Driven Development specialist that strictly enforces the TDD cycle: Red → Green → Refactor.

Core TDD Principles

You MUST follow this exact sequence for every feature request:

1. UNDERSTAND (Clarification Phase)
- Always start by clearly understanding the requirements
- Ask clarifying questions if the requirements are ambiguous
- Break down complex features into smaller, testable units
- Identify edge cases and error conditions upfront
- Confirm your understanding with the user before proceeding

2. RED (Write Failing Tests First)
- Write comprehensive tests BEFORE any implementation code
- Cover happy path, edge cases, and error scenarios
- Ensure tests are specific, readable, and focused
- Run tests to confirm they fail for the right reasons

Chat response:
Context Matters: GitHub metrics provide only partial insights. Different project phases naturally produce varying activity patterns. A developer solving complex architectural challenges might commit less frequently but provide more value.

Quality Over Quantity: Research shows that developer satisfaction is actually a stronger indicator of productivity than raw commit counts or deployment metrics. Happy developers write better code and solve harder problems.

Balanced Approach: The most effective productivity measurement combines GitHub metrics with qualitative factors like:
- Code quality and impact
- Mentoring and knowledge sharing
- Process improvements
- Team collaboration effectiveness

Best Practices for Implementation
1. Focus on Trends: Look at patterns over time rather than absolute numbers
2. Team Context: Consider team size, project complexity, and development phase
3. Multiple Perspectives: Combine quantitative metrics with developer feedback
4. Actionable Insights: Ensure metrics lead to improvements, not just measurement
5. Avoid Gaming: Be aware that focusing too heavily on specific metrics can lead to counterproductive behaviors

W[illegible] implement any specific GitHub productivity metrics in
y[illegible]cation? I can see you have a dashboard structure already
s[illegible]s.

Interface text:
.github/chatmodes — frontend-vibes
spec.md
spec.prompt.md M
TDD.chatmode.md U
EXPLORER
FRONTEND-VIBES
.devcontainer
devcontainer.json
.github
chatmodes
TDD.chatmode.md
instructions
frontend.instructions.md
prompts
plan.prompt.md M
spec.prompt.md M
copilot-instructions.md
.vscode
mcp.json
tasks.json
src
app
favicon.ico
global-error.tsx
globals.css
layout.tsx
page.tsx
components
dashboard
layout
header.tsx
ui
alert.tsx
avatar.tsx
badge.tsx
Configure Tools...
CHAT
Built-In
Ask
Agent
Edit
Custom
TDD
Configure Modes
Agent
Claude Sonnet 4 (Preview)
Ln 8, Col 81
Spaces: 4
Chat Mode
AIE
aws

### TDD mode description

The custom TDD mode appears in the chat mode menu. Its description guides the assistant to write tests before implementation.

[12:56](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=776s) [A tooltip describes the custom TDD mode as requiring tests before implementation.](https://assets.ai.engineer/sites/aiecode2025/sha256/a586782e84314f8444f02918f010283c68c628c9cba0c566ed4b09bc676d2c8d.webp)

[illegible] sequence for every feature request:

[illegible]ation Phase)
[illegible]ly understanding the requirements
[illegible] if the requirements are ambiguous
[illegible]es into smaller, testable units
[illegible]rror conditions upfront
[illegible]g with the user before proceeding

[illegible]ests First)
[illegible] BEFORE any implementation code
[illegible]ses, and error scenarios
[illegible] readable, and focused
[illegible] the right reasons

• Process improvements
• Team collaboration effectiveness

Best Practices for Implementation
1. Focus on Trends: Look at patterns over time rather than [illegible]
2. Team Context: Consider team size, project complexity, [illegible] phase
3. Multiple Perspectives: Combine quantitative metrics w[illegible]
4. Actionable Insights: Ensure metrics lead to improveme[illegible] measurement
5. Avoid Gaming: Be aware that focusing too heavily on sp[illegible] to counterproductive behaviors

W[illegible] implement any specific GitHub pro[illegible]
y[illegible]cation? I can see you have a dashb[illegible]
s[illegible]s.

Interface text:
Built-In
Ask
Agent
Edit
Custom
TDD
Test-Driven Development (TDD) assistant that enforces writing tests before implementation
Configure Modes
Agent
Claude Sonnet 4 (Preview)
Ln 8, Col 81
Spaces: 4
AIE
Microsoft
smol ai

### TDD response sequence

The custom TDD mode asks for tests first, then pauses for confirmation before implementation. Kirschner wants to review the tests before the assistant writes code.

[13:02](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=782s) [The TDD instructions outline writing tests, seeking confirmation, implementing and refactoring.](https://assets.ai.engineer/sites/aiecode2025/sha256/fbd24f1435496b189a06714eb8e988911bd6b4df79f823c5cbd10030835504d1.webp)

RED Phase - Writing Tests
[Explain what tests you'll write and why]

Confirmation Point
[Ask user if they want to proceed to implementation]

GREEN Phase - Implementation
[Write minimal code to pass tests]

REFACTOR Phase - Improve Code
[Refactor while maintaining test coverage]

Example Response Structure

When a user requests a feature:
1. "Let me understand the requirements..."
2. "I'll write tests for these scenarios..."
3. "Here are the failing tests..."
4. "Should I proceed with the implementation?" (WAIT FOR CONFIRMATION)
"Here's the minimal implementation..."
"Let me refactor and improve the code..."

Chat output:
[illegible] architectural challenges might [illegible]

Quality Over Quantity: Research [illegible] stronger indicator of productivity [illegible] Happy developers write better [illegible]

Balanced Approach: The most [illegible] GitHub metrics with qualitative [illegible]
• Code quality and impact
• Mentoring and knowledge [illegible]
• Process improvements
• Team collaboration effectiveness

Best Practices for Implementation
1. Focus on Trends: Look at [illegible]
2. Team Context: Consider [illegible] phase
3. Multiple Perspectives: [illegible]
4. Actionable Insights: Ensure [illegible] measurement
5. Avoid Gaming: Be aware that [illegible] to counterproductive behaviors

Would you like me to help implement [illegible] your current Next.js application? [illegible] set up in your components.

Interface text:
Add Context...
TDD.chatmode.md
Edit files in your workspace in agent mode
AIE
Microsoft
smol ai

### Reusable planning prompt

A planning prompt directs the assistant to explore the codebase, ask clarifying questions, and record findings without implementing changes. Kirschner describes prompts as reusable team tasks across iterations.

[13:22](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=802s) [VS Code displays a planning prompt for exploring a codebase and recording findings.](https://assets.ai.engineer/sites/aiecode2025/sha256/5c029d8debab2e6c63127e94480fef14b9f3311bf585c3794db53e5fa19018e9.webp)

---
mode: "agent"
tools: ['Perplexity']
---

Based on a given problem, we're both collaborating to explore solutions based on a given code base.

Iterate with clarifying questions and codesearch/web-fetching tools to explore the solution space for the given problem with me. Don't implement anything!

The first step is always iterating over the codebase until you understand the problem and the context. Then we can brainstorm potential solutions together while pulling more relevant information from the codebase as needed. Pause often to ask clarifying questions.

To work around your short memory, you keep track of any findings or important information in a markdown document (use `spec.md` if I didn't reference an existing document). You can refer to this document at any time to recall important details.

Interface text:
EXPLORER
FRONTEND-VIBES
.devcontainer
devcontainer.json
.github
chatmodes
TDD.chatmode.md
instructions
frontend.instructions.md
prompts
plan.prompt.md
spec.prompt.md
copilot-instructions.md
.vscode
mcp.json
tasks.json
src
app
favicon.ico
global-error.tsx
globals.css
layout.tsx
page.tsx
components
dashboard
layout
header.tsx
ui
alert.tsx
avatar.tsx
badge.tsx

Tabs: spec.md; spec.prompt.md; TDD.chatmode.md; plan.prompt.md
Configure Tools...

CHAT
Context Matters: GitHub metrics provide only partial insights. Different project phases naturally produce varying activity patterns. A developer solving complex architectural challenges might commit less frequently but provide more value.

Quality Over Quantity: Research shows that developer satisfaction is actually a stronger indicator of productivity than raw commit counts or deployment metrics. Happy developers write better code and solve harder problems.

Balanced Approach: The most effective productivity measurement combines GitHub metrics with qualitative factors like:
- Code quality and impact
- Mentoring and knowledge sharing
- Process improvements
- Team collaboration effectiveness

Best Practices for Implementation
1. Focus on Trends: Look at patterns over time rather than absolute numbers
2. Team Context: Consider team size, project complexity, and development phase
3. Multiple Perspectives: Combine quantitative metrics with developer feedback
4. Actionable Insights: Ensure metrics lead to improvements, not just measurement
5. Avoid Gaming: Be aware that focusing too heavily on specific metrics can lead to counterproductive behaviors

Would you like me to help implement any specific GitHub productivity metrics in your current Next.js application? I can see you have a dashboard structure already set up in your components.

Add Context...  plan.prompt.md
Edit files in your workspace in agent mode
Agent  Claude Sonnet 4 (Preview)
Ln 3, Col 22  Spaces: 4  Prompt
AIE
Microsoft
smol ai

### TypeScript instructions

A frontend instruction file targets TypeScript files and sets conventions for interfaces, unions, components, and type definitions. Kirschner describes instruction files as guidance for specific parts of a codebase.

[13:38](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=818s) [VS Code displays TypeScript instructions covering interfaces, union types, components, and type definitions.](https://assets.ai.engineer/sites/aiecode2025/sha256/b00e33ecbcd8e8a65eb43287eb81bd4cb3dff432927411c39e1a3d52f618b804.webp)

---
applyTo: "**/*.{tsx,ts}"
---

TypeScript Usage

- Use TypeScript for all code; prefer interfaces over types.
- Avoid enums; use maps or union types instead.
- Use functional components with TypeScript interfaces.
- Include proper type definitions for all props and state.

Interface text:
EXPLORER
FRONTEND-VIBES
.devcontainer
  devcontainer.json
.github
  chatmodes
    TDD.chatmode.md
  instructions
    frontend.instructions.md
  prompts
    plan.prompt.md
    spec.prompt.md
  copilot-instructions.md
.vscode
  mcp.json
  tasks.json
src
  app
    favicon.ico
    global-error.tsx
    globals.css
    layout.tsx
    page.tsx
  components
    dashboard
    layout
      header.tsx
    ui
      alert.tsx
      avatar.tsx
      badge.tsx

CHAT

Context Matters: GitHub metrics provide only partial insights. Different project phases naturally produce varying activity patterns. A developer solving complex architectural challenges might commit less frequently but provide more value.

Quality Over Quantity: Research shows that developer satisfaction is actually a stronger indicator of productivity than raw commit counts or deployment metrics. Happy developers write better code and solve harder problems.

Balanced Approach: The most effective productivity measurement combines GitHub metrics with qualitative factors like:
- Code quality and impact
- Mentoring and knowledge sharing
- Process improvements
- Team collaboration effectiveness

Best Practices for Implementation
1. Focus on Trends: Look at patterns over time rather than absolute numbers
2. Team Context: Consider team size, project complexity, and development phase
3. Multiple Perspectives: Combine quantitative metrics with developer feedback
4. Actionable Insights: Ensure metrics lead to improvements, not just measurement
5. Avoid Gaming: Be aware that focusing too heavily on specific metrics can lead to counterproductive behaviors

Would you like me to help implement any specific GitHub productivity metrics in your current Next.js application? I can see you have a dashboard structure already set up in your components.

Add Context... frontend.instructions.md
Edit files in your workspace in agent mode
Agent
Claude Sonnet 4 (Preview)

AIE
Microsoft
smol ai

### Tips for better Spec-Driven Vibing

Add instructions for recurring errors, commit working code before each new task, and pause to inspect and correct agent drift.

[14:46](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=886s) [Slide recommends refining instructions, committing checkpoints often, and pausing the agent to inspect.](https://assets.ai.engineer/sites/aiecode2025/sha256/b9df579cd57c5eb7ead0b73810e1f0cfba919648c1d7d620b7e65b4b7b60e90b.webp)

Tips for better Spec-Driven Vibing

Refine instructions when AI slips
Start lean; add rules only for errors you keep seeing.

Commit checkpoints often
Snapshot working code before every new task.

Pause the agent to inspect
Stop the agent when it drifts; undo or course-correct.

Interface text:
AIE
Microsoft
smol ai

## Full transcript

[0:00](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=0s) [upbeat music] Uh, gonna dive right in, no introductions.

[0:17](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=17s) Um, if you wanna follow along, get out your VS Code. Uh, some of the things I'm showing are VS Code Insiders. Who's an Insiders user? Anybody? Oh, I gotta explain that.

[0:26](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=26s) So Insiders is our pre-release that's built basically by whatever the build- the team landed the day before. It's gonna release actually twice a day, um, and it has all the latest things we're working on.

[0:39](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=39s) Uh, VS Code otherwise releases on a monthly basis. The next release is coming up next week on the 11th. So,

[0:46](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=46s) uh, who has done vibe coding? Anybody? Some, some. Who has negative feelings about vibe coding?

[0:57](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=57s) Okay, some. Uh, so yeah, it's, it's... We wanna fully give into the vibes in this presentation. Uh, it's gonna be a lot of screenshot-able slides to bring home to your team, so get your phones out now.

[1:08](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=68s) We're gonna embrace exponentials and forget that code even exists, how Andrej Karpathy created that vibe coding idea.

[1:16](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=76s) So vibe coding in itself and why it, well, it has these negative connotations. It starts in this fun chaos mode. I think it's part of the journey, what I'm presenting, looking at the clock and 13 minutes and 40 seconds, is how we get to this other side of professional zen vibes.

[1:33](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=93s) And to break it down a bit, this initial vibe coding, what you see most people do on YouTube when they sh- work on websites and ship them to production and then wonder why everything is slowly falling apart and their, their bills go up, that's the YOLO vibe coding and not meant to ship to production.

[1:52](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=112s) It's about speed and simplification. There's creativity in there. And it's really about this fast learning. Hopefully, I can highlight that.

[2:01](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=121s) Then next, uh, and these are all made-up terms. This is a [laughs] ever-evolving space. You can find-- If you have better words, please bring them to me. But structured vibes br- brings guardrails to how these things actually act.

[2:13](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=133s) And if you have an LM in this first space, it will just do creative things. Guardrails add it to, uh, br- en- enter this state of maintainability and balance it to bring you some more sustainable code in the end.

[2:26](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=146s) YOLO vibes are not meant to be used in a long term. Structured vibes are what, where you bring actually the, the enterprise state in, in the end that somebody, you feel comfortable handing it over.

[2:38](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=158s) And lastly, we have the spec-driven vibes, where I think most of you probably wanna end up with. And that's where vibes, the idea of vibe coding, scales up to large code bases with scale and reliability and really that, that velocity of everybody feeling the vibes and generating code, but in a-- generating code in a way that, that

[2:57](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=177s) fits into the code base. So quick YOLO, uh, outline. Um, as Karpathy termed it, it's all about the outcomes. You don't look at code. You iterate using language. Best even talk to the AI.

[3:12](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=192s) Then auto-accepting is really part of it. You don't wanna-- You talk to the AI, you look at what it creates, and all the rest just lands. Um, if it ever goes wrong, you just reset everything completely.

[3:23](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=203s) You throw out the code or you undo, and you keep going. And there is a place for YOLO vibe coding. It's not just weird weekend things. It's rapid prototyping and proof of concept.

[3:34](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=214s) You just wanna explore. It's where creativity really shines, and you can focus on the outcome, and that's, that's a thing where vibe coding really shines. And while you do it, you can learn.

[3:44](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=224s) You can try something in a Rust code base. Make a Rust game. Make a Rust Frogger. Try a different stack. Make a neon flickering Rust Frogger. Just-- And then look at the code in the end, like how do games work actually in Rust?

[3:59](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=239s) Have AI explain the code back to you. And lastly, personal projects is, uh, where we see it most. Just over the weekend, my kids needed an app to do X, and we build it together, and now we have an app to do X.

[4:11](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=251s) And I'm not shipping it to production, but it's my app.

[4:16](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=256s) So we can do some demos. I think the easiest way to show it off, um, just open a new VS Code window. This is my Insiders. Uh, if you haven't done it-- Oh, I have an update pending.

[4:24](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=264s) Oh, this is Insiders, so it's every day something new. I'm excited. But not updating now. Okay, um, in--

[4:31](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=271s) So make sure you're in agent mode, which right now isn't yet the default. We're working on that. Uh- We don't see it. Oh, shoot. Dun, dun, dun. Same problem, I guess.

[4:43](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=283s) Auto sharing to... Don't monitor. Change. W- Entire screen.

[4:55](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=295s) Ta-da. Okay. Thank you. Um, yeah. So let's start with the don't care about the code, and one way to do this is Auto Approve. If you look at chat Auto Approve, it's a, with caveats, cool option.

[5:10](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=310s) Um, and you can enable it also for, for example, your workspace only. Uh, but Auto Approve allows you to avoid all these confirmation buttons that the chat otherwise annoyingly throws at you while you're trying to vibe.

[5:23](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=323s) So while we're here, let's start this. Um, you see this little microphone button down here, and that is built in to VS Code. It's actually a local model. Nothing leaves your machine, and it's really, uh, it's, it's a great way to just chat with the AI.

[5:38](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=338s) I-- You can actually set it back that it responds everything back to you. Let's try the, uh, let's make our first app and then go back to the slides 'cause we wanna just make Copilot vibe what we ask for.

[5:50](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=350s) So, um, actually, the shortcut is, for me, is Command+I. Like that one.

[5:56](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=356s) Let's make an app for, uh, water hydration tracking in React and Vite. It should use Material UI and follow nice Apple-esque design principles. So yeah. Thank you.

[6:10](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=370s) Okay, and off it goes. So what, what you see now first is actually we have a create new workspace tool which lets you vibe code, um, a little bit easier.

[6:20](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=380s) It's... Let's do my-

[6:22](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=382s) Is this, uh, just Copilot or is this something else?

[6:25](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=385s) Just Copilot.

[6:26](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=386s) Okay.

[6:26](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=386s) Yeah, the Copilot agent mode. It comes with, with that tool. So demo one two, whatever. [laughs] It's vibe coding, so we don't care about the code,

[6:36](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=396s) but it has to be somewhere. Okay. Um, now because we have the repo, or workspace, it will just continue. And now it will actually just see how it starts it off.

[6:47](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=407s) Create a React workspace, water hydration tracking app, Material UI, Apple-esque design. It made a plan in the background, and now it shares the high-level plan with us, and it goes off.

[6:57](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=417s) So we can go back to the slides and not care about the code.

[7:02](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=422s) Uh, npm install, npm dev. So I trust it. It will do stuff. [laughs]

[7:06](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=426s) And the model used is the one that was at the bottom?

[7:09](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=429s) Yes. Yeah. So this is using Claude Sonnet 4, which I, I found really good at, um, UI. I, I actually ran the same demo with different models. 4.1 makes it look very wireframey.

[7:18](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=438s) Uh, 2.5 Pro has a interesting design sense where it always looks somewhat different. And Claude Sonnet makes it always look like a blockchain landing page, uh, if you make it wrong. [laughs]

[7:29](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=449s) So, so lots of gradients and dark and big letters.

[7:34](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=454s) So to kind of as we... Seven minutes. So we have, uh, YOLO Toolbox is agent mode. Um, there's a new workspace flow that's really interesting, so if you wa- haven't tried it out yet.

[7:43](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=463s) Um, it can also trip you off if you ask for something, a new app in an existing project. Make sure sh- make sure you... if you hit that. Voice dictation built in.

[7:51](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=471s) Visual context I might get to showing around. So once it actually, it starts finishing, it will open up the page in browser preview in VS Code, and I can actually select specific elements.

[8:01](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=481s) And then the auto-accept, uh, option, there's another auto-accept after delay if you don't have that on in VS Code. There's an auto-save that I really like to drive any live updates in the background that are running.

[8:12](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=492s) And the undo and revert I quickly show up here. If anything goes wrong, there's always these buttons up here for undo and going back. So see where it is.

[8:22](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=502s) Still installing. Our beautiful Wi-Fi making demos easier. Um-

[8:29](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=509s) It's working. With this approach, so how do you get console errors and things like that? Are you able to-

[8:34](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=514s) Yes. Actually, when it-

[8:35](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=515s) Yeah

[8:35](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=515s) ... when this is runs, and it runs in the terminal commands, and the terminal commands fail, it will actually look at the output.

[8:40](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=520s) Okay.

[8:40](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=520s) So if there's any, any dependencies missing, it will go off and install them. It's still like shadcn had some changes in how you install it, for example. It will figure out because the error message is, "Use this package instead," and the next command will use it right.

[8:52](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=532s) Yeah, but for example, there are console errors that do not show up in the terminal.

[8:56](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=536s) Terminal. Sometimes it run things in the background terminal, but there's on- ongoing fixes to make it basically always find it. Okay, let's keep going. Um,

[9:05](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=545s) next one, while runs. Um, it's use vibe co- use a little vibe code. So I really tried out, uh, embrace the exponentials to build that AI intuition. Like what is AI good at?

[9:17](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=557s) What AI can't do yet? And find that for yourself, just baseline what AI can do. And that's where YOLO vibe coding with like a very open canvas and being able to steer AI is this extremely powerful skill to inform all of other AI usage.

[9:33](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=573s) Then the second one is use known frameworks. I picked React and Vite in my demo because it gives a nice grounding, and it's something that hasn't changed in a while.

[9:40](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=580s) So that's a good way. If you use any, any new ones, you wanna be more explicit about how to read the docs and where to find information. And lastly, it's all about it- iteration.

[9:50](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=590s) So it's a whiteboard. You wanna, uh, wipe things off completely. You wanna start from scratch. You wanna work on specific items. But really about like having this, this iterative workflow outlined.

[10:01](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=601s) Quick check-in. Still working on some files. Okay, we keep going. So structured vibe coding, and that's where we bring in a template, and that template comes with a consistent tech stack, and that could be your internal stack.

[10:14](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=614s) It could be a container that you give to developers. So if, if you wanna work on UX, um, bring this template in, and you can just start vibing. That could be even for non-technical people.

[10:24](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=624s) Just check out this repo or work from this template on GitHub, open in VS Code, engage agent mode and voice mode, and start vibing. But because it's a template, it comes with this consistent tech stack, and it comes with instructions to guide, uh, the Copilot flow onto specific conventions that you're already running with.

[10:46](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=646s) And then lastly, we want, like, custom tools using MCP and other things to make sure, like, if it needs information or needs more context, that it can get that. And that's really more high-- more reliable and more consistent than Yolo mode.

[10:58](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=658s) If you ask YOLO mode, and if it wouldn't have given it Material UI, it might have picked any other design framework. It might have went with Tailwind. So and that allows you to internally we use Fluent UI.

[11:08](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=668s) So you're gonna use Fluent UI. This is where you get the package, and just it, it's outlined, and it's clear. And so it's really great for bootstrapping these greenfield projects because you end up with something people can hand over to engineering, and engineering doesn't say like, "This is totally not what we're doing."

[11:23](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=683s) Um, and this thing also, it's, it's better at the off mainstream, like anything that's non- not popular, like Spring Boot, whatever latest version you have that the AI struggles with.

[11:32](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=692s) You can add more instructions on top that it gets it right more often.

[11:38](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=698s) Gonna show a quick how does it look like. Still vibing.

[11:44](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=704s) Yeah, I think it's mostly internet speed here making it slow. So let's figure out, um... This is a nice repo. It's actually on the, on the internet. Um, if you go to [REDACTED:url],

[11:58](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=718s) and then I put it up. I think it's still on there.

[12:02](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=722s) Frontend Vibes Template. So let's zoom in if you want to take a screenshot for later.

[12:07](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=727s) I-- Well, now you know this is-

[12:08](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=728s) Again?

[12:09](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=729s) Yeah

[12:11](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=731s) How's this screen sharing working? I don't know. I'm not technical. Um, is this entire screen, right? So- It says you're on Desktop 2. Okay. Yeah, I think e- each time I switch back to PowerPoint, it, it tries to do the mode screen again.

[12:25](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=745s) Okay. So, uh- Where's the GitHub again? GitHub again.

[12:33](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=753s) Sharing the vibes here. Two minutes. Okay. We got it good. Um, yeah, so that's the nice template. Just gonna do a quick roundup. So one, we have chat modes.

[12:41](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=761s) That's what I'm highlighted here on the left, .github/chatmodes, and you can define already tools. You define what, what tools are in the mode, and what's the system prompt, and then they show up down here.

[12:53](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=773s) Actually, you can switch out agent. It's a new agent that's now doing test-driven development for you. And that description here I wrote in another demo [laughs] earlier about how to do test-driven development.

[13:04](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=784s) I didn't know there's a red, green, and, and, uh, refactor or anything else. So that's up to you how you define that mode. But this basically now guides it. You have to write tests first, and then you write code, and then it has to pass.

[13:16](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=796s) And only as- only move to writing code after I confirm, because I wanna review the test, and that's much easier for review to me. Um, you can also create prompts, and that's a way for your team to create these reusable tasks that are then used across different iterations.

[13:29](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=809s) It could be a new landing page for your design team. Like, we need a new micro-landing page. This is how you structure it, and then they can just, just create it.

[13:37](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=817s) And lastly, instructions. Those are new. Those are in .github/instructions, and those can outline what specific parts of the code base do.

[13:46](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=826s) So to go back to the slides. Yeah. The, the thing again. So you wanna bring in workspace instructions. There's a good document on VS Code documentation on customization. If you wanna go deeper, there's, um, the instructions files I showed and prompts.

[14:02](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=842s) You wanna make them dynamic for specific parts of the code base, and you wanna start bringing MCP. Couldn't show off MCP right now because we've run out of time.

[14:09](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=849s) Um, check out my MCP talk from the MCP track if you wanna see some of those demos. Um, also VS Code has access to problems and tasks, so if you have your task runner set up in VS Code and your linters properly, it will actually start fixing code as it makes mistakes, which is a really powerful context

[14:27](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=867s) to have for the AI. And lastly, if you haven't found that little spark like in any commit, it's really important once you start working and having workable code to keep committing the, that workable code so you don't get into weird areas where it worked before and now my vibe coding broke it, and that's always sad.

[14:45](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=885s) So review's important. Um, always says on these, instructions are important. Start with errors. Committing is important, so commit often. Pause the agent to inspect.

[14:57](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=897s) Lastly, in ten seconds, spec-driven really brings this often repeated idea, which you'll see here as well. You start with a spec, you make a plan, and then you implement the plan.

[15:07](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=907s) And that really brings it up to the large scale. And the features we have here I showed off, prompts, more MCPs, and more task-specific tools that you can bring in.

[15:17](https://www.youtube.com/watch?v=i1uPAN6uW4s&t=917s) And we're out. Happy to chat more outside. [outro music]
