AI Engineer World's Fair 2025

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

Loading slides…

Read the talk

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.

From a talk by Harald Kirschner

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

From experiments to maintainable code

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, 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.”Open full source frame
Karpathy’s vibe-coding premise: embrace the vibes and forget the code exists.

He introduces three provisional names for progressively more constrained workflows:

WorkflowMain purposeWhat constrains generation
YOLO vibesExplore and learn quicklyThe desired outcome
Structured vibesProduce maintainable work for handoffStack choices and conventions
Spec-driven vibesMake reliable changes in large codebasesA 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.

0:170:26
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:17 · section reference included

Accept, reset, and learn

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.Open full source frame
YOLO vibe coding pairs outcome-first iteration with auto-accept and undo.
3:123:23
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:12 · section reference included

Dictating a hydration tracker

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 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.

4:164:31
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:16 · section reference included

Model choice and the iteration controls

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 talkKirschner’s aesthetic impression
Claude Sonnet 4Good at UI, but can overuse dark backgrounds, gradients, and large lettering
4.1More like a wireframe
2.5 ProA 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.

7:067:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:06 · section reference included

What the agent can see when something fails

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.

8:298:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:29 · section reference included

Put the enterprise defaults in the starting point

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 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.

10:0110:14
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:01 · section reference included

Encode the workflow and its approval boundary

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 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.

12:3312:41
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:33 · section reference included

Preserve working states, then scale the plan

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 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.Open full source frame
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.

13:4614:02
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:46 · section reference included

Resources

From the talk

Updates since the talk

Transcript download
Full transcript

Loading transcript…