AI Engineer World's Fair 2025

Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments

Loading slides…

Read the talk

Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments

A hydration tracker, a mock GitHub dashboard and a broken TDD mode show how instructions, tools and specifications turn open-ended generation into a repeatable development process.

From a talk by Harald Kirschner

Before you start: Basic familiarity with VS Code, a JavaScript project and Git will help you follow the demonstrations; MCP and the customization mechanisms are explained as they appear.

What happens when you stop looking at the code?

If an engineer works entirely through chat and judges only the resulting application, what replaces reviewing the code? Harald Kirschner opens with that tension: give the model a desired outcome, let it generate the implementation and keep directing it in natural language. The attraction is immediate feedback; the difficult part is deciding where trust should end and guardrails should begin.

Slide showing an Andrej Karpathy post behind the enlarged quote: “Fully give in to the vibes, Embrace exponentials, And forget that the code even exists.”Open full source frame
Vibe coding: give in to the vibes and forget that the code exists.

Kirschner points to an Anthropic conference chart showing agents running longer and generating more code. His concern is the review burden that follows. A prototype can go online quickly, then leak information or otherwise become a problem once people depend on it. He organizes the path from that initial excitement toward dependable work into three stages.

StageMain purposeAdded discipline
YOLO vibesCreativity, speed, learningExplore the output
Structured vibesSustainable development and handoverReadability and quality control
Spec-driven vibesScale, reliability and velocityExplicit requirements and repeatable practices

The first stage is useful precisely because it makes experimentation cheap. It is not yet a process for shipping products. The later stages retain that freedom while making the result easier for another person—or another agent session—to understand and extend.

In the exploratory loop, the user watches the application, accepts changes and tells the assistant to try again when something looks wrong. Kirschner jokes about the popular prompt “Fix it or go to jail,” but the practical use cases are less theatrical: a proof of concept, a UX mockup that makes an idea concrete in a meeting, or a working example from which to learn a framework. During a live Build exercise, he used Three.js after a long absence; once the generated application ran, he could investigate how it made shapes and organized the code. Water trackers and projects built with children belong in this same category: useful experiments whose scope makes starting over acceptable.

0:250:43
Suggest correction

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

0:25 · section reference included

Start the hydration tracker from an empty window

The first exercise begins with an empty VS Code window: Command+Shift+N, no project folder and Copilot beside the editor. Kirschner uses Insiders, the daily development build, and selects Claude Sonnet 4, his personal preference for frontend work. The essential setup step is switching the chat from Ask to Agent, which exposes the tools picker.

VS Code shows no folder open in the Explorer, an empty editor, and the Edit with Copilot panel with Agent and Claude Sonnet 4 selected.Open full source frame
An empty VS Code workspace with Copilot ready in Agent mode.

He initially tries to disable the New Workspace scaffolding tool. For a small HTML experiment, a scaffold can introduce more structure than the task needs. Participants see different controls, however, so the exercise proceeds with New enabled. The workshop therefore follows the interface available in that recording; several controls shown later were still arriving in Insiders, despite the initial expectation that Stable would suffice.

The request deliberately leaves room for interpretation: build a water-consumption tracker with React and Vite, a large accessible interface, an Apple-inspired visual direction and Material UI. Popular frameworks reduce the number of unfamiliar decisions the model must make. There is no button inventory, mobile layout specification or detailed CSS prescription. The user supplies a recognizable stack and an aesthetic direction, then lets the assistant fill in the rest.

From the folderless window, the New flow proceeds through a short setup sequence:

  1. Ask the user to open an empty folder.
  2. Create and open the selected project directory.
  3. Continue scaffolding inside that workspace.

This flow is optimized for greenfield requests such as a water tracker or movie database. It handles the otherwise distracting first decisions about project setup before the user has anything to inspect.

5:235:39
Suggest correction

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

5:23 · section reference included

Approval settings change the execution loop

Once scaffolding starts, command confirmations interrupt the hands-off flow. Kirschner searches Settings for Approve and enables auto-approval under Workspace, rather than User, to limit its scope to this project. He explicitly cautions about using it: removing the Continue prompts means allowing the assistant to execute actions without stopping for each confirmation. The visible plan includes installing Material UI, creating the tracker and building the project structure.

The setting does not immediately behave the same way for everyone. Participants encounter different Settings entry points, uncertain feature availability and continuing prompts. Kirschner distinguishes the broad setting from MCP permissions that can allow an individual call, a session or a workspace. He attributes the remaining prompts in the active chat to having enabled auto-approval too late in that session.

He then opens a second window, ensures approval is configured before the new run and asks for another hydration tracker using Microsoft's Fluent design system. This generation proceeds without confirmations. It also chooses an incorrect Fluent dependency and attempts to repair it. Running the two windows together makes another practical issue visible: the operator must still track which process belongs to which project. The payoff is design exploration—much like asking for several alternative sign-up flows before committing to one.

The reliable route into Settings during the exercise is Command+,. But finding the switch is not the main safety question. An audience member asks for a middle ground between approving every command and approving everything. Kirschner explains why a terminal allowlist is harder than matching a command name: shell commands can be chained, and one apparent command can contain several operations. Finer approval controls were work in progress; workspace scope narrows where a permissive setting applies, but does not make its commands harmless.

11:1711:31
Suggest correction

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

11:17 · section reference included

The scaffold exposes its assumptions

The generated project contains App.tsx, App.css and Copilot instructions. Those instructions record more than the user explicitly requested: the stack, a clean and consistent interface, CSS choices and responsive behavior. Scaffolding has converted a loose design request into a set of continuing assumptions. Kirschner did not separately ask for the instructions file; it appeared as part of project creation.

The first application presents today's hydration progress, quick-add actions and plus/minus controls. Participants report different-looking results from their own runs. Kirschner uses that variation to explore a model's design sense, particularly its choices of icons and colors. His evaluation so far is entirely visual: he has not inspected the CSS, TSX or state-management implementation. A convincing interface is the result of this phase, while implementation quality remains a separate question.

VS Code browser preview shows Today's Progress at 1750ml of a 2000ml goal, an 88% progress bar, and Quick Add buttons beside Copilot's response.Open full source frame
The generated hydration app displays progress and quick-add controls.
19:4420:01
Suggest correction

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

19:44 · section reference included

Point at the interface, then keep or undo the change

The next request targets the progress header: add animation and perhaps particles. Rather than identify the component by name, Kirschner selects the rendered element. The agent has started the development server with npm run dev and opened VS Code's Simple Browser. Its element picker can attach a visual reference together with CSS and HTML information to chat. In this run, the element screenshot fails to arrive, but the CSS/HTML description does arrive, including the mui-paper element context. The selection replaces a laborious description of where the desired change belongs.

While that edit runs, the Fluent variant is ready. It independently includes a goal-reached state and recent entries, making similar functional assumptions to the Material version, but with a plainer appearance that Kirschner describes as more corporate. For smaller visual experiments, he returns to the earlier tooling distinction: disabling New allows a simpler single-file HTML approach, whereas New tends toward npm packages and a fuller project scaffold.

An audience question about tracking new features prompts Kirschner to identify his work on VS Code and point to release notes. Monthly releases collect changes; daily Insiders builds are harder to follow. A daily MCP-powered change summarizer is suggested, not built. He then rearranges the workspace: named chats can become editor tabs, sit beside code or detach into their own windows. A detached chat can occupy a second monitor and stay on top, leaving the application preview as the main working surface.

Voice input supplies the next change request: add dark mode and make the hydration app more appealing to children. Kirschner demonstrates Command+I and describes the transcription model as local, with optional read-back for accessibility. A hold-to-talk shortcut can also be configured; he recalls a Hey Copilot feature without demonstrating it. Together with wireframe attachments, element selection and hot reload, these controls let the user express changes through the medium most convenient for the task.

ControlWhat it changes
Tool auto-approvalWhether execution waits for permission
Delayed edit acceptanceWhether proposed edits are accepted automatically
AutosaveWhen editor changes are saved
Checkpoints and undoWhich generated editing stage is retained

These are separate decisions. The particle edit eventually produces animated bubbles; Kirschner accepts it, demonstrates undo and restoration, then returns to the original version. Per-stage checkpoints make this visual comparison reversible even after accepting edits.

This completes the exploratory loop: give broad tasks, learn where the model succeeds or struggles, and use familiar frameworks whose conventions are well established. Treat the prototype like a whiteboard. If an experiment goes wrong, throwing it away may be more useful than becoming attached to its implementation.

22:3522:46
Suggest correction

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

22:35 · section reference included

Make the starting point carry the team's knowledge

Structured vibe coding starts before the first feature request. A starter template supplies a consistent stack, instructions for working in it and custom tools that expose domain knowledge. The user no longer has to remember to request Fluent rather than Material, dark mode or responsive behavior. Those expectations already belong to the project.

This is particularly useful when nontechnical colleagues build greenfield prototypes. An internal design system makes the result recognizable and polished enough to communicate in a meeting. The same approach can steer the assistant toward less common internal frameworks, workloads and deployment infrastructure, countering its tendency to choose the most familiar public patterns.

Structured Vibe Coding slide lists a consistent tech stack, conventions and guardrails, custom tools, and use cases including greenfield projects and out-of-the-mainstream workloads.Open full source frame
Structured vibe coding combines starter templates, instructions, and custom tools.

To demonstrate that starting point, Kirschner commits a prepared project, lets Copilot generate the commit message and syncs it to GitHub. The repository is shown as Sleep vibes. Participants clone it and install dependencies; Simple Browser: Show opens the embedded preview. Once inside the cloned directory, the demonstrated setup command is:

sh

npm install

The setup itself becomes part of the lesson: a shared template should make reaching the first working screen straightforward.

Kirschner initially says the repository lacks a dev container and suggests Codespaces as a better one-click experience. Participants then find a .devcontainer configuration, and he remembers asking Copilot to inspect the codebase and update its Node.js container. The correction matters: a prepared environment is useful only if the person sharing it knows what is present and how to run it. An audience member's frustration with differences between Stable, Insiders and extensions reinforces that environment friction can send users back to another tool.

32:1332:32
Suggest correction

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

32:13 · section reference included

Separate project guidance from reusable tasks

The template's foundation is .github/copilot-instructions.md, which Kirschner describes as included with agent, chat and inline-chat requests. His preferred starting point is concise: identify the stack, frameworks and versions. That is more valuable than filling the file with formatting rules the existing tooling already expresses. Keep the document in the repository and refine it as a team rather than treating it as a fixed policy written once. Personal instructions can live in user settings; shared repositories and organization-level discovery are discussed as ways to improve distribution, with the latter still a desired capability in this conversation.

Instructions can also guide tool choice. Kirschner directs frontend QA toward Playwright MCP, research toward Perplexity and library documentation toward Context7. For Context7, he supplies known library IDs so the assistant need not repeatedly resolve them. This is useful operational knowledge: not just which tools exist, but when to use them and which preparatory calls can be skipped.

As the global file grows, targeted rules can move into .github/instructions/name.instructions.md. Front matter supplies a glob describing the files to which the guidance applies. For example, a small rule for the TypeScript frontend could be written as:

markdown

---
applyTo: "**/*.tsx"
---
Use the project's existing UI components and design conventions.
Keep new interface elements consistent with the surrounding application.

In the version demonstrated, a matching file had to be in the model's context for the rule to activate. Merely having TypeScript files somewhere in the repository was insufficient; even an open file needed its context enabled. Kirschner identifies this as an active area of improvement.

Reusable prompts solve a different problem. A team member might perfect a test-writing prompt, share it in Slack and leave everyone repeatedly searching for it. Storing it as a prompt makes it available through slash invocation, alongside personal and workspace prompts such as plan and spec. Instructions can also be attached manually. The new configuration entry point shown in Insiders makes these assets easier to create and discover; a prompt-sharing website remains a suggestion. Kirschner also keeps a personal prompt that bootstraps instructions for a new project.

MechanismPrimary questionHow it participates
InstructionsHow should this code be written?Applicable guidance combines
Reusable promptWhat task should be performed?Task text enters the conversation

A TypeScript rule and a frontend-folder rule can both apply to the same work, so their authors must avoid contradictory guidance. A prompt instead initiates a task and remains part of the conversation. This distinction keeps a project's standing conventions separate from the action the user wants now.

39:1639:39
Suggest correction

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

39:16 · section reference included

Encode a development sequence in a custom mode

An audience member asks where an always-follow-TDD policy belongs. Kirschner creates a custom mode, an Insiders feature at the time. The demonstrated repository location is .github/chatmodes; user storage offers a place to experiment privately before sharing a mode with the team. He names the new mode TDD and asks the assistant to generate its workflow.

The requested behavior has an explicit boundary between test creation and implementation. A compact Markdown body capturing that sequence is:

markdown

Understand the requested behavior before changing code.

1. Write tests for the requested behavior.
2. Run the tests and inspect the failures.
3. Ask the user for confirmation before implementing.
4. Implement the behavior and rerun the tests.
5. Refactor while keeping the tests passing.

Do not write implementation code before writing the tests.

The generated mode includes the familiar red, green and refactor phases. It also invents unnecessary framework details, which Kirschner says can be removed. Generating the workflow is convenient, but its configuration still needs inspection.

He starts the plain landing-page project with npm run dev and requests a GitHub issues dashboard with contribution metrics. The data should be mocked; no live GitHub integration is wanted. Selecting TDD changes the agent's working instructions, and the mode can also specify its available tools. Kirschner forecasts a Stable release the following week on the 11th. The published VS Code 1.101 release subsequently arrived on June 12, 2025; the recording's prediction is not its release date.

While the dashboard request runs, a deployment question reveals another context boundary. An audience member has an error in terminal output while the assistant appears finished and wants the agent to notice it without copy-and-paste. Kirschner's first answer is to let Copilot run the deployment command itself, so it receives the output. For commands run separately, terminal-last-command context includes the command's output, while terminal-selection context supplies selected text. These are ways to provide evidence of failure, rather than a demonstrated continuously watching terminal mode.

46:2046:30
Suggest correction

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

46:20 · section reference included

A workflow prompt cannot supply missing capabilities

The first TDD attempt does not edit the project. Its generated configuration named tools that do not exist, leaving the mode without write access. It consequently behaves like ordinary chat and returns code instead of applying changes. Instructions describe intended behavior; the actual tool configuration determines which actions are possible.

Kirschner repairs the configuration and shows how a prompt's tools entry can use the picker to select real tools. For a planning prompt, he selects Perplexity for internet research. Restricting the available tools also addresses the growing clutter caused by adding MCP servers: a tool useful for one activity need not be available for every other activity.

Tool sets package related capabilities and can combine built-in and MCP tools. VS Code already uses grouping internally: editing can expose several editing methods, and codebase search can include grep, file search and other searches. The demonstrated research set combines Perplexity with Fetch. A task can therefore receive a relevant group instead of the entire installed tool inventory.

After the repair, the TDD run creates mock data, tests and a test utility, then attempts to run the tests. A package or library problem appears. Kirschner reports that the tests are red, and the assistant pauses to ask whether it should proceed with the dashboard components—the requested approval boundary is now visible. He approves continuation, but this passage does not establish a completed dashboard with passing tests.

VS Code shows package.json beside a Copilot response listing mock data, validation checks, changed files, and a question asking whether to proceed with GitHub dashboard components.Open full source frame
Copilot pauses to ask whether it should implement the dashboard components.
53:4353:52
Suggest correction

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

53:43 · section reference included

Install MCP capabilities without embedding credentials

Playwright MCP provides the next concrete installation example. It exposes browser automation to the assistant, including page interaction, screenshots and accessibility-oriented page structure. Those snapshots are useful context for inspection; they do not by themselves constitute a comprehensive accessibility audit. Kirschner uses the project's Install Server link, which invokes VS Code through a protocol handler much like installing an extension from the marketplace. The server appears in his user configuration, where its tools, failures and output can be inspected.

His configuration also contains GistPad MCP, using a GitHub token supplied through an input variable rather than written directly into the configuration. Inputs reuse the familiar VS Code configuration pattern of an ID, type, description and optional default. A secret-input declaration has this shape:

json

{
  "inputs": [
    {
      "id": "github-token",
      "type": "promptString",
      "description": "GitHub token for GistPad",
      "password": true
    }
  ]
}

The corresponding server configuration can reference ${input:github-token}. The input system prompts for and securely stores the value; password: true marks it as password input, rather than being a standalone encryption mechanism. Kirschner says VS Code uses its key storage and macOS Keychain on his machine.

GistPad uses GitHub Gists as a place for knowledge and reusable prompts. Kirschner identifies the project with lostintangent and recommends it as an example to explore, alongside the GitHub MCP server. The token-based setup here is the workshop's configuration; the project's current VS Code instructions instead use an extension and sign-in.

57:3757:50
Suggest correction

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

57:37 · section reference included

Connect, discover and invoke an MCP server

An audience member already has a Python MCP server running on an SSE endpoint and wants to connect it. Kirschner opens .vscode/mcp.json, the workspace configuration that can be shared with the team, then uses Add Server → HTTP. The manual equivalent is a named server entry with a URL and HTTP type rather than a local stdio command. Autocomplete points out a missing URL; in the demonstration, supplying the URL also lets the editor infer the connection type.

The transport distinction needs precision. Kirschner describes the older SSE transport as deprecated and discusses the hosting burden of long-lived connections. The MCP transport specification replaces the older HTTP+SSE transport with Streamable HTTP, which can itself still use SSE for streaming. The connection flow supports the newer transport with legacy fallback; SSE has not disappeared from the protocol.

Starting a server verifies that the configuration works and allows the client to discover its tools. VS Code caches that discovered inventory, avoiding the need to start every configured server merely to populate Copilot's tool list. Discovery and execution are therefore separate moments: seeing a tool in the picker does not require eagerly launching all servers whenever chat opens.

Agent mode is the normal execution path in this workshop. Kirschner initially says Ask does not run MCP tools, then qualifies that statement: explicit tool references can invoke tools in Ask. His attempted Ask-mode demonstration does not work during the exchange, so the practical path shown remains Agent mode with the relevant tools enabled.

The model picker introduces a separate choice from server configuration. Built-in models arrive through GitHub Copilot, while Manage models supports personal provider credentials, including Anthropic, Azure, Cerebras, Gemini and Groq. Kirschner shows Gemma 3 through local Ollama and a model labeled Perplexity R1 through OpenRouter, which he describes as a DeepSeek-R1 fine-tune. He is not yet satisfied with the range of useful local models on his M4 Pro.

When an attendee cannot find Claude Opus 4, Kirschner first considers account-tier restrictions, then points to agent-mode filtering for tool-calling capability. Custom-provider support is still a preview in this recording, and providers report those capabilities differently. An incomplete capability mapping can therefore hide a model from the agent picker even when the provider offers it.

1:01:121:01:22
Suggest correction

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

1:01:12 · section reference included

Keep research in a maintained specification

To show what a tool call exposes, Kirschner disables unnecessary tools and invokes the research set for a question about GitHub productivity metrics. The set contains Perplexity and Fetch; tools can also be mentioned individually. The call UI identifies the server and offers a route to its configuration. Although he wonders whether an earlier failure involved an outdated Perplexity key, this run returns research.

The approval state is consequential again. Without auto-approval, the user can inspect and edit outgoing arguments before sending them. Here, auto-approval is still enabled from the earlier experiment, so the request has already gone out. The displayed _ask suffix belongs to the Perplexity tool's name; it does not identify the chat mode.

The research includes a follow-up query. Kirschner then opens an earlier community-dashboard specification built from Perplexity research and shows a prompt that points to the target spec file. Markdown file references are clickable and receive validation feedback. The important instruction is to work on the specification and nothing else: research missing information, preserve details from the conversation and keep the same document updated.

VS Code displays spec.prompt.md with instructions to work only on the spec, use Perplexity for research, and capture conversation details in the spec; the update instruction is highlighted.Open full source frame
The specification prompt explicitly requires keeping the spec updated.

This moves requirements out of a transient chat exchange into a durable artifact. A task prompt can keep the work bounded with a short body such as:

markdown

Work only on the specification. Do not implement the application.

Use Perplexity to research missing information.
Preserve the relevant details discussed in this conversation.
Keep the specification updated as requirements become clearer.

The boundary matters because a capable coding agent otherwise has both the opportunity and the tools to begin implementation before the requirements are settled.

1:07:451:07:55
Suggest correction

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

1:07:45 · section reference included

Tool access still leaves a model decision

A question about model selection leads to MCP sampling. Ordinary tool invocation does not inherently mean that the server uses a language model. Sampling provides a specific reverse path: the server asks the client to use its LLM. Kirschner offers summarization as an example, where a server requests a summary before returning a more compact result. He describes support as available in Insiders with limited adoption, and presents his team's early support as a point of pride.

The next audience question is more fundamental: can tool choice be deterministic? Kirschner recommends reducing a mode or prompt to the tools its task actually needs—for example, allowing only Perplexity for research. Another option is adding a precise tool reference, such as resolve-library-id, instead of hoping the model interprets an ordinary-language description correctly.

The audience presses the distinction between selecting what a developer exposes and determining what an ordinary chatbot user causes to execute. Kirschner concedes the limit: even when a tool is explicitly named, the model might not call it. A constrained tool inventory narrows the available actions; it does not guarantee invocation. No deterministic dispatcher is demonstrated here.

1:11:141:11:19
Suggest correction

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

1:11:14 · section reference included

Make the project observable, then separate decisions from execution

The final development guidance connects the customizations to the repository itself. Give the agent an existing implementation to consult—for example, the Model Context Protocol TypeScript SDK server through cross-repository search. Configure tasks and linting in the template so Problems and task output become available feedback. Pause when work goes off course, answer questions to steer it and selectively trust read-only tools.

As mistakes reveal missing guidance, update the instructions. Commit each working state before inviting more experimentation, and use pause-and-review when the agent's direction becomes unclear. Database, logging and project-tracking MCP integrations can add operational context; properly configured tests let the agent execute tests and debug failures. Model choice remains another adjustable part of the process, with o3 mentioned for deeper reasoning.

For specification work, start with the conversations that already contain the requirements. A project-meeting transcript can supply the raw material, provided the final decisions are explicitly identified. An audience member proposes generating a spec, asking the model to critique it and revising until omissions are resolved. Kirschner recommends a related prompt: ask three questions about the idea. The assistant becomes a thought and design partner that challenges assumptions before producing code; the discussion does not identify an objective tool that certifies a spec as good.

At the time of the recording, Kirschner says VS Code has no built-in planning mode, but custom modes let users define one. Roo's configurable modes and Cline's Plan feature provide adjacent examples. The workflow can use three distinct stages:

  1. Write the specification: settle what the application should do.
  2. Write the implementation plan: decide how the codebase should change.
  3. Implement: carry out the agreed work.

This deliberately spends more effort on the initial decisions before allowing the agent to run.

Not every task needs the same ceremony. Experiment to discover which requests can proceed directly and which benefit from a spec first. Give feedback instead of accepting a poor answer, then encode the process that works for the team in modes, prompts and instructions.

The closing exchange also recognizes a cost to customization: accumulating prompts and modes can begin to resemble Emacs major and minor modes, and Kirschner acknowledges that the experience needs simplification. His final advice returns to the codebase rather than another control panel. Keep code well structured and self-explaining, provide concrete examples in the instructions and update that guidance as the project changes. The assistant's working environment should make the intended solution easier to understand, not require an ever-growing collection of corrections.

Slide lists self-explaining code, planning with codebase context, guidance for existing codebases, concrete examples, and continuously updated instructions and prompts.Open full source frame
Best practices for large codebases: clear structure, planning, examples, and updated instructions.
1:14:361:14:52
Suggest correction

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

1:14:36 · section reference included

Resources

From the talk

Updates since the talk

  • VS Code 1.101 release notesDocumentation

    Historical release notes covering custom chat modes, tool sets and experimental MCP sampling.

Transcript download
Full transcript

Loading transcript…