Kirschner Wins Microsoft Coding Contest With Multi-Agent Git Fleet
Visual Studio Code
Deploying parallel foundation models across isolated Git worktrees with strict behavioral boundaries outperforms single-agent iteration when rapidly scaffolding complex software.
Four Microsoft engineers demonstrated distinct multi-agent paradigms in a live competition to build a real-time collaborative markdown editor from scratch in under 45 minutes using GPT-5.5, Claude Opus 4.6, and Codex. (2:54)
Harald Kirschner secured the win by using Git worktrees to run parallel background agents across heterogeneous models, synthesizing multiple exploratory prototypes instead of relying on a single iterative run. (32:03)
Unrestricted 'Yolo' agent execution requires secure isolation; the presenters ran their live polling app inside a cloud-hosted GitHub Codespace to prevent local key exfiltration while exposing public ports for audience voting. (5:35)
Prompting strategies diverged between contestants: Julia Kasper successfully one-shotted architecture synthesized from an `idea.md` document, while Harald enforced behavioral constraints via an `AGENTS.md` file to prevent product overengineering. (15:43)
Detailed notes
## Background
Published on YouTube by the Visual Studio Code channel on June 4, 2026, this Microsoft Build 2026 breakout session (BRK201) explores orchestrating fleets of parallel agents across local, background, and cloud surfaces. The presentation covers real-world multi-agent workflows, including decomposing tasks, deciding when to fork versus delegate, and verifying quality when agents outnumber human developers.
## TL;DR
Hosts Burke Holland and Kent C. Dodds orchestrate a fast-paced 'vibe coding' competition challenging four Microsoft engineers—Julia Kasper, Christian Reddington, Pierce Boggan, and Harald Kirschner—to build a collaborative, cloud-based markdown editor from scratch using distinct agentic environments. While the contestants leverage tools ranging from local VS Code agents and terminal CLI orchestration to Git worktrees and multi-model pipelines, the hosts simultaneously build a live, public voting web application from a GitHub Codespace. The contestants navigate rapid feature iteration, agent hallucinations, and model handoffs before presenting their prototypes in rapid 20-second pitches. Ultimately, Harald Kirschner secures the audience vote with a prototype synthesized from background research, parallel worktree agents, and agent-assisted document collaboration.
## Atmosphere & style
The session feels like an energetic, chaotic live tech gameshow blended with an authentic software development masterclass. Kicking off with audience calisthenics and playful banter between Burke and Kent, the mood swings rapidly between lighthearted jokes and high-stakes troubleshooting as timers tick down and live demos teeter on the edge of failure. Watching the hosts stall for time while 'letting agents cook' creates an electric, relatable vibe that captures both the raw unpredictability and astonishing speed of frontier AI-assisted development.
## Bulletin
- [02:54](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=174s) Four Microsoft engineers demonstrated distinct multi-agent paradigms in a live competition to build a real-time collaborative markdown editor from scratch in under 45 minutes using GPT-5.5, Claude Opus 4.6, and Codex.
- [32:03](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1923s) Harald Kirschner secured the win by using Git worktrees to run parallel background agents across heterogeneous models, synthesizing multiple exploratory prototypes instead of relying on a single iterative run.
- [05:35](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=335s) Unrestricted 'Yolo' agent execution requires secure isolation; the presenters ran their live polling app inside a cloud-hosted GitHub Codespace to prevent local key exfiltration while exposing public ports for audience voting.
- [15:43](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=943s) Prompting strategies diverged between contestants: Julia Kasper successfully one-shotted architecture synthesized from an `idea.md` document, while Harald enforced behavioral constraints via an `AGENTS.md` file to prevent product overengineering.
## Key takeaways
- [00:00](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=0s) The engineering bottleneck has shifted from manual code authoring to deciding what to build and orchestrating AI workflows.
- [05:35](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=335s) Uninhibited agent execution ('Yolo' mode) should be sandboxed in environments like GitHub Codespaces to protect local environments from file tampering or credential leakage.
- [10:08](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=608s) In AI-assisted development, planning often happens organically through conversational dialogue rather than rigid upfront specifications, treating the conversation itself as the living spec.
- [10:08](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=608s) Context window priming can be achieved by deliberately asking the agent foundational questions about system primitives before issuing implementation tasks.
- [17:00](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1020s) Multi-model pipelines allow pairing different frontier models according to their strengths, such as utilizing Claude Opus for strategic planning and Codex or GPT-5.5 for tactical execution.
- [29:41](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1781s) Switching models mid-stream can resolve specific development hurdles, such as moving from GPT-5.5 to Claude Opus 4.6 when frontend rendering anomalies emerge.
- [32:03](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1923s) Running agents across concurrent Git worktrees prevents file collisions and allows distinct models to race toward viable architectural solutions simultaneously.
- [32:03](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1923s) Explicit instruction files like `AGENTS.md` are critical for maintaining throwaway, hackable code during prototyping and preventing agents from prematurely building enterprise migrations.
- [34:01](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=2041s) Dedicated design personas and token systems (such as 'Poster Board') allow agents to rapidly generate broad visual variations in parallel before developers narrow down choices.
- [26:50](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1610s) Micro-managing agent prompt syntax or correcting minor typos wastes valuable developer time, as modern frontier LLMs handle messy conversational input and multilingual prompting natively.
- [41:24](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=2484s) Integrating background quality-assurance agents, such as Christian's Playwright test runner, ensures that rapid agent-generated code remains functional and properly styled.
- [41:24](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=2484s) The collaborative editor paradigm is shifting toward delegating markdown manipulation entirely to autonomous agents rather than forcing humans to write raw syntax.
Burke Holland welcomes the audience to the session on multi-agent patterns in Visual Studio Code, framing the event not merely as documentation review, but as a live "vibe coding" competition. Before jumping into any technical architecture, Burke introduces his co-host, Kent C. Dodds. Stating his core belief that increased blood flow sharpens the brain for learning, Kent immediately gets the entire room on its feet for a physical warm-up exercise: twelve synchronized, vocalized deep squats followed by side stretches.
With the audience energized, Burke sets the stage by anchoring the audience in recent AI history. Twelve months earlier, OpenAI had just released GPT-4-class updates, and the previous year’s competition had developers building their own bespoke versions of Frogger from scratch. With today's far more advanced models, the bar has been raised significantly beyond toy games. Turning to Kent, Burke asks him to elaborate on his background. Kent explains his roots in JavaScript and the web, noting that as an educator, his focus has fundamentally pivoted because coding mechanics are no longer the primary bottleneck for developers:
> “These days you don't know, you don't really need to know how to actually do the building part of that as much. And so I'm focused on teaching people how to know what to build.”
[02:54](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=174s) The Challenge and the Four Contestants
After joking about having contestants generate massive games like *Halo* or *Grand Theft Auto*, Burke reveals the real problem statement. Highlighting a real-world developer tweet asking for *"something like Google Docs but for markdown... a cloud based collaborative markdown editor,"* Burke announces that this exact system is today’s contest challenge. Four contestants from across the Microsoft and VS Code organizations are tasked with building this collaborative tool from scratch using completely distinct agentic workflows and interfaces.
```mermaid
flowchart TD
accTitle: Four Contestant Tooling Setups
accDescr: Diagram showing the four contestants and their assigned agent environments.
The four competitors and their assigned agent platforms are:
- **Julia Kasper** (VS Code team): Building directly inside Visual Studio Code using the built-in local VS Code agent.
- **Christian Reddington**: Operating exclusively out of the terminal utilizing the GitHub Copilot CLI.
- **Pierce Boggan** (Product Manager on VS Code): Utilizing the brand-new standalone Copilot app.
- **Harald Kirschner**: Utilizing the dedicated new Agent app.
Every contestant must begin by feeding the exact raw tweet prompt directly into their respective agent environment without manual starter code.
[05:35](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=335s) Sandbox Security and the Live Voting App Plan
While the four contestants begin their race, Burke and Kent set out to build a live, public-facing voting application so the audience can vote on the final markdown editor implementations. To do this, Burke switches his machine to a GitHub Codespace. Burke explains that operating agents at peak speed requires running them in an uninhibited execution mode, which carries inherent organizational risks if run locally.
> “The really the only way to be productive with an agent is to put it into allow all or Yolo mode and just let it do its thing. But a lot of organizations won't let you do that because that's inherently unsafe.”
By deploying inside a cloud-hosted GitHub Codespace, the agent can run safely in unrestricted execution mode without risking local workstation key exfiltration or file tampering. Furthermore, the Codespace can run a local server and expose an encrypted public port, allowing audience members to connect their mobile devices directly into the development environment in real time without intermediate deployments.
[07:15](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=435s) Product Engineering and Technical Architecture Decisions
With thirty-six minutes remaining on the clock, Kent steps into his role as a product engineer to scope the voting app into immediately shippable increments. He outlines the core requirements: a responsive web page, clear identification for the four contestants, a real-time visual tally of votes, and an administrative trigger to lock the poll and declare a winner. Rather than attempting a complex build all at once, Kent advises starting with a barebones home page, securing the public deployment, and generating an on-screen QR code so attendees can access the endpoint early.
Addressing how software methodology shifts in the era of artificial intelligence, Kent contrasts traditional development paradigms with agentic workflows. While agile development starts with a basic skateboard and gradually transforms into a scooter and a car, working with an agent often yields an overly complex "mega car" loaded with unexpected features that the engineer must systematically prune back:
> “With AI, it's like it starts with this mega car with all these different features that you don't want and then you subtly get rid of those things.”
When Burke triggers the Copilot CLI in planning mode, the agent immediately prompts them to select an enterprise-style framework such as Next.js. Kent firmly pushes back on unnecessary framework complexity for a single-page voting screen, recommending they stick strictly to pure vanilla HTML and JavaScript to move quickly, maintain full transparency over real-time events, and eliminate compilation overhead.
[10:08](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=608s) Skipping the Formal Plan: "The Conversation Is the Plan"
Kent C. Dodds and Burke Holland watch as the agent scaffolds the homepage of their project. Because the application is deliberately kept small and lightweight, Kent appreciates that they do not need to deal with a complex build pipeline, tree-shaking, or hot module replacement (HMR). Burke shares a moment of developer nostalgia, admitting that he misses the simpler era when building for the web meant writing raw HTML and JavaScript without heavy tooling layers. Burke notices that Kent seemed to bypass the typical upfront specification phase and asks whether he skipped planning altogether.
Kent explains his development philosophy when collaborating with coding agents: he treats the back-and-forth dialogue itself as the living specification. When expanding an established enterprise codebase with hundreds of thousands or millions of lines of code, Kent starts by querying the agent with foundational questions about system architecture and primitives—even when he already knows the answers—specifically to seed the agent's context window with the correct domain knowledge before issuing any implementation commands. As Kent explains:
> “I actually don't plan like the, the, the, the, the conversation is the plan.”
Burke examines the freshly generated screen and playfully mocks its aesthetic, pointing out the telltale dark mode and neon purple accents that make it immediately obvious an artificial intelligence built it. With their scaffolding underway, they set a three-minute timer to allow the other contestants down on the floor to make progress before they begin snooping on their work.
- The application is intentionally built with vanilla HTML, CSS, and JavaScript to avoid bundlers, compilers, or build overhead.
- Kent’s context-priming technique: query the agent about system primitives and domain architecture to load the context window before asking it to write code.
- The default UI output immediately shows off the stereotypical "AI vibe" with dark purple color themes.
---
[11:57](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=717s) QR Codes, DevTools on a Mac, and the Unpkg Rabbit Hole
Burke outlines the next functional requirement: audience members need to connect and vote from their phones, meaning the homepage needs a prominent QR code. Burke starts writing a prompt containing the hardcoded URL, but Kent stops him and suggests telling the agent to pull `window.location` directly in client-side JavaScript instead. Burke is surprised that the browser can dynamically generate its own QR code on the fly without server involvement. The agent responds by injecting an external script tag pointing to `qrcodejs` from a CDN, but the rendered page fails to show the code.
```mermaid
flowchart TD
accTitle: Client-Side QR Code Generation Fallback
accDescr: Process of attempting dynamic QR code generation from CDN to unpkg inspection.
subgraph CDN ["External Delivery"]
Inject -->|"HTTP GET"| CDNFile["CDN Script Request"]
CDNFile -->|"404 Not Found"| Err["QR Code Not Defined Error"]
end
subgraph Debugging ["Debugging Fallback"]
Err --> Switch["Switch to unpkg Provider"]
Switch --> Inspect["Browse unpkg Directory Contents"]
Inspect --> Failure["Missing Extension / Plain Text Stream"]
end
```
Burke tries to troubleshoot the broken script, running into keyboard shortcut confusion across operating systems:
> “How do you open it on a Mac? I'm a PC guy.”
Kent feeds him the shortcut (`Command` + `Option` + `I`), revealing a console error showing that `QRCode` is undefined because the CDN script request returned a 404. Kent advises switching the package source to `unpkg`—a free CDN that resolves npm packages directly to their target modules—while joking about running the live presentation on infrastructure with no service-level agreement. When that script also fails to resolve cleanly, Kent and Burke inspect the source files directly in the browser by opening `unpkg`'s package browsing directory. They discover the package binary is serving an unexpected raw text stream without an extension. Realizing this rabbit hole could consume all their time, Burke leaves Kent behind to untangle the package resolution while he heads down to check in on the rest of the team.
- Dynamic client-side QR generation relies on reading the host and path via `window.location`.
- The agent originally fetched a non-existent CDN path, resulting in an unhandled 404 in the browser network panel.
- Opening developer tools on macOS requires `Command` + `Option` + `I` rather than the Windows standard `F12` or `Control` + `Shift` + `I`.
- The `unpkg` browse mode enables directory listing by stripping the file path after the package root slash.
---
[15:43](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=943s) Checking In on Julia: GPT-5.5 High Reasoning and One-Shotting
Burke walks over to Julia Kasper's station to inspect her progress on the markdown editor challenge. Julia explains that she is running VS Code locally connected via Azure mode, using GPT-5.5 set to the high reasoning profile. Because Julia collaborates directly with model providers on integrating new models into VS Code, she shares an inside observation regarding provider benchmarks: model teams have grown weary of seeing automated front-end leaderboards dominated by competing models, so OpenAI placed special emphasis on refining their front-end development capabilities for this release.
Julia demonstrates her structured generation workflow. Instead of jumping directly into scaffolding source files, her high-reasoning prompt first synthesized a design specification document titled `idea.md`, defining core user actions and architectural requirements. Once she validated the ideas outlined in the document, she instructed the model to execute the entire implementation in one continuous operation. Burke expresses amazement at her daring, all-or-nothing approach to code generation:
> “You're just going to one shot the whole thing.”
- Julia runs the agent against GPT-5.5 in VS Code using the high reasoning setting.
- OpenAI deliberately optimized the model's capabilities around front-end UI generation to counter Opus-based benchmarks.
- The two-step generation flow starts by outputting user flows to `idea.md` before prompting the model to execute the complete codebase in a single pass.
---
[17:00](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1020s) Checking In on Christian: Multi-Model Orchestration with Opus and Codex
Burke moves over to Christian Reddington's desk, where an initial user interface with an outline and an editing text box has already materialized. Christian is tackling the build by setting up an orchestrator-and-worker multi-agent pattern entirely through structured prompting rather than relying on an external orchestration framework. He manages his development environment across full-screen workspace tabs, allowing him to swipe back and forth between the agent generation sessions and the live application view.
Christian divides duties between different specialized foundation models to balance strategic architectural planning against raw code output:
> “So we've got Opus as the kind of planner, so that more powerful model.”
Christian pairs Anthropic's Claude Opus for high-level orchestration with OpenAI's Codex executing the tactical code implementation. Burke takes a moment to address the entire audience, calling for a round of applause for Julia Kasper, highlighting that she is the engineer responsible for burning late-night oil to ensure all newly announced foundation models launch inside Visual Studio Code and GitHub Copilot the moment they are released.
- Christian uses prompt-based orchestration to direct sub-agents without secondary frameworks.
- The multi-model pipeline uses Claude Opus as the high-level planner and Codex as the implementation engine.
- Workspace switching allows full-screen isolation between code generation outputs and live browser testing.
---
[18:19](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1099s) Checking In on Harald: "That's Literally VS Code and Live Share"
Burke arrives at Harald Kirschner's station, where Harald immediately launches into a humorous complaint about the challenge prompt. Burke had asked for a real-time, collaborative markdown editing application. Harald points out the deep irony of building that software inside Microsoft:
> “And I was thinking, as someone working on a product that you're somewhat familiar with, that's literally a thing.”
Harald notes that Burke's requested application is functionally identical to Visual Studio Code paired with the Live Share extension, something the team had already built years earlier.
Harald then walks through his implementation stack. Working inside the GitHub Copilot application in Plan mode with GPT-5.5 High, he allowed the agent to map out the application architecture. However, Harald was disappointed that Plan mode bypassed Monaco—the underlying open-source code editor that powers VS Code itself—and instead suggested CodeMirror alongside five other alternative web editors. When Harald tests the running prototype by opening dual browser windows to demonstrate real-time synchronization, the text fails to mirror across the two panes, revealing that the agent had mocked the synchronization state with hardcoded placeholders rather than true real-time sockets.
- Harald jokes that Burke’s challenge prompt recreates existing Microsoft technology: VS Code combined with Live Share.
- The workflow was initiated in GitHub Copilot's Plan mode powered by GPT-5.5 High.
- Instead of utilizing VS Code's native Monaco editor component, the planning agent recommended CodeMirror and several other third-party text editor libraries.
- The initial live demo showed superficial UI elements with fake, non-functional synchronization between sessions.
[19:29](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1169s) Harald’s Research and Multi-Agent Design Exploration
Burke Holland checks in on Harald Kirschner to see how his project is progressing. Harald explains that his very first move was to spawn an agent session dedicated purely to background research, querying what markdown editors are already running out in the wild. Burke jokes that Harald generated a research report just to rip off all the best existing ideas, to which Harald readily agrees: “Yes, especially if you want to ship within 45 minutes.”
Harald then kicked off a parallel design exploration session to test three distinct visual and architectural directions. He deployed a dedicated design agent to generate mockups representing different approaches to session management, visual design rationales, review ergonomics, and document editing workflows. Inspecting the options labeled A, B, and C on screen, Burke notices a UI detail on layout A: it features a miniature Post-it note element attached to comments. While Harald favors option B, its layout overflows the screen boundary, prompting Burke to lobby hard for the Post-it motif on layout A, declaring that every comment should have a little sticky note attached to it.
- Harald started with an autonomous research query session mapping out existing markdown editor implementations before writing code.
- A design agent was instructed to produce three distinct UX explorations (A, B, and C) focused on session tracking and review management.
- Layout A introduced sticky Post-it style comment attachments, which Burke singled out as the must-have design feature.
---
[21:01](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1261s) Deploying the Audience Voting App via QR Code
Burke transitions back over to Kent Dodds, who has been tasked with building a real-time voting web application from scratch so the live audience can score the contestants. Kent prompts his agent in a GitHub Codespace, quickly generating a working QR code on the presentation screen. Burke asks the crowd for a round of applause, inviting everyone to scan the code with their mobile phones to join the live application, playfully telling them to bypass the default GitHub Codespaces disclaimer screen without overthinking it.
```mermaid
flowchart TD
accTitle: Real-Time Voting App Architecture
accDescr: Data flow from audience mobile clients through a server module with an event emitter persisting to a JSON file and broadcasting updates.
subgraph ClientLayer ["Client Layer"]
A["Audience Mobile Web App<br/>(Light Mode One-Pager)"]
end
A -->|"HTTP POST / Record Vote"| B
B --> C
C -->|"Write vote state"| D
C -->|"Emit update event"| E
E -.->|"Live bar chart updates (Planned)"| A
```
Kent walks through the modifications made by his coding agent: he stripped out the initial user sign-in page to lower friction and enforced light mode across the interface. Standing by his UI choice against traditional developer aesthetics, Kent proclaims: “Light mode is the best mode.” Originally, the agent assumed the app needed a multi-challenge tournament structure, but Kent directed it to collapse everything down into a focused, single-page polling interface. The agent prompts Kent for the specific contestant names to populate the ballot, and Burke rattles off the lineup: Julia, Chris, P-Bog (Pierce Boggan), and Harald.
- The audience connects directly to a live GitHub Codespace instance serving the web application.
- Authentication screens and complex tournament routes were removed in favor of an instant single-page ballot.
- The ballot candidates were registered directly into the agent context: Julia, Chris, P-Bog, and Harald.
---
[22:40](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1360s) Voting Mechanics, Scripting Fears, and Model Tiers
With the contestants locked in, Burke and Kent discuss whether audience members should be allowed to submit multiple votes for their favorites by repeatedly tapping the screen. When Burke queries the audience on whether multi-voting should be enabled, the crowd hesitates, preferring a fair, single-vote system. Burke teases the room for being too upstanding, though he jokingly spots someone in the back row and warns: “Somebody's going to write a script.”
```
+------------------------+-----------------------------------------------------------+
| LLM / Engine | Kent's Context & Impressions |
+------------------------+-----------------------------------------------------------+
| Claude Opus 4.6 | Active default in the current Codespace environment |
| GPT-5.4 / GPT-5.5 | Preferred daily driver; 5.5 missing due to login state |
| Composer 2.5 (Kimi) | Kent's alternative workflow engine when working in Cursor |
+------------------------+-----------------------------------------------------------+
```
While the agent churns on the UI update, Burke notices that Kent's editor is running Claude Opus 4.6. Kent admits it was the default model inside the container environment. He notes that in his everyday workflow he typically leans on GPT-5.5, or uses Composer 2.5 (which is Kimi-based) inside Cursor. Seeing GPT-5.4 listed, Kent decided to stay on Opus rather than troubleshoot container account logins, quipping about using modern tools versus models from a couple of months prior. Burke hints at strong offline opinions comparing incremental model variations, remarking: “I have thoughts on Opus 4.6 versus 4.7 versus 4.8, which I will share when we're not live on air.”
---
[24:34](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1474s) Architecting State Persistence and WebSockets Under Time Constraints
Once the agent completes its run, Kent inspects the rendered interface on mobile dimensions. While responsive rendering holds up, refreshing the browser immediately reveals a fatal flaw: the app lacks data persistence, resetting all votes to zero on reload. With roughly 18 minutes remaining in the overall session—and only about 12 minutes before judging begins—they evaluate storage backends. Kent weighs SQLite against a plain JSON flat-file storage mechanism on the Codespaces file system, concluding that SQLite provides negligible benefit for their immediate need.
They instruct the agent to build a server-side module in Node.js responsible for saving votes to a local JSON file while maintaining an in-memory pub/sub mechanism to detect state mutations. Kent asks for the architecture to be prepared for future WebSocket integration without blocking current progress on full duplex wiring. The agent creates a single-tenant EventEmitter pattern in one shot. Kent approves of the agent's architectural foresight: “It's a single-tenant event emitter, so any future websites, that's exactly how I would do it.” With time running short, they skip full WebSocket integration for the immediate next prompt, commanding the client to execute standard HTTP requests to record each vote reliably.
- Persistence was implemented via a Node.js server module writing directly to a local JSON file.
- The agent decoupled vote persistence from communication by instantiating an internal `EventEmitter` pipeline.
- The team deferred WebSocket wiring to prioritize basic vote recording before the impending 12-minute deadline.
---
[26:50](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1610s) Audience Tooling Demographics and Conversational Prompting Hygiene
To take advantage of an agent generation pause, Burke conducts an informal survey of the audience to see which AI development environments are currently in active use across the room. A substantial number of attendees raise their hands for Visual Studio and Visual Studio Code, alongside multiple hands for the newer GitHub Copilot standalone app, the integrated VS Code agent interface, and terminal-based CLI tools.
Kent uses the intermission to share practical advice on communicating with coding agents. Because he is inside a container without voice mode configured, he types all his instructions manually, but he emphasizes that developers waste enormous amounts of time fixing typos. Kent advises the crowd to stop micromanaging their input: “LLMs are extremely good at language. That's what they do. So you don't—if you're like backspacing, stop doing that. You don't have to get it right.” He adds that non-native English speakers should simply converse in their native language rather than struggle through translations, as modern frontier models handle multilingual context natively.
Burke wraps up the segment with a linguistic riddle inspired by an AI documentary depicting future autonomous agents inventing their own ultra-efficient communication protocols. He challenges the audience to name the single most efficient human language for AI communication. When audience members guess Esperanto and Mandarin, Burke reveals that while Mandarin ranks highly near the top, neither is number one, leaving the room hanging as the prompt completes.
[29:14](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1754s) Why Agent Prompting Leans on English
Before checking in on the live coding contestants, the presenters briefly discuss why English remains the default working language for orchestrating agents. English carries immense semantic density, where a single descriptive word like "bucolic" immediately conveys rich context, tone, and specific associations to an LLM. Beyond the sheer semantic density, English heavily dominates the underlying pretraining datasets for current models. While the hosts acknowledge this dynamic may evolve over time, English remains the most effective medium to steer models precisely. With about ten minutes remaining in the build challenge, the hosts switch gears to walk the floor and assess each competitor's progress.
Julia has made strong progress on her dual-window collaborative editor, though she ran into user-interface friction along the way. Initially generating her implementation with GPT-5.5, she found that while the logic was solid, the model began corrupting parts of the UI. To stabilize the frontend, she swapped her model mid-stream to Claude Opus 4.6 to finish refining the UI. Demonstrating the live build, Julia shows a split-window layout representing two distinct user sessions side-by-side, where typing in one window renders smoothly and responsively in the other.
She notes that while the sync engine correctly identifies distinct active users, both avatars or labels currently display the same username, which she plans to fix. She has also wired up a dedicated share link feature. Expressing satisfaction with how fast the build came together, Julia remarks, “So far I basically one shot at it.”
```mermaid
flowchart LR
accTitle: Julia Model Handoff Architecture
accDescr: Pipeline showing Julia prompt passing through GPT-5.5 for initial code generation and then Claude Opus 4.6 for UI refinement into dual split windows.
subgraph LLM_Pipeline["Model Workflow"]
A["Core App Prompt"] --> B["GPT-5.5 (Core Logic & Sync)"]
B -->|"UI Glitches Detected"| C["Claude Opus 4.6 (UI Refinement)"]
end
subgraph App_Output["Split-Window UI"]
C --> D["User Session 1 (Markdown Editor)"]
C --> E["User Session 2 (Live Preview / Share Link)"]
D <-->|"Real-Time Sync"| E
end
```
[30:47](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1847s) Contestant Check-ins: Christian and Pierce Push Boundaries
Moving across the stage, the hosts check in on Christian Reddington, who is building directly inside the terminal CLI. Christian displays a text-based environment converting raw Markdown input directly into formatted terminal output in real time. The hosts react with visible excitement, comparing the terminal-driven document renderer to a command-line rendition of Google Docs.
Pierce Boggan is working within the browser through a custom GitHub app preview. His setup features an editor previewing Markdown with live, low-latency updates. Rather than stopping at basic document editing, Pierce embraces full feature creep. He announces he is adding colon-syntax emojis (like `:smile:`), plans to embed a pet widget directly into the document canvas inspired by the VS Code Pets extension, and is integrating the Copilot SDK to trigger autonomous document generation. Reflecting on his aggressive list of last-minute features, Pierce admits, “I'm using Copilot SDK, so we've got some things firing off right now. I'm a little nervous. That's a lot, but we'll see where we land.”
[32:03](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=1923s) Harald's Speculative Fleet: Worktrees, Research Queries, and AGENTS.md
Harald Kirschner surprises the hosts by announcing that his core implementation is already finished. Rather than relying on a single iterative run, Harald built an entire prototype pipeline synthesized from three earlier exploratory prototypes, cherry-picking the best capabilities into a single combined build. He ran a dedicated background research query to determine optimal architecture, merged those findings with his prototype, and then spawned three autonomous background agents across distinct Git worktrees to race against each other.
Each agent received a different architectural angle: one was prompted to parse Harald's Copilot CLI session history to extract architectural plans, while others were seeded with alternative system prompts. Furthermore, he diversified the model backends across the fleet, running two agents against OpenAI GPT models and a third against Claude Opus 4.6 to evaluate which model produces the highest quality code. When the hosts jokingly question his compute budget and ask why he didn't launch twelve agents instead of three, Harald notes that one of the agents has already finished a clean implementation. Addressing whether his codebase is becoming an overly complex production application, Harald clarifies that his project rules are explicitly constrained in an `AGENTS.md` file: “No, no, no. But my AGENTS.md clearly says don't build a product we're building, otherwise it's like doing migrations.” Harald emphasizes that throwaway, hackable code is essential during rapid prototyping so teams can pivot without carrying legacy baggage.
- Harald leverages multiple Git worktrees simultaneously so concurrent agents write and compile code without causing local workspace file conflicts.
- He combines an automated architectural research query directly with prior prototype code before spinning up competitive sub-agents.
- Multiple contestants on stage actively employ `AGENTS.md` files to enforce behavioral guidelines, scope boundaries, and architectural patterns for their Copilot instances.
[34:01](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=2041s) Building the Audience Voting Tool: WebSockets and the Poster Board Aesthetic
Back at the host desk, the presenters scramble to finish their live audience polling app before the contestants finish. The backend now writes incoming click events into a local `data.json` file—recording test votes successfully for contestants like Julia—and the AI has wired up WebSocket support to broadcast tally updates in real time. Before exposing the port publicly, the host decides to overhaul the interface design using a Claude Opus 4.6 agent paired with a custom reusable persona skill called "Poster Board."
The Poster Board design system explicitly documents typography, strict color palettes, spacing rules, and a list of design anti-patterns for the model to avoid. The host prompts the CLI to generate ten distinct layout mockups inside a single file, attempting to prefix the execution with a `fleet` command to trigger parallel sub-agents. Because the prompt asks for all ten mockups to be written into the exact same file, the agent's internal planner decides against parallel delegation, falling back to a single general-purpose agent to prevent write collision. Explaining this iterative aesthetic approach, the host remarks: “I do this a lot when I'm designing. I'm like, give me 10 designs. I'll pick the one that I like the most and then I'll iterate on that one and say, give me another 10 and like whittle it down until I get to something that's fairly good.”
- The custom "Poster Board" skill acts as an external design token repository that standardizes appearance across otherwise disconnected side projects.
- Prompting agents to generate ten variations in a single document gives developers an instant visual picker to choose from before committing to a final implementation.
- With seven minutes left on the clock, the hosts stall for time as the model writes out the mockups, bantering with the audience and audio engineers about evening plans and reminiscing about how bass-heavy and chest-thumping The Chainsmokers concert was at the event the previous night.
[38:18](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=2298s) Backstage Encounters and Launching the Live Audience Voting App
While waiting for their automated agents to finish building, the hosts pass the time with backstage banter from earlier in the event. One speaker recalls hanging out by the stairs talking to Kayla during the keynote when a massive crowd formed around two men; it turned out to be The Chainsmokers, prompting the realization that they missed out on a high-five or a selfie that could have made them famous. Shifting back to the live build, the hosts note that software development has officially entered a bizarre new era: “This is the era we're in where we just watch agents cook.”
```mermaid
flowchart TD
accTitle: Audience Voting Flow
accDescr: GitHub Codespaces port forwarding to audience live voting
subgraph Codespaces ["GitHub Codespaces Environment"]
A["App running on Port 4000"] --> B["Set Port Visibility to Public"]
end
subgraph AudienceAccess ["Audience Interaction"]
B --> C["Generate New Public URL & QR Code"]
C --> D["Audience Phones Scan & Cast Real-Time Votes"]
end
```
To let the audience evaluate the prototypes, the team makes their live app's port visibility public via GitHub Codespaces, marveling at how straightforward Codespaces makes sharing web servers. After displaying a freshly generated QR code, audience members immediately start hitting the voting endpoint from their mobile phones. Before the contestants even finish presenting, votes already begin ticking up on screen for Julia and Harald, leading to jokes about whether users can vote for themselves or spam the system by refreshing their browser pages. Meanwhile, the hosts struggle with opening a generated `mocks.html` file inside VS Code after their terminal reloads unexpectedly, debating whether to reload the editor or simply press forward under their tight three-minute countdown.
- **Port Configuration**: Exposed port `4000` publicly in GitHub Codespaces to stream real-time polling updates directly to audience smartphones.
- **Time Remaining**: The team checks their clock and realizes they only have 4 minutes left, rapidly dropping to under 3 minutes before the session wraps.
---
[41:24](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=2484s) The 20-Second Prototype Pitches
With only a few minutes left on the clock, each developer gets a strict 20-second rapid-fire window to showcase their multi-agent-generated solutions.
Julia leads off by showing a minimalist, split-screen markdown editor. Her build includes:
- Seamless file creation and workspace renaming.
- A personality/vibe selector allowing users to change their display name and choose distinct emojis.
- A collaborative edit-tracking panel that inspects specific modifications to reveal who made them.
- One-click link sharing.
Chris presents second, demonstrating an editor incorporating a structured sidebar for spinning up extra files and a full WYSIWYG editor styled using GitHub's Primer design system. Behind the scenes, Chris deployed a Playwright agent running automated tests against the user interface to detect styling flaws or missing npm dependencies—a fitting tool choice given that he happens to be wearing Playwright socks on stage. His interface also integrates status tiles across the top representing active users with automated avatars rendering in the background.
Pierce steps up third, admitting that his API only booted moments before after appearing completely broken while Chris was speaking:
> “You tried to warn me, Kent. You tried to warn me.”
Pierce explains that his agent added emojis while accidentally regressing existing functionality, resulting in a somewhat clunky UX where selecting text forces the user to scroll halfway down the page to hit a button before scrolling back up. Nonetheless, he successfully got inline commenting working, even if his design wasn't winning any awards compared to Chris's GitHub Primer styling.
Finally, Harald showcases his prototype with only 20 seconds remaining, joking that they are in San Francisco so he has to sell it like an official pitch deck. He unveils two working implementations:
1. **A Reading Room**: Automatically discovers, loads, and reads through local `plan.md` session files, reflecting the exact agent plan that scaffolded the prototype itself.
2. **A Collaborative Document Editor**: Emphasizes quick actions, comments, and automated suggestions over raw markdown syntax. Harald explains his philosophy: “I don't want to edit markdown anymore. I want my agent to edit markdown.”
---
[45:21](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=2721s) Announcing the Winner and Session Wrap-up
With the session running 23 seconds into negative time, the team opens the live voting dashboard on port 4000 to check the audience tally. Harald takes a clear, commanding lead on the scoreboard. Rather than running a drawn-out countdown, the hosts decide to call it on the spot:
> “I think we're going to have to say it was Harold. He won in his heart and with the votes.”
The audience breaks into applause for all four contestants, acknowledging how intimidating it is to code and debug agents live in front of a theater full of peers. The speakers conclude by highlighting upcoming sessions focused on the Model Context Protocol (MCP) and GitHub Copilot, thanking the attendees for joining, and encouraging everyone to explore the recommended session resources.
## Notable quotes
> [38:18](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=2298s) This is the era we're in where we just watch agents cook. — Burke Holland
> [41:24](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=2484s) I don't want to edit markdown anymore. I want my agent to edit markdown. — Harald Kirschner
> [05:35](https://www.youtube.com/watch?v=n-ifKF4tn-4&t=335s) The really the only way to be productive with an agent is to put it into allow all or Yolo mode and just let it do its thing. But a lot of organizations won't let you do that because that's inherently unsafe. — Burke Holland
## Mentioned
Visual Studio Code, Microsoft, OpenAI, GitHub Copilot, GitHub Codespaces, Kent C. Dodds, Burke Holland, Julia Kasper, Christian Reddington, Pierce Boggan, Harald Kirschner, Next.js, CodeMirror, Monaco Editor, Live Share, Claude Opus 4.6, GPT-5.5, GPT-5.4, Codex, Composer 2.5, Cursor, Playwright, GitHub Primer, The Chainsmokers, Model Context Protocol
## Video description
Building with one agent is familiar. Orchestrating a fleet of them in parallel across local, background, and cloud surfaces is where it gets real. You'll see the decisions that matter, how to decompose work across agents, when to fork vs. delegate, and how to verify quality when agents outnumber you. Leave with patterns for multi-agent workflows you can apply to your own codebase tomorrow.
Seating for this session is first-come, first-served. Add it to your schedule to plan your day and arrive early to secure a spot.
To learn more, please check out these resources:
* https://aka.ms/build26/BRK201
𝗦𝗽𝗲𝗮𝗸𝗲𝗿𝘀:
* Julia Kasper
* Harald Kirschner
* Burke Holland
* Kent Dodds
* Christian Reddington
* Pierce Boggan
𝗦𝗲𝘀𝘀𝗶𝗼𝗻 𝗜𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻:
This is one of many sessions from the Microsoft Build 2026 event. View even more sessions on-demand and learn about Microsoft Build at https://build.microsoft.com
BRK201 | English (US) | Developer tools & frameworks
During a live Visual Studio Code challenge, developers demonstrated that effective multi-agent engineering relies on strategic orchestration, context management, and scope control rather than manual syntax generation.
Shifting Developer Roles and Emergent Context Planning (7:15)
As artificial intelligence models advance, coding mechanics are no longer the primary development bottleneck. Kent C. Dodds argued that instruction has shifted toward helping engineers determine what to build rather than how to construct it manually. Unlike conventional agile development that progressively scales from minimal baselines, agent-driven workflows frequently generate overly complex architectures that require deliberate pruning. For instance, when scaffolding a basic single-page application, Copilot CLI immediately suggested an enterprise-grade framework like Next.js, prompting Dodds to enforce vanilla HTML and JavaScript to bypass compilation and build-tooling overhead.
Dodds also challenged traditional upfront specification workflows, asserting that "the conversation is the plan." In enterprise settings, he seeds the model's context window by querying it about existing system architecture and primitives before requesting any implementation code. Furthermore, because large language models handle natural language robustly, micromanaging typo corrections in prompts slows developers down unnecessarily.
Sandbox Security and Rapid Parallel Prototyping (5:35)
Executing coding agents with full productivity often demands unrestricted or "Yolo" mode, which introduces organizational risks like credential leaks or local file modification. Burke Holland demonstrated mitigating this risk by running agents within GitHub Codespaces. This cloud sandbox isolates local environments while enabling public port forwarding so real-world users can immediately interact with live endpoints.
Contestants used parallel execution patterns to evaluate different approaches under tight deadlines. Harald Kirschner started by dispatching an automated research agent to inspect existing markdown editors, followed by a design agent generating multiple UI directions. To prevent write conflicts and explore competing architectures simultaneously, Kirschner deployed multiple Git worktrees where autonomous background agents competed across different foundation models. Similarly, the hosts employed an iterative "Poster Board" design token system to generate ten mockups in a single file before refining their preferred layout.
Multi-Model Orchestration and Specification Guardrails (17:00)
The competition highlighted multi-model orchestration over reliance on a single generic model. Christian Reddington divided responsibilities between Anthropic's Claude Opus for high-level architectural planning and OpenAI's Codex for tactical code generation, coordinating both through structured prompts without secondary frameworks. Julia Kasper adopted a staged approach: using GPT-5.5 High Reasoning, she generated an `idea.md` document defining user actions and architectural requirements before executing the entire implementation in one pass. When frontend visual bugs appeared, she swapped to Claude Opus 4.6 to stabilize the interface.
Multiple contestants relied on `AGENTS.md` configuration files to establish rigid project boundaries and prevent models from over-engineering throwaway prototypes. Kirschner emphasized that explicit agent instructions prevented the model from constructing production-level abstractions that complicate rapid pivoting. Meanwhile, Pierce Boggan illustrated the dangers of feature creep: integrating emojis and agent extensions late in the build led to UI regressions that complicated the user experience.
Balancing Fast Trade-Offs Under Constraints (24:34)
Building live software required aggressive prioritization and knowing when to defer complex engineering patterns. When building the audience voting application, Dodds and Holland discovered that browser reloads reset vote counts to zero. Rather than configuring a full database like SQLite, they instructed the agent to save data to a local JSON file while wiring a Node.js `EventEmitter` to detect state mutations. To ensure basic vote collection before the deadline, they postponed full WebSocket bidirectional streaming and prioritized reliable HTTP requests.
Similar trade-offs surfaced when third-party dependencies failed. An early attempt to generate on-screen QR codes broke when an agent fetched a non-existent CDN path, resulting in browser 404 errors. When switching to `unpkg` led to unparsed raw text streams, resolving the packaging bug directly proved too time-consuming, reinforcing the need to simplify architectural dependencies during rapid prototyping.
The competition concluded with Harald Kirschner winning the audience tally by combining local plan-parsing with an agent-assisted editing workflow. The exercise demonstrated that while autonomous agents can deliver functional full-stack applications in minutes, success hinges on the developer's ability to steer architectures, maintain sandboxed environments, and prune agent-generated complexity.
Source quotes
[38:18] Burke Holland: This is the era we're in where we just watch agents cook.
[41:24] Harald Kirschner: I don't want to edit markdown anymore. I want my agent to edit markdown.
[5:35] Burke Holland: The really the only way to be productive with an agent is to put it into allow all or Yolo mode and just let it do its thing. But a lot of organizations won't let you do that because that's inherently unsafe.
Original transcript
[0:00] Hey welcome everyone, We're so glad to see you here.
[0:04] This is multi agent patterns in VS Code.
[0:06] You will learn from the docs, but more importantly, this
[0:10] is a live vibe coding competition.
[0:12] And before we get started, this is my illustrious Co
[0:15] host, Mr.
[0:15] Kent C Dodds.
[0:16] Hello.
[0:17] Everybody all right and you have some an exercise.
[0:21] Oh yeah, that's right.
[0:22] So as people are finishing coming in, every time I
[0:25] give a talk, I like to get people's blood flow
[0:27] going because it's good for your brain, so you'll learn
[0:30] better.
[0:31] So I'd like to invite everybody to please stand.
[0:33] If you're physically able, please stand up here.
[0:35] I'll let's step over to the side so they can
[0:37] observe what we're going to do.
[0:40] Put your arms out like this.
[0:41] Squat down, come back up.
[0:43] This is called exercise.
[0:46] We're going to do 12 together and you'll get back
[0:48] up.
[0:48] Get back up.
[0:49] You got to count out loud.
[0:50] That was just a practice.
[0:51] So we'll start with ready 1-2.
[0:54] You got to count with me.
[0:55] Look at that 340.
[0:57] You're doing so good.
[0:59] It looks like you 7 and you can go really
[1:02] deep if you really need it or just like a
[1:06] little bit.
[1:07] I lost count.
[1:08] 110 OK, eleven no and 12 OK Stretch up and
[1:12] over to one side and to the other.
[1:16] All right.
[1:17] Awesome.
[1:18] Thank you.
[1:18] Thank you.
[1:19] All right, feeling good.
[1:21] Everybody's awake now.
[1:22] All right, welcome.
[1:23] We have a live.
[1:25] What we're going to do here today, folks, is a
[1:27] live vibe coding competition.
[1:30] Last year.
[1:31] Who, who, who watched this last year?
[1:33] Your ability to watch this couple of folks.
[1:36] So last year, let me just let me just baseline
[1:39] for you where we are in human history.
[1:42] Last year at this time, Open AI had just released
[1:47] GPT 4.1.
[1:48] OK, That was 12 months ago, I think it was.
[1:52] And last year we made Frogger.
[1:55] Each person made their own version of Frogger.
[1:57] And then you voted on the one that you like
[1:58] the most.
[1:58] They made it from scratch this year, right?
[2:02] Things are a lot different.
[2:05] We now have much more capable models and so this
[2:09] year, Oh no, that's my illustrious.
[2:13] This year we have Kent C dot so Kent, you've
[2:15] been prolific as long as I've been alive, much like
[2:18] Addie.
[2:19] Tell us a bit about yourself and.
[2:22] Yeah, yeah.
[2:23] So I'm a software developer, primarily JavaScript and the web
[2:26] is my jam.
[2:27] And I'm a full time educator and I teach people
[2:31] how to build excellent user experiences.
[2:34] These days you don't know, you don't really need to
[2:36] know how to actually do the building part of that
[2:39] as much.
[2:39] And so I'm focused on teaching people how to know
[2:42] what to build.
[2:43] So if you're tired of building the wrong things, then
[2:46] come talk to me, all right?
[2:48] So we're going to get some free, I'm going to
[2:51] get some free instruction from Kent as these folks live
[2:53] code.
[2:54] But last year we did build Frogger.
[2:56] This year we're going to take it up a notch.
[2:57] So we were thinking, yeah, which one should we have
[3:02] them build?
[3:04] Halo 1.
[3:06] I'm serious, which one are they going to build y'all?
[3:08] Oh, no AI could do anything.
[3:10] It's going to right #2 GTA.
[3:14] No, GTA never coming #2 sorry.
[3:19] No, we're actually not going to give this one.
[3:21] We can't do it, we can't do it.
[3:22] Now what we could do though, is what if we
[3:25] did?
[3:25] What if we solved a real problem with AI folks
[3:28] instead of building snake games?
[3:30] I saw someone had tweeted this out on X and
[3:36] they said this.
[3:38] Is there something like Google Docs but for markdown?
[3:41] I need a cloud based collaborative markdown editor, please.
[3:43] So guess what we're going to build today?
[3:46] We're going to build a cloud based collaborative markdown editor.
[3:50] That is the challenge.
[3:52] Let me introduce our contestants here.
[3:54] First.
[3:54] We have Julia from the VS Code team.
[3:56] Hello.
[3:57] Hello.
[3:57] Julia Julia is going to be using VS Code and
[4:00] the local agent in VS Code.
[4:02] Here we have all the way from the UK.
[4:06] Absolutely.
[4:07] Mr.
[4:07] Chris Redington.
[4:08] Hello everyone.
[4:09] Chris is going to be coding by hand.
[4:12] Good luck.
[4:13] Write them.
[4:13] Down, Chris.
[4:14] Is going to be using the copilot CLI to do
[4:17] the challenge further down this way another 50 yards down
[4:22] the field.
[4:24] Here we have Mr.
[4:25] Pierce Boggin, PM on the VS Code team and you
[4:28] will be using the Copilot app today.
[4:31] New Copilot app the.
[4:32] New Copilot app and over here Mr.
[4:35] Harold Kirschner, who's going to be using the agent app,
[4:37] the new agent app.
[4:38] So we have 4 different, yes.
[4:40] Do we have enough apps for doing agent development yet?
[4:43] OK, maybe we need more.
[4:44] Everybody's got their work.
[4:45] Bro.
[4:45] And then while they do that, we, Kent and I
[4:48] are going to build a voting app so that you
[4:51] can vote on the winner.
[4:53] And Kent's going to instruct me and teach me how
[4:55] to do this correctly.
[4:56] So with that, your first instruct Harold.
[4:59] Harold, get your hands off deck.
[5:02] Saw that?
[5:03] The stakes here are very high.
[5:05] Yeah, Your first task is to just input that prompt
[5:10] into the agent.
[5:11] I don't care where you go from there, but you
[5:13] have to start there.
[5:14] Yes, I'm aware of the product probably already exists, but
[5:18] we're going to build it anyway because it hasn't been
[5:20] built here.
[5:21] OK.
[5:23] So while they do that, do we have any more
[5:26] slides?
[5:27] Should we say on your market say go?
[5:28] I think some of them have.
[5:30] Already gone on.
[5:31] Your market say go.
[5:33] All right, we're, it's officially underway.
[5:35] So I don't think we have any more slides.
[5:37] Yeah, we don't.
[5:38] We'll do like that.
[5:39] All right, so if you would, Steve, Steve, throw up
[5:42] my computer, this one here.
[5:44] So Kent and I are going to build the, the,
[5:47] the voting experience for this and we are going to
[5:50] be using a GitHub code space to do this.
[5:52] Now, the reason why we're doing this is because agents
[5:56] are kind of dangerous.
[5:58] The really the only way to be productive with an
[6:01] agent is to put it into allow all or Yolo
[6:03] mode and just let it do its thing.
[6:05] But a lot of organizations won't let you do that
[6:07] because that's inherently unsafe.
[6:09] And so we're going to be in a code space,
[6:11] which means it's not on our machine.
[6:13] And there's special protections on code spaces to keep your
[6:17] keys from getting exfiltrated so you can safely let the
[6:20] the agent kind of run amok and we don't have
[6:23] to worry about it.
[6:24] Yeah, it's going to be awesome.
[6:25] All right, so.
[6:26] And we can even have it run a server and
[6:29] make it public for all of you to be able
[6:31] to actually do the voting and stuff.
[6:33] And it's talking straight to the code space.
[6:35] Pretty cool.
[6:35] Correct.
[6:36] Yeah, we're going to.
[6:36] You're going to connect directly to our dev environment and
[6:39] nothing is going to go wrong.
[6:40] We are all saved, yeah.
[6:41] Absolutely.
[6:42] OK.
[6:42] So, Kent, where?
[6:43] Where do we start?
[6:45] We're here, yeah, we've got, we've got it all set
[6:48] up.
[6:48] I don't know.
[6:49] I think we're primarily using.
[6:53] Well, no, this is the way you like to develop
[6:56] is with the CLI.
[6:57] Correct, right?
[6:57] OK, in Visual Studio Code this is my deferred method
[7:00] in an editor tab.
[7:01] Yeah, perfect.
[7:02] So I think I, I don't know, let's just make
[7:06] a voting thing, no mistakes, right?
[7:08] And that's and then we can just go Raz these
[7:10] guys.
[7:10] Make a voting thing.
[7:11] Make no mistakes.
[7:12] No, don't say that, but no, I'm joking.
[7:15] Well, let's let's think about like as think as a
[7:18] product engineer.
[7:19] That's epic.
[7:19] Product engineer is my thing.
[7:22] What it What is the product actually supposed to do?
[7:25] OK, it needs to be a web page need.
[7:28] So that's the the modality people should be able to
[7:32] vote.
[7:32] They probably need to know what they're voting for.
[7:35] So I assume maybe give you numbers like 1-2, three
[7:37] or four.
[7:38] It needs to visually show in real time what the
[7:41] count is on each one of those things.
[7:44] And it needs to I guess display a winner somehow,
[7:48] either by us saying like finalized or.
[7:52] We, yeah, we click on it or something.
[7:55] Yeah.
[7:55] OK, so I want to break this down to like
[7:58] shippable chunks because this is high stakes.
[8:01] We've got 36 minutes left, so we need to be
[8:03] able to get to a point where, OK, this will
[8:06] work if we're stuck with this, and then we can
[8:09] commit and then keep on adding stuff to that.
[8:11] So why don't we just start with a home page
[8:14] that says what it is and that's it?
[8:17] OK, so just a blank.
[8:18] So OK, so let's see.
[8:19] I think I have do I have voice mode?
[8:21] I don't.
[8:21] And we'll also want to let's actually get that deployed.
[8:25] And once once that's deployed on this machine, then the
[8:28] next thing we can do is get the QR code
[8:30] so they can actually access.
[8:31] Access it.
[8:32] OK, So what am I asking?
[8:33] About here Let's say we're building a voting platform for
[8:38] a coding challenge.
[8:40] Let's just start with something simple.
[8:44] What are you using?
[8:45] Let's do a homepage.
[8:48] I'm using web art.
[8:49] And we'll see what it comes up with.
[8:50] This is the, have you seen that, that visual where
[8:53] you've got like the product development life cycle where it's
[8:56] like we build this, this car and over time, eventually
[8:59] it's like actually what the customer wanted.
[9:02] And there's, there's like, here's the waterfall approach where it,
[9:05] it's nothing like what you want.
[9:06] And then finally it's what you want.
[9:07] And then agile is like it's a scooter and then
[9:09] or it's a skateboard, then a scooter.
[9:11] And then it like it completely changes as you go.
[9:13] Like it's something you can iterate on with AI.
[9:16] It's like it starts with this mega car with all
[9:19] these different features that you don't want and then you
[9:22] subtly get rid of those things.
[9:24] And so that's one of the beauties of using AI
[9:27] and just kind of being free.
[9:29] Like this is you just say, I'm going to be
[9:31] really vague and then we'll like chip away and iterate
[9:34] on what's created.
[9:35] All right, So what are we doing here?
[9:36] What's our stack?
[9:38] Wow.
[9:38] OK, yeah.
[9:39] So this is planning mode I suppose.
[9:41] And it's thinking I don't want to make a.
[9:43] Decision.
[9:44] I just did this.
[9:44] OK, so you're never going to get this guy to
[9:47] use Nextj.
[9:48] Yes, we can talk about that later if you want.
[9:52] I think that this so we do have some like
[9:54] real time and other things in there.
[9:56] So you might think, OK, well, I want like a
[9:58] real framework for that.
[10:00] I have built some pretty amazing things with AI with
[10:03] just vanilla and I honestly for for one page like
[10:06] we've got, let's just do.
[10:07] Vanilla.
[10:07] You think we can get it done?
[10:08] Oh, yeah.
[10:09] OK.
[10:09] All right, Yeah.
[10:10] Here we go.
[10:12] Let's see here.
[10:13] All right, It's creating the home page.
[10:14] The cool thing about this too is like we're this
[10:17] this app is not going to get so big that
[10:20] we need to have like some complicated tree shaking build
[10:23] process or whatever.
[10:25] So this is actually going to be great because we
[10:27] won't have to worry about a build or anything like
[10:30] that.
[10:30] Yeah.
[10:30] Really nice.
[10:31] Yeah, we will.
[10:32] We won't have hot module replacement or any of that,
[10:34] but I don't think we need that.
[10:36] So yeah, I do miss the days when you could
[10:38] just write HTML and JavaScript and make a web page.
[10:41] We're pretty far from that, but yeah, so interesting.
[10:45] So we're starting from sort of a minimal, the most
[10:48] minimum thing.
[10:49] I noticed you kind of skipped the planning.
[10:51] Or did you?
[10:51] Oh, yeah, I do not.
[10:52] I actually don't plan like the, the, the, the, the
[10:57] conversation is the plan.
[10:59] And you iterate on that to get to the ultimate
[11:02] end result.
[11:03] Now, like we're starting a brand new thing.
[11:05] And so it's going to be different from like the
[11:07] hundreds or millions of lines of hundreds of thousands or
[11:09] millions of lines of code that you're working in.
[11:12] But the idea is pretty similar that when I'm, when
[11:15] I'm building a new feature in a bigger app, I'm
[11:18] going to have a conversation with the agent.
[11:20] And I'm going to say like, first I'll ask questions
[11:23] that I actually already know the answer to because I
[11:25] want the agent to get the answers to those questions
[11:28] in the context about like architecture, systems, primitives.
[11:31] And then we iterate on on that.
[11:33] And once we have this conversation filled up with the
[11:36] stuff I want, then I'll say great go.
[11:38] All right, so we have this looks so AI created
[11:40] people think, yeah, we're going to we'll get to that
[11:43] in a second.
[11:44] The purple and the the dark.
[11:45] Yeah, this is.
[11:46] Should we pause?
[11:47] Should we pause this and go Razzie's?
[11:50] I'm kind of, I'm kind of curious.
[11:51] Yeah, I think when we get to 30 here.
[11:52] OK, go down, give 3 minutes, give them a heart,
[11:54] you have 3 minutes, and then we're going to come
[11:56] bug you.
[11:56] Yes.
[11:57] All right, so where do we go from here?
[11:59] We have a, We get the.
[12:00] Now we.
[12:01] I think we need AQR code so folks can actually.
[12:03] Yeah, yeah.
[12:03] So I'm seeing a bunch of stuff on here I
[12:05] want to get rid of, which we'll do later.
[12:07] Like I want to get rid of the sign in
[12:09] and different stuff like that.
[12:10] We don't need that, but let's just get a QR
[12:12] code so people can connect to it from their phones.
[12:14] So I literally I would say people are going to
[12:18] connect to this or vote through their phones.
[12:22] So let's put a QR code on the homepage for
[12:26] the page and I'm.
[12:29] It won't know the URL, so I'll put that.
[12:30] I think actually don't give it that, just say window
[12:34] dot location it will get it.
[12:36] Really.
[12:36] Yeah, you can make a QR code in the.
[12:38] Browser you tell it window dot location.
[12:40] Just say window dot location, it'll get it.
[12:42] Really.
[12:43] I did not know that.
[12:43] Oh.
[12:44] Yeah, sure.
[12:44] So.
[12:44] It's just going to pull it dynamically, use JavaScript on
[12:47] the fly to create.
[12:47] OK, I'm with.
[12:48] It I'm curious because we're using plain HTML and CSS
[12:52] and JavaScript, it's not going to.
[12:55] I mean, there are mechanisms it could use to go
[12:57] get a library for this, but I wonder if it's
[12:59] actually just going to implement it itself, which would be
[13:01] pretty that would be.
[13:03] Just going to add it from scratch.
[13:05] Yeah, I'm kind of curious, what does it say it's
[13:07] doing OK, Well, hey, it.
[13:09] Added QR code JS, yeah.
[13:10] OK, there we go.
[13:11] It's probably pulling it from, yeah, the CDN.
[13:14] Yep.
[13:15] Let's take a look.
[13:16] All right, let's see here.
[13:17] And then I want you all to scan this if
[13:19] it works.
[13:21] That did not.
[13:22] Work.
[13:22] Maybe Devtools will show us something or we can tell
[13:24] the agent.
[13:25] You can just say agent didn't work.
[13:29] How do you open it on a Mac?
[13:31] I'm a PC guy.
[13:32] Command option I.
[13:33] There we go.
[13:34] There you go.
[13:37] Yeah.
[13:37] So we've got QR codes not defined.
[13:38] My guess is if you went in the network, you'd
[13:41] see that the request for the JavaScript file failed.
[13:43] Failed.
[13:43] It probably got the wrong yeah four O 4.
[13:47] Yeah, that's OK.
[13:48] So we can go.
[13:49] This right here.
[13:50] It could be.
[13:53] One thing that I would do is I would just
[13:55] tell it use on package instead.
[13:57] OK, so use on PKG instead.
[14:00] So for those not familiar, Unpackaged is a free service
[14:04] that you basically just give the URL, the name of
[14:07] the package and you can give it like whatever version
[14:11] and it will resolve to the the main module of
[14:14] that package.
[14:15] So it's pretty cool.
[14:17] I don't know if they've got an SLA.
[14:18] So like use at your own risk.
[14:21] We are risking everything right now.
[14:24] What?
[14:25] Happened.
[14:25] I don't know.
[14:26] I'm not even seeing the sign in that I didn't.
[14:27] Know it's gone and there's definitely no.
[14:30] This does happen sometimes.
[14:31] What did it do?
[14:34] Interesting, it just said it switched.
[14:35] Here.
[14:35] Let's let's do a view source.
[14:37] OK, Remember those days when you could do view source?
[14:39] Well we are doing vanilla so we can view source.
[14:42] Oh, you want to view source?
[14:43] Yeah, I kind of want to just view the source.
[14:46] I've been, it's been so long.
[14:47] On page source right there.
[14:48] Since man, I don't think I've done that in years.
[14:51] OK so if you click on the QR code man
[14:54] that should resolve Nope.
[14:56] Still not found?
[14:56] So what?
[14:57] Yeah, that's our issue.
[14:58] Why?
[14:58] Why don't you actually open that back?
[15:00] U OK and there's a way on unpackaged to look
[15:03] at the contents of the package O update the URL
[15:07] and remove everything U to where it says build but
[15:10] leave the slash in.
[15:12] Everything up to where it says build.
[15:14] Yeah, so leave like this.
[15:14] No, no, before or after that, after everything after that
[15:18] and leave the slash in and that will give us
[15:20] a browse page for this.
[15:22] And now we can actually see OK, so what's going
[15:24] on?
[15:24] Maybe they released a new version and changed Oh no,
[15:27] it was two years ago.
[15:28] But yeah, let's maybe go to Ben, maybe QR code.
[15:32] What the TET stream?
[15:34] It doesn't even have an extension.
[15:36] Wow.
[15:37] I tell you what, I'm gonna let you work on
[15:39] this, OK?
[15:39] Check in with these folks down here.
[15:41] Your job is to I'll fix QR code working.
[15:42] All right, I will hear with that.
[15:44] All right, Steve, let me have let's bring up Julia's
[15:48] machine here.
[15:49] Hey, Julia.
[15:49] Hello.
[15:50] How's it going?
[15:51] You want me to walk you through what I did?
[15:53] Yeah, let's see, Are you done?
[15:54] No, my agent is still working.
[15:57] What's going on?
[15:58] Show me what you got all.
[15:59] Right, so as you said I should be using Azure
[16:03] mode and local in VS Code.
[16:05] I picked GBD 5.5.
[16:07] OK on high reasoning.
[16:08] High reasoning, interesting because so I'm supporting a lot of
[16:12] the model launches in VS Code and one of the
[16:14] things we work very closely with the model providers and
[16:18] Open AI mentioned they've seen way too many Opus front
[16:21] end UI bolts, so they really wanted to make their
[16:23] latest models better in front end development.
[16:26] So I wanted to give GBD 5.5 for a test
[16:29] with my wide app that was scaffolded here.
[16:32] And so yeah, I used high reasoning and it created
[16:36] an idea MD file.
[16:37] So let's switch over and see what it came up
[16:40] with.
[16:42] Just a little bit of like what users can do.
[16:46] And after this I told it, OK, perfect.
[16:48] Let's just go and execute based on this idea.
[16:51] And as you can see, it's still working.
[16:52] So I don't know how it's going to look like,
[16:54] but I'm excited.
[16:55] You're just going to one shot the whole thing.
[16:57] I love it.
[16:58] All right, Chris.
[16:59] Hey.
[17:00] Hi, how are we doing?
[17:01] Pretty good.
[17:02] How are?
[17:02] You.
[17:02] Yeah, I'm great.
[17:03] Having a great time.
[17:04] You done?
[17:04] No, OK.
[17:05] What do you got so far?
[17:07] So we've got like an outline, we've got a text
[17:09] box like that's great, right?
[17:10] That's.
[17:11] Pretty good.
[17:11] Does IT support markdown?
[17:13] Probably maybe it's working through it.
[17:15] So what I've done is we've kicked off like an
[17:18] orchestrator kind of agent.
[17:19] So that's kind of a pattern I use typically is
[17:22] have someone that does like a plan and builds it
[17:24] out and then you have some sub agents.
[17:26] That what are you using to do the orchestration?
[17:27] Just fleet.
[17:29] No, so I'm just using some promptings.
[17:32] So I'm.
[17:33] Telling you to use this?
[17:33] Yeah, exactly this exactly.
[17:35] And I notice you've got yours full screen and you're
[17:37] swiping over to see.
[17:38] Is that your the way that you normally work?
[17:40] Yeah, I normally have like multiple tabs open and.
[17:42] But you're using workspaces specifically to.
[17:45] Yeah, yeah, exactly.
[17:47] Interesting.
[17:48] And yeah, so we've got Opus as the kind of
[17:51] planner, so that more powerful model.
[17:53] So you picked Opus?
[17:54] Yep, you picked GPT 5.
[17:56] But then I'm having codecs do the implementation.
[17:59] Oh really?
[18:00] Oh codecs, multi multi model.
[18:03] All right by the way, y'all special round of applause
[18:06] for Julia.
[18:06] Julia ships all the new models in Visual Studio code
[18:09] and copilot said when you see those show up, that's
[18:11] Julia.
[18:11] Can we give Julia a round of applause?
[18:13] It's a lot of late nights, a lot of late
[18:15] nights.
[18:16] All right, all right, boys, what do we got?
[18:20] Here's I'm.
[18:21] Really mad at you, Bert.
[18:22] Why?
[18:23] Because I was reflecting on your prompt.
[18:26] So you want Markdown editing, Collaborative, collaborative, real time, real
[18:31] time.
[18:31] And I was thinking, as someone working on a product
[18:34] that you're somewhat familiar with, that's literally a thing.
[18:38] That.
[18:39] Like literally it's called BS code and live share.
[18:42] I literally already have done this.
[18:46] I'm done with the.
[18:47] Thing you have to build it.
[18:48] This is already a thing.
[18:49] Don't encourage him.
[18:50] Stop it.
[18:52] So I started with a plan in the GitHub Copilot
[18:56] app.
[18:56] So we started in plan mode.
[18:58] GPD 55 High was kind of where I started.
[19:02] We built out a plan.
[19:03] I was I was a little sad Plan Mode did
[19:05] not recommend Monaco as the base.
[19:08] Did it not?
[19:08] By the way, Monaco's the editor that underpins Visual Studio
[19:11] Code.
[19:12] What did it give you?
[19:12] Code Mirror.
[19:14] It gave me like 5 other things.
[19:15] I don't want any of that so so plan mode,
[19:17] it started it's thing.
[19:19] It's working right now and I think we have, we're
[19:22] getting there.
[19:23] Oh, whoa.
[19:24] But this is all fake.
[19:25] Like I went over here and this is not the
[19:27] same as this.
[19:27] So we have work to do.
[19:29] Well, real time should be easy.
[19:31] This is a solved problem.
[19:32] Just make it work exactly.
[19:34] All right, Harold, What?
[19:35] Do you got?
[19:36] Last but not least, you're my favorite one.
[19:38] By the way, don't tell these.
[19:39] Thank you.
[19:39] Thank you SO.
[19:40] Much all.
[19:41] Right, I start with with research on what is out
[19:45] there.
[19:45] That was my first.
[19:46] I just went to research query in one session.
[19:49] Like what are marked editors already running?
[19:51] There's a research report they're going to RIP off all
[19:55] the ideas or pick the best based on.
[19:58] What it's already done?
[19:59] Yes, especially if you want to ship within 45 minutes
[20:03] and then I then I did actually kicked off design
[20:07] exploration where we have three things I want to try
[20:11] out.
[20:11] There's one idea is here, not just just.
[20:15] Getting an idea of how this could look like.
[20:16] What do we have?
[20:17] C We have B See.
[20:19] There.
[20:19] These are your mops for what it might look like.
[20:21] Yeah, just send a design agent out and let it
[20:24] show me like this is like how we manage session
[20:27] maybe or the other one is more on a design
[20:30] rational around making it review easier and kind of evolving
[20:33] a session and what how editing works because we all
[20:37] need to manage these sessions.
[20:39] So I need a lot more context when you throw
[20:41] me back into a plan.
[20:42] We like think that a has like a little post
[20:45] it attached to it.
[20:46] So where's the little?
[20:47] Post it.
[20:49] There's B and so far just my favorite, but this
[20:51] one doesn't fit into the screen well, so this doesn't
[20:53] actually post it.
[20:56] I want that so I want all right every type
[20:58] of comment when they will post it so.
[20:59] Good luck folks.
[21:00] Looking good.
[21:01] Let's go back down here and see how Kent's doing
[21:03] on our QR code.
[21:04] All we need is AQR code.
[21:05] How hard could this be?
[21:07] Hey, let's go.
[21:09] Round of applause for the come on.
[21:11] If that's not impressive, I don't know how to impress
[21:13] you.
[21:14] All right, so you can scan this if you want
[21:16] to do it now and then you'll have access to
[21:18] this app as we go.
[21:19] You'll need to click the little disclaimer there that says
[21:21] you're connecting to a code space.
[21:23] It's fine to worry about it.
[21:24] Don't read it, just click it.
[21:27] OK, where?
[21:28] We'll leave this up here for a second.
[21:29] I see some phones still up.
[21:31] So I removed the sign in Page.
[21:34] I made it light mode because light mode is the
[21:36] best mode.
[21:36] Light mode is the best mode.
[21:38] Sorry, can't set it.
[21:41] Can't argue with Kent.
[21:42] And so right now it's actually working on that, changing
[21:45] a couple of things, because here it kind of assumed
[21:48] that we wanted to do like multiple challenges.
[21:51] We're just doing one right?
[21:52] And so we're just going to have it as A1
[21:54] pager.
[21:54] So it might be done.
[21:55] I'm assuming that most people who want it have got
[21:58] it.
[21:58] So here it asks a question.
[22:00] OK, what are the four interest people will be voting
[22:03] on team name, project titles or placeholder names for now.
[22:06] Oh, let's.
[22:07] Go get names.
[22:07] People names.
[22:08] People names, yeah, there you.
[22:09] Go.
[22:09] We've introduced our contestants, so let me type.
[22:12] Let me give you the names.
[22:13] OK, let's see here.
[22:18] OK, go ahead, Julia, Chris, P Box and Harold.
[22:27] All right.
[22:28] Super.
[22:30] And once we're finished with this, then we need to
[22:34] get it so that we can show some bar of
[22:37] like how many votes they've accumulated.
[22:40] Correct.
[22:41] And now can these individuals vote more than once?
[22:45] That is an interesting question.
[22:46] Maybe it's like I really really, really, really like.
[22:49] Like you can just tap it over and.
[22:51] Over and over again.
[22:52] Right, I don't know, let's.
[22:53] But what do you all think?
[22:54] Do you want to be able to vote more than
[22:55] once?
[22:55] Who wants to vote What?
[22:57] What you're all like.
[22:58] Too fair.
[22:59] Yeah.
[23:00] There we go.
[23:00] There we go.
[23:00] Sometimes that's enough.
[23:01] Let's do that.
[23:02] Fun because then it's like you like you got to.
[23:04] Who cares?
[23:05] That much about?
[23:07] Somebody's going to write a script.
[23:09] Do not do that.
[23:11] They won't look at these people are all upstanding.
[23:14] Yeah, well, they didn't want to be able to vote
[23:16] more than once anyway, so yeah.
[23:17] They're mad about it, OK.
[23:18] Except for that woman in the back there who is
[23:20] jumping up.
[23:20] She's writing a script right now.
[23:22] So, so interesting.
[23:23] I gave it the names and it's been cooking for
[23:26] a little while here.
[23:27] Oh, because it's updating, Yeah.
[23:28] It's building a whole
Like, we're chatting quite a bit I.
[23:33] NOTICED that you were on Opus 4.6 meeting an intentional
[23:36] choice.
[23:37] That's the default.
[23:38] When you go in.
[23:39] So I didn't change it.
[23:39] I was waiting for you to tell me.
[23:41] Yeah, yeah.
[23:42] I typically use GPT 5.5 or in cursor I'll use
[23:47] composer 2.5 also that's Kimi based, but I looked and
[23:52] this had GPT 5.4.
[23:54] So I was like, oh, we'll just stick with Opus.
[23:55] 55 is here.
[23:56] Oh it is.
[23:57] Well, let's get my 5 going, of course, and then
[23:59] we'll tell it clean up Opus mess.
[24:02] Just kidding.
[24:03] Oh, I wonder if it's because.
[24:06] No, I wonder if it's because I'm in a code
[24:09] space.
[24:10] Oh, I don't think I've logged into the.
[24:12] Product account that's why.
[24:13] It's not there unfortunately.
[24:15] That's all right.
[24:15] Opus 4-6 is.
[24:17] This is just like a little blast from the past.
[24:18] Come on, a whole two months ago I have.
[24:23] Thoughts on Opus 46 versus 47 versus 48, which I
[24:26] will share when we're not live on air.
[24:29] OK, let's talk to me about that.
[24:31] Come chat later.
[24:32] All right, All right, so as it's done, let's take
[24:34] a look.
[24:34] OK.
[24:37] All right, now we're talking.
[24:38] Vote for your favorite.
[24:39] Pick the entry.
[24:40] OK, So what happens?
[24:41] Are we responsive here?
[24:43] Let's see here.
[24:45] We're zoomed in.
[24:46] Oh yeah.
[24:47] How does this look on a phone?
[24:48] Yeah, it's like that.
[24:49] That could be we're.
[24:50] Going to fix this in a second anyway.
[24:51] Yeah, yeah.
[24:51] OK.
[24:52] So.
[24:52] What happens if you click check refresh the page?
[24:55] What happens?
[24:56] It's?
[24:57] No, there's no, yeah, there's no persistence, so.
[24:59] Let's talk about next step.
[25:00] That's probably the most important.
[25:02] Just like let's get the persistence in and then we
[25:04] can do the bars and whatnot.
[25:06] So this is running in a code space.
[25:08] There is a file system.
[25:10] We could just have it be like a Jason file,
[25:13] or we could do.
[25:16] Well, like I was going to say, we could do
[25:18] SQLite, but that doesn't really give us much advantage over
[25:21] just a Jason file for and it needs.
[25:23] To refresh on everyone's screen.
[25:25] Yeah.
[25:25] So we're going to have to have like some sort
[25:28] of notification system like when write then like pub sub
[25:31] sort of OK thing going on.
[25:33] So we're going to need web sockets.
[25:35] OK, Yeah, I would just make AI would tell it
[25:39] let's let's well we need a server side module, OK,
[25:43] that is responsible for in fact, no, we want to
[25:47] save it to a file.
[25:49] So say we're going to have a module that's responsible
[25:52] for persisting the votes to a Jason file.
[25:55] And that module will also be responsible for keeping track
[26:00] of when changes are made.
[26:03] And then we'll say like, we're going to wire this
[26:07] up to a web socket, do that later.
[26:12] We got 18 minutes.
[26:13] Yeah, I think, I think we have a chance.
[26:15] Can we do it?
[26:16] I think we could possibly.
[26:17] Is it 18 minutes total or 18 minutes till the
[26:20] judging?
[26:21] Which one is it?
[26:21] I'm thinking that's 18 minutes.
[26:22] Total 18 minutes total.
[26:24] Wow.
[26:24] Jeez.
[26:24] OK.
[26:24] So we really have like.
[26:25] 15 less yeah, 12:00-ish minutes.
[26:28] Not that many.
[26:28] OK.
[26:29] Yeah, Node.
[26:30] Node is fine.
[26:31] Now we just got to Yolo.
[26:32] We got to go.
[26:33] Yeah, I think we're going to do this.
[26:35] I'm feeling confident.
[26:36] We're going to make it happen.
[26:37] When we get to 5 minutes left, we're we're going
[26:40] to say finish it, no mistakes and we'll just see
[26:43] what happens and.
[26:45] It'll probably work rather than all of the workflow steps
[26:48] that we've taken here to make this happen.
[26:50] So just out of curiosity, how many folks in the
[26:54] audience are using Visual Studio and working with agents?
[26:59] All right, Visual Studio, Visual Studio Code.
[27:02] Hey, there we go.
[27:04] Let's go.
[27:05] Anybody using the new GitHub app?
[27:07] GitHub Copilot.
[27:07] I used it yesterday.
[27:08] That's quite a few hands.
[27:09] That's right.
[27:10] Let's go.
[27:11] What about the agent app that's in Visual Studio Code?
[27:14] Any folks using that?
[27:15] Couple of hands there?
[27:16] CLI.
[27:17] Where am I CLI people at?
[27:19] OK, very nice.
[27:21] Nice mix of folks here.
[27:22] Hey we got something OK so data persist nice.
[27:27] So normally I would like to.
[27:30] It's a single tenant event emitter, so any future?
[27:32] Websites, that's exactly how I would do it.
[27:34] OK, one shot.
[27:35] And that's why I said we're going to wire this
[27:37] up to Websockets so it would know, OK, I'm going
[27:39] to need some sort of event publishing.
[27:41] OK, so let's, I don't know, I think that we're
[27:45] at the point where we can say no, let's just
[27:48] do record a vote.
[27:50] So we're not going to do Websockets yet.
[27:51] When I click it should record the vote or like
[27:55] make a request to record.
[27:57] Should make a request to record events.
[28:01] Yeah.
[28:03] And as a friendly reminder, I'm not using voice mode
[28:05] because we're in a code space and I did not
[28:07] do the due diligence of installing voice mode.
[28:10] But if you're typing to the agent, you do not
[28:12] need to correct your misspellings.
[28:13] I don't know if you notice but like these are
[28:16] barely words sometimes it doesn't matter.
[28:18] Lols are extremely good at language.
[28:21] That's what they do.
[28:22] So you don't.
[28:22] If you're like backspacing, stop doing that.
[28:24] You don't have to get it right.
[28:26] And if if your English as a second language, just
[28:29] talk to it in your native language, it's amazing.
[28:31] Yeah, I can do that too.
[28:32] It's it's really good.
[28:33] You know, I watched this documentary about AI where they
[28:36] were talking about how, like in the future, AIS will
[28:39] start to communicate in a language that we don't understand
[28:42] because it's more efficient.
[28:43] And it got me thinking, what is the most efficient
[28:46] language for AIS to communicate in?
[28:49] It looks certainly not English.
[28:51] Does anyone know?
[28:53] Anybody have any guesses what is the most efficient language
[28:56] for the AI to communicate in?
[28:59] You can throw a hot take out there, that's OK.
[29:02] Esperanto what?
[29:03] What did you say?
[29:04] Mandarin.
[29:05] Mandarin.
[29:05] That's one of them.
[29:06] It's not the top.
[29:07] That's like #2 no, nowhere on the list.
[29:11] Wait, do you have an answer?
[29:12] Yeah, I know the.
[29:12] Answer.
[29:13] Oh, OK.
[29:14] It's English and the reason why is because English is
[29:17] like a really semantically heavy language, right?
[29:20] Like if I use the word like bucolic that means
[29:23] a lot to the agent and also because of the
[29:26] training data.
[29:28] That makes.
[29:28] Sense currently that is the language.
[29:30] I just thought that was an interesting.
[29:31] That is interesting, yeah.
[29:33] I'm just trying to fill time.
[29:34] Y'all go with me here?
[29:35] OK, let's check in with our contestants while we're doing
[29:38] you.
[29:38] Are you going to I tell you what you check
[29:39] in I'm?
[29:40] Going to.
[29:40] OK, Yeah.
[29:41] Hi, Julia.
[29:42] Hello.
[29:42] So how are things going?
[29:43] You good?
[29:44] Probably 10 minutes.
[29:46] How are you feeling about that?
[29:47] I feel confident I did have to switch my model
[29:50] in between.
[29:51] OK, what did you switch to?
[29:52] I switched to an Opus 1.
[29:54] Opus.
[29:55] OK.
[29:55] And so the GBT 5.5 did a great job and
[29:58] then it messed up a little bit of my UI.
[30:01] So I had to go in and I had to
[30:03] let a little bit of AUI finish, you know, Opus
[30:06] 4.6.
[30:06] And this is what I have so far.
[30:08] So sweet.
[30:10] As you can see, two windows, split windows.
[30:13] This one is the one of the users and you
[30:16] can see, hey, it notices the users.
[30:18] I can go in and I can type stuff, I
[30:21] hope.
[30:23] Nice and responsive.
[30:24] It's fast.
[30:25] I want something I noticed is I want to update
[30:28] the username because right now it looks like it's just
[30:31] one user but it it's supposed to be two.
[30:34] I like the share link thing.
[30:35] I like that too.
[30:36] I do want to do like a little bit of
[30:38] tweaking on what you can do here, but yeah, so
[30:41] far I basically one shot at it.
[30:43] Oh, I'm impressed.
[30:44] Yeah, I'm loving that.
[30:45] Awesome.
[30:45] OK, let's see.
[30:47] It's sorry, it's Chris, right?
[30:49] It is.
[30:49] Sorry, I didn't.
[30:50] I just want to double check that.
[30:51] So you're working in the CLI.
[30:53] We are and here you go.
[30:55] It is, yes.
[30:56] I feel like I'm looking like at a markdown for
[30:59] Google Docs.
[30:59] Yeah.
[31:00] So, you know, go and put it.
[31:01] Wow, we've got our things there.
[31:03] Obviously it's not so pretty yet, but.
[31:05] I mean, you're converting markdown into like rendered stuff.
[31:09] I'm impressed by that.
[31:10] Yeah, awesome job.
[31:12] Keep doing that.
[31:14] All right?
[31:14] What's going on, Pierce?
[31:16] All right, so I'm in the browser here inside the
[31:18] GitHub app.
[31:19] We have a little editor preview for a markdown and
[31:22] if I pop over here, got some real response, got
[31:25] some real time stuff going on.
[31:27] So Next up for me, got out emojis right.
[31:31] Any bar coded demo is not complete without.
[31:33] So like a colon smile: sort of thing, correct?
[31:37] And then I wanted like something like VS Code pets,
[31:39] but in this editor.
[31:40] So I'm going to go do that.
[31:41] And then I'm feeling ambitious.
[31:43] I'm also going to have like just generate this doc
[31:46] for me so I can vibe even more.
[31:47] I'm using copilot SDK, so we've got some things firing
[31:50] off right now.
[31:52] I'm a little nervous.
[31:53] That's a lot, but we'll see where we land.
[31:55] I love the ambition and you're just you're SCOE creeping
[31:59] on all of us right now.
[32:00] That's exactly.
[32:02] I love it, Pierce.
[32:03] All right, Harold, how is it going here?
[32:05] It's already done.
[32:07] It's whoa.
[32:07] Whoa, really?
[32:08] This is the a.
[32:12] This is the prototype based on the three prototypes before
[32:14] I kind of pick and choose these are the features
[32:16] I want make me combine 1.
[32:18] So and then I gave this prototype.
[32:20] It did also an analysis on what what should the
[32:23] architecture be.
[32:24] It was like a separate research career I ran and
[32:27] now combine the research plus the prototype and now I
[32:30] have three agents doing that different work trees and maybe
[32:34] one of them wins.
[32:36] OK, Hey.
[32:37] So they all got slightly different prompts like 1 was
[32:40] build it based on my copilot CLI sessions and just
[32:43] extract all the plans.
[32:44] The other one I got a different spin, so I
[32:48] just more agents.
[32:49] Yeah, you're.
[32:50] To get to maybe the best winner.
[32:52] I tried it last time too and I think I
[32:54] won.
[32:54] I didn't win.
[32:56] But in your heart you won.
[32:58] You know what?
[32:58] In your heart you might win this time too.
[33:01] You're not very cost sensitive, I notice.
[33:03] You're just why?
[33:05] Why 3?
[33:05] Why not 12?
[33:06] But.
[33:07] Two of them run on GPT and another one on
[33:09] 4/6.
[33:10] So someone calls against models as well.
[33:12] OK.
[33:12] Yeah, yeah.
[33:12] See what makes better I, I.
[33:14] Love it, I'm excited to see what it comes up
[33:16] with.
[33:16] Good, but.
[33:17] 111's done.
[33:18] Let's.
[33:18] See.
[33:18] Oh, hey, here we.
[33:19] Go, I've been roof.
[33:20] Let's see.
[33:21] Now we're going OK, working.
[33:22] So you got.
[33:22] Actually coming out of my sessions already so.
[33:28] This is a full, like, full product.
[33:30] Other people are making features of a product, but you're
[33:32] doing the whole thing.
[33:33] No, no, no.
[33:34] But my HMD clearly says don't build a product we're
[33:37] building, otherwise it's like doing migrations.
[33:39] Right, you know what I want.
[33:41] That if I if I pivot, we need to throw
[33:42] everything out right?
[33:45] Yeah, you want to make this as messy as possible,
[33:47] this.
[33:47] One this is the my my favorite thing to tell.
[33:50] How many of you all did an Agents MD?
[33:53] Yeah, I didn't.
[33:54] Oh, you made an Agents MD as well.
[33:56] Awesome.
[33:57] Well, cool.
[33:58] I'm looking forward to seeing it, Harold.
[33:59] Good luck.
[34:00] Good luck to everybody.
[34:01] How are we doing?
[34:03] Are we going to be able to vote on this,
[34:04] or are we going to have to fall back to
[34:06] raising hands?
[34:07] I.
[34:07] Don't know.
[34:08] I don't know.
[34:09] So I was able to that's interesting.
[34:12] It's this 127.
[34:14] It's oh, because it's not public yet.
[34:15] Anyway, so I was able to make it so that
[34:17] when you click, it writes to the Jason file.
[34:20] And so Julia gets recorded one vote.
[34:22] And then I said implement the websock.
[34:23] It said that it did.
[34:24] So theoretically now like if we had two of these
[34:28] instances open.
[34:29] Can I just refresh that one there?
[34:30] Should be a way to like do this on Mac,
[34:32] right?
[34:32] You can put you can arrange windows on Mac, can't
[34:34] you?
[34:34] There we go.
[34:36] So this one here, let's just refresh.
[34:37] So in theory, let me make sure this is refreshed
[34:42] too.
[34:42] We should be, yeah.
[34:44] Oh, OK.
[34:46] Are we done?
[34:47] Let's let's just try it.
[34:48] Can we test it out?
[34:49] Can, yeah.
[34:49] You're going to have to.
[34:50] Well, no, I have to make it public first.
[34:51] It's not public yet, so let's go back here.
[34:54] This will.
[34:55] Be like, to be clear, for all the, you know,
[34:58] the technical people in the room, this is a trial
[35:01] run.
[35:01] This is not the final vote we're testing.
[35:04] Now OK, so the test before we redesign because I'm
[35:06] going to we're about to make this app pop.
[35:07] What do you want to do?
[35:08] Let's pop it.
[35:09] OK, don't.
[35:10] We're not testing it yet.
[35:11] So here's what we're going to do.
[35:12] I'm going to use Opus 4/6 and I'm I'm going
[35:14] to use a skill that I created that knows about
[35:17] my design aesthetic.
[35:18] And that aesthetic is called poster board.
[35:20] It's just what I call it.
[35:21] And it defines the color palette, it defines typography and
[35:24] it tells the AI to avoid specific things.
[35:27] So what I'm going to do now is I am
[35:30] going to say give me 10 mocks for this site.
[35:35] Put them in the same file.
[35:37] Use the poster board aesthetic.
[35:39] Can you tell it also to spawn multiple sub agents
[35:42] to do this so that it's not doing one at
[35:44] a time?
[35:44] Yes, we can.
[35:45] So what we well, it's writing the same file.
[35:49] I'll tell you what we'll try.
[35:51] So we're going to say use the poster board aesthetic.
[35:53] And I'm just going to point it because I don't
[35:55] have it installed here.
[35:56] Normally it's a skill, but it's just I'm just going
[35:58] to give it the gist.
[35:59] And then if we want to use multiple sub agents,
[36:01] all we need to do is a control A to
[36:03] go to the front.
[36:04] It is OK, It's just fleet.
[36:07] So there's a command and then the CL is job
[36:09] is not to figure out like which work can be
[36:12] parallelized here.
[36:13] Can we actually do this?
[36:15] And so yeah, that's what we're going to do.
[36:17] So I do this a lot when I'm designing.
[36:19] I'm like, give me 10 designs.
[36:20] I'll pick the one that I like the most and
[36:22] then I'll iterate on that one and say, give me
[36:24] another 10 and like whittle it down until I get
[36:26] to something that's fairly good.
[36:28] And just so you know what we're after here.
[36:30] Like if we go to.
[36:32] So let's go to not AI town.
[36:35] That was a fun experiment though, but like here's some
[36:37] of my projects like this is what the design is
[36:39] going to look like, right?
[36:40] It's the same any of my projects all look the
[36:42] same.
[36:43] Here's another one right?
[36:45] They all have this like similar aesthetic summer light, summer
[36:48] dark, same color schemes.
[36:49] So that's.
[36:49] What we're doing here, you have a way you like
[36:51] to do it, and I love it.
[36:53] Yes, I have my own sort of design system and
[36:55] I just keep reusing it everywhere and it all looks
[36:58] somewhat similar.
[36:59] Does anybody else do that same sort of thing?
[37:02] I do not and I think that's great.
[37:03] I'm going to, I'm going to borrow that.
[37:05] It's great.
[37:06] Like I was never talented enough before to do that,
[37:08] but but now I can.
[37:09] Now I'm now I'm a designer.
[37:11] Yeah, you just iterate with it like.
[37:12] I don't like the way that looks.
[37:13] Try again.
[37:14] Exactly.
[37:14] OK, so it actually did.
[37:16] It's sent off to an agent here.
[37:17] It's using a general purpose, so it looks like it
[37:20] could not parallelize or decided it couldn't.
[37:23] Probably because it's going to the same file.
[37:25] I think so, but I like it to be in
[37:26] the same file so you can see them all.
[37:28] Pick the one that we like the most.
[37:30] We got 7 minutes.
[37:32] Oof, it's close.
[37:34] Coming up on it.
[37:36] All right, what is what are we doing tonight, y'all?
[37:38] Is there a party or something?
[37:41] Where are we going?
[37:42] We're all in it together.
[37:44] Now, is there a movie we should go to?
[37:45] Yeah.
[37:46] Any exciting movies coming out right now?
[37:49] No.
[37:49] Nothing.
[37:50] Nobody's doing anything tonight.
[37:52] Are you kidding me?
[37:53] Come on.
[37:54] What did?
[37:54] You retired from The Chainsmokers thing yesterday.
[37:56] I didn't even get to see that was that good.
[37:58] It was pumping.
[37:59] I was loud.
[38:01] Tech check, Was it loud?
[38:02] Oh, it was great.
[38:03] Yeah, it was fun.
[38:04] I I don't know how many of you were up
[38:06] front, like right next to can you hear?
[38:08] How did you hear me say that?
[38:10] I don't know.
[38:10] It was so loud, but like I felt it in
[38:12] my chest.
[38:13] I wasn't even outside for some of it and I
[38:15] was like what is happening?
[38:16] That's wild.
[38:16] You know, I had no idea they were going to
[38:18] be here.
[38:19] And so during the keynote, I was backstage and I'm
[38:22] standing there by the stairs talking to Kayla, and there's
[38:25] this crowd of people around these two guys.
[38:28] And I've looked over and I'm like, who are these
[38:30] two guys standing right there?
[38:31] And then they went on the stage and like the
[38:33] chain smokers.
[38:35] What?
[38:36] I could have given them a Wi-Fi.
[38:38] Yeah, we could.
[38:39] Have taken a selfie.
[38:40] I could be famous now.
[38:41] All right, This is the this is the era we're
[38:44] in where we just watch agents cook.
[38:46] Yeah.
[38:46] This is what we do now, should we developer.
[38:49] Should we just like, hope and pray that this works
[38:51] and have them actually do their demos?
[38:54] Oh.
[38:54] It's going to work.
[38:55] So we could test.
[38:55] Let's test.
[38:56] Look, so let's go make this.
[38:59] Let's go make this public.
[39:02] Something's happening.
[39:04] Very exciting.
[39:06] Let's make it public port visibility.
[39:07] Public code spaces are amazing because you can like this.
[39:12] It's just so easy to OK, And then we need
[39:14] the URL because it's going to be a bit different.
[39:16] And then we'll give you a new QR code.
[39:19] OK, so you all want to try this.
[39:21] Let's zoom that out.
[39:22] OK.
[39:24] Oh, Julia's already got a vote.
[39:25] We probably better unvote.
[39:28] How do we?
[39:28] I guess we'll have to.
[39:29] Edit Oh no, we didn't think about that.
[39:31] Or or maybe box.
[39:32] Look at somebody really likes Harold.
[39:33] It's working.
[39:34] Who?
[39:34] What's?
[39:35] Happening.
[39:36] Is it working on your phones?
[39:37] Is like is the the numbers are updating for you?
[39:40] Am I getting yeses?
[39:41] Yes, you need a.
[39:43] You need a better visual.
[39:44] Wow, Julia's.
[39:45] But like Julia's, you can't vote for yourself.
[39:47] Is that you?
[39:49] Can you vote multiple times?
[39:51] I'm I'm betting that they won't let you vote multiple.
[39:53] Yeah, I wonder.
[39:54] If you refresh the page, you can probably vote again.
[39:57] Don't do that, no.
[39:58] No, I'm sure you can vote.
[39:59] You can just sit there and ham.
[40:00] Just go.
[40:01] Just go.
[40:01] OK, so now let's go back here and see if
[40:05] we got some mocks here.
[40:07] We're going to have to reset once they've actually been
[40:09] able to present their solutions.
[40:11] Is it still running?
[40:13] Oh and there we go.
[40:14] Oh OK, so we have mocks dot HTML has a
[40:16] mock.
[40:16] Whoa, what happened?
[40:19] Oh, it's up here, I see.
[40:22] Can we open that up?
[40:23] We should be able to.
[40:25] Am I right side or left side?
[40:26] I'm left side.
[40:28] Where is the file?
[40:30] It says it.
[40:31] It says it created it.
[40:33] Can you command me to?
[40:34] It I don't see it oh what happened?
[40:37] It reloaded, didn't reload.
[40:40] What is going on in my term?
[40:41] What is happening?
[40:42] Way, way old to go.
[40:43] Oh, hold on.
[40:44] Oh sorry, so I should be able.
[40:45] To there it is.
[40:46] It's right there, OK?
[40:47] It was just took a minute to show up.
[40:50] We need.
[40:50] 4 minutes, yes.
[40:53] So let's see here.
[40:55] So these are the mocks we got.
[40:57] Maybe, maybe please open open.
[41:02] I don't know what that button does.
[41:04] It's.
[41:04] Supposed to open a preview but it's not working all
[41:06] right.
[41:07] We may just have to run with it like it
[41:09] is.
[41:10] Let's see here.
[41:10] We could reload the editor.
[41:12] How could that possibly go?
[41:13] Wrong.
[41:13] You know what I would say is just.
[41:14] I would say choose the one you like best.
[41:17] Implement that one.
[41:18] Oh yeah, because we're we're not at 3 minutes.
[41:19] We got to go.
[41:20] Yeah, Should we have them present their ideas?
[41:24] All right, 20 seconds.
[41:25] 20 seconds, y'all.
[41:27] Let's start with Julia.
[41:31] All right, Julia, throw.
[41:33] Up the voting.
[41:34] Let's see what we got.
[41:36] So very simple minimalistic UI.
[41:38] I have it in split screen, so you can rename
[41:41] your works bit, whatever, whatever you want to do, you
[41:45] can easily add a new file.
[41:47] And the fun thing I implemented you want to change
[41:50] your name, you also want to add some kind of
[41:52] also bring in the vibe and change the different emojis
[41:56] that you have.
[41:57] I also the latest like the last feature I implemented,
[42:00] I want to track edits.
[42:02] So if.
[42:02] You click this.
[42:03] I want to see who made these edits and how.
[42:06] And then last but not least, you can share easily
[42:08] share the link.
[42:09] That is great.
[42:10] Julia here.
[42:10] Let's give it up for Julia.
[42:12] Awesome.
[42:14] OK, Chris, what do we got here now?
[42:17] So we've got the editor, we've got a little bit
[42:19] of a sidebar now as well, so we can go
[42:21] and make some additional files.
[42:22] There we go.
[42:23] We see that go to start a new file over
[42:25] there and you know, we've got like our wizzy wig
[42:28] kind of editor over here as well and started making
[42:31] it a little bit like GitHub theme.
[42:32] So using the GitHub Primer library.
[42:34] So kind of halfway through that, I've got an agent
[42:36] using Playwright in the background to start assessing what they
[42:40] look like.
[42:40] So they can kind of assess, huh?
[42:42] We've probably missed a package somewhere along the way.
[42:44] So we need to go.
[42:44] I'm wearing Playwright socks, right?
[42:46] There we go.
[42:47] So that's cool.
[42:48] Yeah.
[42:49] And we've got these little kind of tiles up the
[42:51] top as well to represent each of the users.
[42:54] And we're starting in the background to go and get
[42:56] some like user avatar type things in there as well.
[42:58] Love that awesome job, Chris.
[42:59] Let's give it up for Chris.
[43:03] Hey, Pierce, how is it going?
[43:05] You know what?
[43:06] I just realized I should have started with Harold because
[43:08] every time he's been the last one, he's had all
[43:10] this time to prepare.
[43:11] I know.
[43:11] Oh well.
[43:12] Well, Speaking of time to prepare.
[43:14] You tried to warn me, Kent.
[43:16] You tried to warn me.
[43:17] Did you at least commit so you could go back?
[43:20] Oh, it's working now.
[43:21] Oh, my API finally booted.
[43:23] Like literally when you're talking to Chris, it didn't work
[43:25] at all.
[43:25] I was like, I've added emojis and regressed all the
[43:28] functionality.
[43:29] So look at this UX.
[43:30] You can select text and you too can scroll halfway
[43:33] down a page and hit that you love that and
[43:35] then scroll.
[43:36] Back.
[43:36] Oh OK, we got comments.
[43:38] So we have, we're getting there.
[43:39] We got some comments, but you know, I'm not winning
[43:42] any awards for design here.
[43:44] Yeah, well, you know Chris, he's got the help of
[43:47] the GitHub design library and everything.
[43:50] True.
[43:50] You could probably jump in with that.
[43:52] I don't know.
[43:52] I think it looks like.
[43:54] It's serviceable.
[43:54] It's serviceable.
[43:55] Good job.
[43:56] Let's go hear it up for Pierce and Harold with
[43:59] one minute left.
[44:01] You got 20 seconds.
[44:02] What we got?
[44:02] It's working my pitch check right now.
[44:04] So if you to get funny, we are in San
[44:07] Francisco, so.
[44:08] Yeah, you got to sell it.
[44:08] Presence history.
[44:09] No, actually let me show.
[44:10] So we have 22 versions.
[44:12] So with one, the reading room powered by all the
[44:15] plan MD that I already have locally.
[44:18] So just discovers it actually if I refresh, we see
[44:20] it's reading all the sessions.
[44:21] It's actually working.
[44:22] So this is actually the plan that built this prototype.
[44:25] So I'm looking at the plan and going to edit
[44:28] mode.
[44:28] So I think the life editing and Google Docs, I
[44:30] don't want to edit markdown anymore.
[44:32] I want my agent to edit markdown.
[44:33] So it's more more around quick actions and commenting.
[44:36] The other prototype actually ended up like this where you
[44:39] have a commenting and an activity log more to like
[44:42] Google Docs historically.
[44:43] And then you can quickly comment and like make this
[44:47] pop, which I'm a product manager, so I don't have
[44:50] words so but it can also do quick Proms and
[44:53] it has like suggestions built in.
[44:55] So this is.
[44:56] It's feature full.
[44:57] And none of these repos exists, but this is more
[45:00] prototype.
[45:02] Cool, and you have two implementation, but you had three
[45:04] working on it.
[45:04] One of them just didn't make it.
[45:06] That's a good question.
[45:07] I think the three designs ended up being merged into
[45:10] one.
[45:11] One was another prototype that I have.
[45:14] Some are open as well.
[45:15] Yes, so this is cool.
[45:16] Yeah, well, let's hear for Harold, everybody.
[45:19] Awesome.
[45:21] OK, we are -23 seconds left.
[45:24] We're over.
[45:25] It's time to vote.
[45:26] I see people are already voting.
[45:28] I'm trying to pull it up here.
[45:29] Let's see if we go to my ports.
[45:30] This is public.
[45:31] It's going to port 4000 here.
[45:35] Loading it up.
[45:37] Whoa.
[45:37] All right.
[45:38] Oh, Harold.
[45:39] Harold.
[45:39] Harold's in the lead.
[45:40] How do we know?
[45:41] When do we stop it?
[45:42] I've got to give you some people come out.
[45:44] You leave when you're ready to go when when you
[45:47] care less than the other people who want to.
[45:50] Chris I love you so much man, but go vote
[45:52] for Chris y'all.
[45:53] I feel like no.
[45:54] All right, who?
[45:55] Who made the script?
[45:56] Declare a winner at this.
[45:58] Point.
[45:58] I think we're going to have to say it was
[45:59] Harold.
[45:59] He won in his heart and with the votes.
[46:02] Very nice.
[46:02] Give our contestants a round of applause.
[46:07] It's not easy to code in front of adoring fans.
[46:10] Thank you all so much for being here.
[46:13] We got a couple of sessions for you that you
[46:15] might want to know about next.
[46:16] What do we got these coming up here online in
[46:20] person?
[46:20] What do we have?
[46:21] MCP GitHub copilot.
[46:23] More GitHub copilot, right.
[46:25] Every time you hear the word copilot, do something.
[46:28] I don't know.
[46:28] All right, I hope to see you all tonight.
[46:30] I hope we're doing something fun.
[46:32] Thank you for being with us today.
[46:34] And yeah, some recommended resources for you.
[46:37] Thank you so much.
[46:37] Appreciate y'all.
[46:38] See ya.