# Gadgets: Personal app vibe coding that is actually safe

Kenton Varda

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/RmS5s6Wbin4-gadgets-personal-app-vibe-coding-that-is) · [Video](https://www.youtube.com/watch?v=RmS5s6Wbin4)

## Gadgets: Personal app vibe coding that is actually safe

When an agent can change an app for one person, deployment and permissions must change too. Gadgets makes each app a shareable unit with its own code and confined execution.

Familiarity with browser iframes, client–server applications, and basic JavaScript will help with the isolation architecture.

### The feature request that becomes a rewrite

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

What happens when an app works for almost everyone, but lacks the feature that makes it useful to you? AI could let you add that feature yourself. The harder question is where your modified app would run. **Personal AI code generation challenges infrastructure built to give every user the same application.** The word *personal* is the crucial part: generating another centrally hosted product does not solve the problem of modifying your own copy.

![Dark slide with the statement “Personal AI codegen breaks traditional cloud infrastructure,” with “breaks” emphasized in red.](https://ai.engineer/api/talk-essay-media/7bb54cf8e0ccf4d85c48cfed6f39a4dbef6e7a2a3a321449dbe143983a006a49)

Personal AI codegen breaks traditional cloud infrastructure.

Kenton Varda starts with a familiar development cycle. A developer builds an app and distributes it to users. Some need additional features, so they submit requests. A product manager files those requests in Jira, where most disappear. Occasionally, a request matches something the product manager wants, and it reaches the roadmap.

As those features accumulate, each serves a small subset of users while adding conditionals to the shared codebase. The developer proposes a rewrite with a plug-in architecture: features can become extensions, and the core can stay clean. But new requests must now wait for the architecture. Implementing them first would supposedly waste work. Years pass, the rewrite remains unfinished, and users conclude that the product has been abandoned.

AI offers another distribution of the work. The developer supplies an initial app; each user's agent adds the features that person needs. Users do not inherit everyone else's special cases, and the original developer can preserve a small core. That possibility depends on users being able to run different code, not merely request different settings in one shared program.

### The web opens publishing, but centralizes execution

[4:03](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=243s)

Mobile platforms put an obstacle before execution even begins: installing software outside the approved distribution system. Varda delivers this as a polemic about Apple and Google's gatekeeping, exaggerating the remaining developer population down to five companies and comparing access to unsigned software with buying a gun in the United States. His imagined Google representative tells the user to return after a day of reflection. This is satire about control over one's device, not an installation procedure.

The web provides an escape: anyone can publish an application. Varda points to that openness as a counterexample to the claim that independent distribution must produce a security disaster. Yet web hosting introduces a different constraint. The developer runs one approved version on a server, and every user's requests go to it. Central updates are convenient precisely because users do not control their own running versions.

Many vibe-coding platforms make web apps because the web is an accessible target, but retain that centralized deployment model. They make producing an application easier without changing who controls its execution. Personal customization needs both: the ability to generate a change and an infrastructure boundary within which that change belongs to one user or group.

### The presentation is already a personal app

[6:22](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=382s)

The presentation itself contains a small example of agent customization. **Claude** made the word “breaks” wiggle, alongside its red color and underline. Varda kept the animation because he found it absurd, joking that this unexpected design choice must be an original contribution from AI—and therefore evidence of superintelligence.

[Kenton Varda](https://lanparty.house/) then introduces his connection to the infrastructure problem: he started Cloudflare Workers in 2017 and identifies himself as its continuing lead engineer. Varda reports that Workers has millions of developers and serves trillions of requests per day. Those are his platform-scale figures; the talk supplies no counting definition or measurement interval. His experiment here is a side project built on Workers, and the presentation the audience has been watching is an app created inside it.

### An Office suite where every item has code

[8:04](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=484s)

The Gadgets home screen begins with a familiar prompt box. Varda enters: “Make a silly counter app. Silly max it.” Generation returns an error, which he attributes to the internet connection. The recording does not show a successfully generated counter; he moves on to the existing applications.

The useful analogy is an Office suite. In Google Docs, you might have hundreds of documents that you open, edit, and share. Here, the items are **gadgets**, and each is an application containing its own code. Two items in the same workspace can therefore behave like entirely different applications, rather than different documents interpreted by one fixed editor.

![Gadgets workspace showing “What are we working on?” above a prompt box and a “Your gadgets” list on the right.](https://ai.engineer/api/talk-essay-media/4dcac7f9a92f1198e48b9ee35a91f7d922a7a62e373273def4e522af3852c1b2)

The Gadgets home screen pairs a prompt box with a list of existing gadgets.

Varda's examples make the range concrete:

- **Collaborative whiteboard:** an app he describes as generated from one prompt.
- **Spanish-email filtering:** a personal tool for handling messages in a language he does not know.
- **Pull-request sorting:** a gadget for organizing GitHub reviews he needs to complete.

These are small tools shaped around particular work, managed together like documents.

### Reuse the code, share the instance

[9:44](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=584s)

A useful gadget can become a **blueprint**: export its code without its data, then let someone else instantiate a new gadget from that code. The distinction is small but essential.

| Unit | Contains | Purpose |
| --- | --- | --- |
| Blueprint | Reusable application code | Start another gadget |
| Gadget | An application's code and its own data | Do and share particular work |

For example, the export boundary can be expressed in JavaScript by explicitly selecting code rather than serializing the entire gadget:

```javascript
function exportBlueprint(gadget) {
  return { code: structuredClone(gadget.code) };
}

const deck = {
  code: { "app.js": "export const title = 'Slides';" },
  data: { slides: [{ title: "Private planning" }] }
};

const blueprint = exportBlueprint(deck);
console.assert(!Object.hasOwn(blueprint, "data"));
```

The function illustrates the code/data distinction; the private slide content stays out of the exported object.

The workspace includes blueprints for a document editor, a Kanban board, and a slide builder. Varda instantiates the slide builder, which his Cloudflare colleague Philip, a product manager, had built—Varda believes—in an afternoon. The result is an editable deck.

**One slide-builder gadget contains one slide deck.** Creating another deck means creating another gadget instance. That choice aligns the application boundary with the thing users want to share. A Google Docs-style dialog creates a share link, while the platform implements collaboration permissions and access control. The generated slide application does not have to decide which of many decks a visitor may access; that decision belongs outside its code, at the gadget boundary.

### Making slides can also mean changing the editor

[11:40](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=700s)

Varda switches to another instance of the slide app containing his original, discarded talk deck. He blames the deck's shortcomings on his own content, not Philip's software. Opening its conversation reveals how it was made: every app in the platform integrates with agents, and Varda had given Claude a Google Doc describing the slides he wanted. He also explicitly permitted it to add features to the slide app if the deck required them.

Claude read the application code and the document, then identified a missing capability: slide three needed strikethrough formatting. It added support rather than forcing the slide to fit the existing editor.

![A conversation pane with a bulleted response appears beside a slide titled “Personal app vibe coding that is actually safe.”](https://ai.engineer/api/talk-essay-media/4ee5a0f29baf47586c8f74e4f4dd9abc8cae0e12bfd49a408a58c4e784fa6c07)

Agent conversation beside the slide application's presentation preview.

Other slides needed centered text, so Claude added that too. Slides five and six posed a more interesting problem: Varda wanted an arbitrary drawing of a cloud, while the editor supported boxes and arrows rather than free-form diagrams. Claude added an SVG insertion field and then generated the SVG to put into it. The new interface was not especially convenient for a human author, but it was exactly usable by the agent that had created it. **The agent changed both the document and the tool needed to produce the document.**

### Confining both halves of the application

[14:03](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=843s)

Allowing raw SVG raises an immediate security question: SVG can contain JavaScript. If the agent has introduced a cross-site scripting vulnerability, what can the injected code reach? Varda's answer depends on confinement around the whole application, not on trusting the generated editor to sanitize every input correctly.

The communication path crosses several boundaries:

1. **Sandboxed client:** the gadget UI runs in a null-origin iframe. Varda describes a Content Security Policy that prevents outside communication and access to cookies.
2. **Parent-frame channel:** the client can use `postMessage` to communicate with its parent. A [Cap'n Web](https://github.com/cloudflare/capnweb) RPC session carries calls through that channel, onward through the server, and into the gadget's server code.
3. **Sandboxed server:** that code is a Durable Object on Cloudflare Workers, running in a dynamic worker sandbox that also prevents outside communication.

The generated client and server can communicate with each other and produce the user's interface, without receiving unrestricted access to the surrounding world.

Varda makes the sweeping claim that security bugs in this code do not matter because they cannot leak data out of the confined environment. The supported architectural lesson is narrower: **a generated-code bug need not grant authority beyond the gadget's existing boundary.** The platform's isolation, communication channels, and granted capabilities still have to hold. Network confinement is configuration-dependent: the current [Dynamic Workers API](https://developers.cloudflare.com/dynamic-workers/api-reference/) documents `globalOutbound: null` as blocking `fetch` and `connect`; omitting it inherits the parent's networking. That current API detail explains the requirement without establishing the prototype's exact configuration.

### Local execution and deliberate external access

[15:44](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=944s)

Useful personal tools eventually need to reach outside their sandbox. Varda says the platform includes a system for safe access to external services, but leaves its mechanism for another talk. The recording therefore establishes that integration is part of the design without explaining its permission protocol.

Everything shown except the LLM is built on Workers. There are no containers: dynamic workers execute the application code, and Durable Objects provide persistence. Varda's description of having no database is best understood here as avoiding a separately operated database service, not as claiming that persistence involves no database technology. The environment is running locally on his laptop, which explains why existing gadgets remain usable after the online generation request fails.

Local execution uses [workerd](https://github.com/cloudflare/workerd), the open-source Workers runtime, which can also be self-hosted. Self-hosting untrusted code requires care: the runtime's documentation warns that `workerd` alone is not a hardened sandbox and needs additional isolation against implementation bugs. Varda's motivation is concrete: the platform has Home Assistant and Spotify connectors, and he wants to run it in his basement for home automation.

### From a side project to a deliberate release

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

The talk ends with a change to the original release plan. When Varda submitted the proposal, Gadgets was a side project he intended to put on GitHub immediately after presenting it, so attendees could download and experiment with it. Interest inside Cloudflare subsequently made it a more serious project.

Varda recounts CTO Dane asking him to delay the release for a few weeks and handle it more deliberately. He apologizes that the promised open sourcing is not happening that day, while saying it will happen soon. That is the Gadgets prototype's status at the end of this recording, distinct from the already open-source `workerd` runtime beneath it. The proposed unit of personal software is nevertheless visible: an app whose code can change with its task, whose data belongs to one shareable instance, and whose authority is enforced by the platform around it.

## Resources

- [Cloudflare OS launch announcement](https://blog.cloudflare.com/cloudflare-os/) — The August 2026 release introduces personal apps, blueprints, resource permissions and Gatekeepers for external services.
- [Cloudflare OS source code](https://github.com/cloudflare/cloudflare-os) — Open-source platform for creating and sharing Gadgets, with reusable Blueprints and controlled service integrations.
- [Cap'n Web](https://github.com/cloudflare/capnweb) — JavaScript and TypeScript object-capability RPC supporting browser postMessage, WebSocket and HTTP connections.
- [workerd](https://github.com/cloudflare/workerd) — Open-source Workers runtime for local development and self-hosting, including configuration examples and sandboxing cautions.
- [Dynamic Workers API reference](https://developers.cloudflare.com/dynamic-workers/api-reference/) — API for loading code dynamically and explicitly controlling its outbound network access.
- [Durable Object Facets](https://developers.cloudflare.com/dynamic-workers/usage/durable-object-facets/) — How dynamically loaded Durable Objects receive separate persistent storage within a parent object's lifecycle.

## Slides

### Creating the keynote slide

The speaker shows the keynote slide as an app created on the platform. Its editor pairs the prompt with a dark preview that highlights “breaks” in red.

[7:54](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=474s) [A gadget editor shows a prompt and response beside the generated keynote slide.](https://assets.ai.engineer/sites/aiecode2025/sha256/546615f2190f07044ff77dd787ca1cac6c643680a0fb9082af938cfd65c593d2.webp)

Personal AI codegen
breaks traditional
cloud infrastructure.

Prompt:
Make a simple web page -- intended to be presented as a single slide while giving a conference talk -- which says: "Personal AI codegen breaks traditional cloud infrastructure." The word "breaks" should stand out between the two noun phrases.

I'll create a single-slide page with that statement, making "breaks" stand out.

Wrote 2 files
client.js · server.js

Done. Here's your conference slide.

It displays the line centered on a dark radial-gradient background, with “breaks” standing out between the two phrases:
• Rendered in red with a glow
• Slightly tilted with a jagged “crack” underline
• A subtle periodic shudder animation (disabled if the viewer prefers reduced motion)

The text scales responsively (clamp + viewport units), so it fills the screen whether you're on a laptop or projecting full-screen. Let me know if you'd like a different color, no animation, a subtitle/speaker line, or a light-background version.

Interface text:
Jun 30 5:52 PM
Personal AI codegen bre…
localhost:3000/gadget/[illegible]?chat=0
Personal AI codegen breaks traditional cloud infrastructure
Opus 4.8
Gadget  Code  Connections  Activity
$0.25
Accept changes to save them to the gadget.
Accept changes
Ask a follow-up...
Add resource
Claude Opus 4.8
9,825 tokens  $0.0994
localhost:3000

### Slide Builder Blueprint

Philip’s Slide Builder blueprint needs no connections to create a gadget. The presenter explains that each gadget instance holds one slide deck.

[10:22](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=622s) [The Gadgets Slide Builder blueprint page offers a button to create a gadget.](https://assets.ai.engineer/sites/aiecode2025/sha256/995d3896b4f11aede5cfe1fb32231858df46ad7d66c6d018218950318a5f5c7f.webp)

Gadgets Slide Builder

Build slide decks with Cloudflare style interactively or with natural language. Once you create your own gadget, add connections to build slides with text and charts powered by real data. Slide builder gadget inspired by let-it-slide.

By Philip · v4 · Updated 5/29/2026

Create Gadget

No connections required
This blueprint can create a Gadget without configuring external resources.

Interface text:
Jun 30 5:55 PM
gadgets
Home
Gatekeepers
Explore
Back
localhost:3000/blueprint/[illegible]

### Slide Builder Presentation

After instantiating the Slide Builder, the presenter opens a three-slide deck. Each gadget instance holds one deck; multiple decks require multiple instances.

[10:40](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=640s) [The slide builder displays an introductory slide about composing a deck from primitives.](https://assets.ai.engineer/sites/aiecode2025/sha256/db2d12e966fe486304944b36769a2c081ab1c2b4a7c8bda999753bd1fb2c8aa5.webp)

SLIDE BUILDER

gadgets

Compose your deck from primitives.

Press E to edit. Add slides, drop in components, drag to move, then F to present.

Interface text:
Jun 30 5:55 PM
Gadgets Slide Builder
localhost:3000/gadget/[illegible]
All conversations
No conversations yet
Gadget
Code
Connections
Activity
Start a new conversation...
Add resource
GPT 5.5
$0
1 / 3

### Editing a Slide

The slide editor shows a selected blue card alongside its editable properties. The speaker explains that each gadget instance holds one slide deck; multiple decks require multiple instances.

[10:45](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=645s) [The slide editor shows slide thumbnails, a selected blue card, and card properties.](https://assets.ai.engineer/sites/aiecode2025/sha256/abf9f7b3d75de745c37cdcf86f1e1a1f5bb22afc01f8076746a5425c4b66d3f5.webp)

COMPONENTS
Cards come in tones.
Each card carries a tone, an optional top stripe, an [illegible]

01
Composable
Every slide is just a list of blocks.

02
Themed
Tones, fonts and spacing come from one set of tokens.

[illegible]

04
Yours
Add or remove slides, drag blocks anywhere on the canvas.

Interface text:
Jun 30 5:56 PM
Gadgets Slide Builder
localhost:3000/gadget/[illegible]
All conversations
No conversations yet
Gadget  Code  Connections  Activity
Search slides
01
Compose your deck from primit...
02
Cards come in tones.
03
Boxes and arrows, no Figma re...
Add slide
Add component
TEXT
Title — Display headline
Subtitle — Supporting copy
Text block — Free-form text
Section label — Section eyebrow
CONTAINERS
Card — Tonal card
Diagram box
SLIDE
Page color  #f5f1eb
Dot grid  0
Inset surface
Card
SELECTED
Tone  blue
Top stripe
Eyebrow  02
Title  Themed
BODY
Tones, fonts and spacing come from one set of tokens.
ADVANCED
2 / 3
Start a new conversation...
Add resource
GPT 5.5

### Sharing a Gadget

Varda opens the slide deck’s sharing dialog, which offers invitations and a share link. He says the platform handles sharing and access control for each gadget.

[11:17](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=677s) [A sharing dialog offers an invitation field and a share-link option over the slide editor.](https://assets.ai.engineer/sites/aiecode2025/sha256/27dcba4d6aca521675fca6103785cf1b0d5e7379fa1077e7a939216f8d98bb98.webp)

Share “Gadgets Slide Builder”
Invite people or share a link.

Username or email
Can use
Invite

Create a share link

People with access
Kenton Varda (you)
kenton
Owner

Slide canvas:
Each card carries a tone, an optional top stripe, an [illegible]
01
Composable
[illegible]
02
Themed
Tones, fonts and spacing come from one set of tokens.
04
Yours
[illegible]

Interface text:
Jun 30 5:56 PM
Gadgets Slide Builder
localhost:3000/gadget/[illegible]
All conversations
No conversations yet
Gadget
Code
Connections
Activity
Search slides
Cards come in tones.
Add slide
2 / 3
Add component
TEXT
Title
Subtitle
Text block
Section label
CONTAINERS
Card
Diagram box
SLIDE
Page color
#f5f1eb
Dot grid
0
Inset surface
Card
SELECTED
Tone
blue
Top stripe
Eyebrow
02
Title
Themed
BODY
Tones, fonts and spacing come from one set of tokens.
ADVANCED
Start a new conversation...
Add resource
GPT 5.5

### Gadgets Talk Deck

Varda opens the conversation behind his talk deck. He asked an agent to turn his notes into slides and allowed it to add features to the slide app when needed.

[11:42](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=702s) [A separate slide deck displays the title “Personal app vibe coding that is actually safe.”](https://assets.ai.engineer/sites/aiecode2025/sha256/5f8d0d6007d15ab9b41c56a8c4234e22b1ac31e8e30b565d050f6fd8857f8ce3.webp)

gadgets

Personal app vibe coding that is actually safe.

Kenton Varda
Architect and Lead Engineer
Cloudflare Workers, Cap'n Proto/Web, Sandstorm.io

Interface text:
Gadgets AIE talk
All conversations
EARLIER
Creating Talk About Gadgets Slide Deck
Jun 16 · $5.0023
Gadget · Code · Connections · Activity
1 / 15
Start a new conversation...
Add resource
GPT 5.5

[12:11](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=731s) [A slide deck app displays its title slide beside a conversation requesting slides from talk notes.](https://assets.ai.engineer/sites/aiecode2025/sha256/012680ee602e7ca01602a3a2f8f7eb337e6ae54bf393aad2ae4534a17f9b34a9.webp)

gadgets

Personal app vibe coding that is actually safe.

Kenton Varda
Architect and Lead Engineer
Cloudflare Workers, Cap'n Proto/Web, Sandstorm.io

Interface text:
Gadgets AIE talk
Creating Talk About Gadgets Slide Deck
Gadget · Code · Connections · Activity

I'm developing a talk about Gadgets. I've written out the list of slides in this doc: Gadgets talk notes. The gadget you're looking at right now is a slide deck app. I'd like you to append slides to the deck matching the list in the doc. Note that the dec currently contains the default example slides; I'll delete those later, just append the new slides after them. Consider the example slides as a style guide (though I realize there's not a lot in them). If you need to add any new features to the slides app itself to support some of the slides, feel free to do so. If you aren't sure how to do handle a particular slide, stop and ask me questions.

I'll start by reading the current state of the project and the talk notes doc.
Read 3 files, inspected 1 binding
server.js · client.js · README.md · 0 bindings

I'll read the talk notes doc now.
Ran code export default async function(self, env, ctx) {, read 1 resource
export default async function(self, env, ctx) { · Gadgets talk notes

Keep going.

Now I understand the structure. Let me look at the talk notes again carefully and plan.
The deck currently has 3 example slides. I need to append 14 slides matching the doc.
Most map onto existing components, but a few need new capabilities:

1 / 15
Ask a follow-up...
Add resource
Claude Opus 4.8
98,766 tokens · $5.0023

### Agent updates the slide app

The agent reports adding centered and strikethrough titles and a stamp component, then appending 14 talk slides to the three examples.

[13:00](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=780s) [The conversation lists needed slide features and reports that slides were appended, beside the deck's title slide.](https://assets.ai.engineer/sites/aiecode2025/sha256/7920569358de8003f48afc94e2e54f1797d04c8766c2aa34346e9330aad575da.webp)

gadgets

Personal app vibe coding that is actually safe.

Kenton Varda
Architect and Lead Engineer
Cloudflare Workers, Cap'n Proto/Web, Sandstorm.io

Conversation:
Ran code export default async function(self, env, ctx) {, read 1 resource
export default async function(self, env, ctx) { · Gadgets talk notes

Keep going.

Now I understand the structure. Let me look at the talk notes again carefully and plan.

The deck currently has 3 example slides. I need to append 14 slides matching the doc. Most map onto existing components, but a few need new capabilities:

• Slide 3 ([strikethrough: 2030] → 2027) needs strikethrough in a title — not currently supported.
• The hero/question slides read best centered — titles are left-aligned only.
• Slide 10 needs a "SOLVED" rubber stamp overlay — no such component.
• Slides 5 & 6 are cloud/server/user diagrams — cleanest as authored SVG blocks.

Let me make these app changes first, then append the slides. I'll start with the title component (add strike + align) and a new stamp component.

Edited client.js

The app now supports strikethrough/center titles and a stamp component. Now let me append the 14 slides to the deck via the GADGET binding.

Ran code export default async function(self, env, ctx) {
Used the gadget

14 slides appended (now 17 total: the 3 examples plus the 14 talk slides). Let me update the README to document the new component and title capabilities.

Edited README.md

Let me verify the appended slides stored correctly (especially the diagram markup and the new title props).

Interface text:
Jun 30 5:58 PM
Gadgets AIE talk
Gadgets talk notes
localhost:3000/gadget/[illegible]?chat=0
Creating Talk About Gadgets Slide Deck
Gadget  Code  Connections  Activity
Ask a follow-up...
Add resource
Claude Opus 4.8
98,766 tokens  $5.0023
1 / 15

### Today's cloud

A server inside the cloud connects to six users. Varda says Claude generated the SVG after the slide app lacked support for arbitrary drawings.

[13:27](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=807s) [A cloud containing a server connects by lines to six user icons.](https://assets.ai.engineer/sites/aiecode2025/sha256/ef57596f59c873a6dcdda7236aadad055f1c70a571646317343944b340c44dc6.webp)

TODAY'S CLOUD

THE CLOUD

Interface text:
Jun 30 5:58 PM
Gadgets AIE talk
Gadgets talk notes
localhost:3000/gadget/[illegible]?chat=0
Gadgets AIE talk
$5.00
Creating Talk About Gadgets Slide Deck
Gadget  Code  Connections  Activity
Ran code export default async function(self, env, ctx) {, read 1 resource
export default async function(self, env, ctx) { · Gadgets talk notes
Keep going.

Now I understand the structure. Let me look at the talk notes again carefully and plan.

The deck currently has 3 example slides. I need to append 14 slides matching the doc.
Most map onto existing components, but a few need new capabilities:
• Slide 3 (2030 [struck through] 2027) needs strikethrough in a title — not currently supported.
• The hero/question slides read best centered — titles are left-aligned only.
• Slide 10 needs a "SOLVED" rubber stamp overlay — no such component.
• Slides 5 & 6 are cloud/server/user diagrams — cleanest as authored SVG blocks.

Let me make these app changes first, then append the slides. I'll start with the title component (add strike + align) and a new stamp component.

Edited client.js

The app now supports strikethrough/center titles and a stamp component. Now let me append the 14 slides to the deck via the GADGET binding.

Ran code export default async function(self, env, ctx) {
Used the gadget

14 slides appended (now 17 total: the 3 examples plus the 14 talk slides). Let me update the README to document the new component and title capabilities.

Edited README.md

Let me verify the appended slides stored correctly (especially the diagram markup and the new title props).

Ask a follow-up...
Add resource
Claude Opus 4.8
98,766 tokens  $5.0023
6 / 15

### Editing the cloud diagram

The editor places Claude-generated SVG on the slide: a cloud server connects to six users. The presenter says the app UI runs in a null-origin iframe sandbox with a restrictive Content Security Policy.

[13:45](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=825s) [The slide editor shows the selected cloud diagram and an SVG markup field.](https://assets.ai.engineer/sites/aiecode2025/sha256/5be0aaefafc6ab1607081e3c73e9688d508f383e06169eca76b8bb80d54f9ec8.webp)

TODAY'S CLOUD
THE CLOUD

Interface text:
Gadgets AIE talk
Creating Talk About Gadgets Slide Deck
Gadget  Code  Connections  Activity

Keep going.

Now I understand the structure. Let me look at the talk notes again carefully and plan.

The deck currently has 3 example slides. I need to append 14 slides matching the doc. Most map onto existing components, but a few need new capabilities:
• Slide 3 (2̶0̶3̶0̶ 2027) needs strikethrough in a title — not currently supported.
• The hero/question slides read best centered — titles are left-aligned only.
• Slide 10 needs a "SOLVED" rubber stamp overlay — no such component.
• Slides 5 & 6 are cloud/server/user diagrams — cleanest as authored SVG blocks.

Let me make these app changes first, then append the slides. I'll start with the title component (add strike + align) and a new stamp component.

Edited client.js

The app now supports strikethrough/center titles and a stamp component. Now let me append the 14 slides to the deck via the GADGET binding.

Ran code export default async function(self, env, ctx) { }
Used the gadget

14 slides appended (now 17 total: the 3 examples plus the 14 talk slides). Let me update the README to document the new component and title capabilities.

Edited README.md

Let me verify the appended slides stored correctly (especially the diagram markup and the new title props).

Search slides
01  Personal app vibe coding that...
02  How will people interact with [illegible]
03  How will people interact with [illegible]
    NOBODY KNOWS
04  How will people interact with [illegible]
05  How will people interact with [illegible]
    Personal apps(?)
+ Add slide
6 / 15

Add component
TEXT
Title — Display headline
Subtitle — Supporting copy
Text block — Free-form text
Section label — Section eyebrow
CONTAINERS
Card — Tonal card
Diagram box
SLIDE
Page color  #f5f1eb
Dot grid  0
Inset surface
SVG  SELECTED
SVG MARKUP
<svg viewBox="0 0 1000 440" xmlns=[illegible]
<path transform="translate(290,28) [illegible]
<line x1="120" y1="356" x2="500" y[illegible]
<line x1="272" y1="356" x2="500" y[illegible]
<line x1="424" y1="356" x2="500" y[illegible]
<line x1="576" y1="356" x2="500" y[illegible]
[illegible]
Fit  contain
ADVANCED

Ask a follow-up...
Add resource
Claude Opus 4.8

### Gadget server code

The gadget server is a Cloudflare Durable Object. The speaker says it runs in a sandbox isolated from the outside world, while an RPC channel connects it to the client.

[14:52](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=892s) [The code tab displays a server file with a Durable Object class and undo and redo methods.](https://assets.ai.engineer/sites/aiecode2025/sha256/dd1007b4d7e799b11f6641048a35c45ccbf52ced130c82d070034ea90b481380.webp)

server.js

 * (future) easy.
 */

const STORAGE_KEY = "deck";
const MAX_UNDO = 50;

export class Gadget extends DurableObject {
  constructor(state, env) {
    super(state, env);
    this.state = state;
    this.subscribers = new Set();
    // Undo/redo stacks live in memory only — they're transient and
    // shared across every connected client (one global history for the
    // whole deck). On DO restart history is lost, which we consider
    // acceptable. Each entry is a full deck snapshot (deep clone).
    this.undoStack = [];
    this.redoStack = [];
  }

  // -------- undo / redo ----------------------------------------
  async getUndoState() {
    return {
      canUndo: this.undoStack.length > 0,
      canRedo: this.redoStack.length > 0,
    };
  }

  async undo() {
    if (this.undoStack.length === 0) return false;
    const prev = this.undoStack.pop();
    const current = await this.state.storage.get(STORAGE_KEY);
    if (current) this.redoStack.push(current);
    await this.state.storage.put(STORAGE_KEY, prev);
    await this.#broadcast(prev);
    return true;
  }

  async redo() {
    if (this.redoStack.length === 0) return false;
    const next = this.redoStack.pop();
    const current = await this.state.storage.get(STORAGE_KEY);

Interface text:
Jun 30 6:00 PM
Gadgets AIE talk
Creating Talk About Gadgets Slide Deck
Gadget  Code  Connections  Activity
FILES
README.md
client.js
server.js

Ran code export default async function(self, env, ctx) {, read 1 resource
Keep going.

Now I understand the structure. Let me look at the talk notes again carefully and plan.

The deck currently has 3 example slides. I need to append 14 slides matching the doc. Most map onto existing components, but a few need new capabilities:
• Slide 3 (2030 [illegible] 2027) needs strikethrough in a title — not currently supported.
• The hero/question slides read best centered — titles are left-aligned only.
• Slide 10 needs a "SOLVED" rubber stamp overlay — no such component.
• Slides 5 & 6 are cloud/server/user diagrams — cleanest as authored SVG blocks.

Let me make these app changes first, then append the slides. I'll start with the title component (add strike + align) and a new stamp component.

Edited client.js

The app now supports strikethrough/center titles and a stamp component. Now let me append the 14 slides to the deck via the GADGET binding.

Ran code export default async function(self, env, ctx) {
Used the gadget

14 slides appended (now 17 total: the 3 examples plus the 14 talk slides). Let me update the README to document the new component and title capabilities.

Edited README.md

Let me verify the appended slides stored correctly (especially the diagram markup and the new title props).

Ask a follow-up...
Add resource
Claude Opus 4.8
98,766 tokens  $5.0023
localhost:3000/gadget/[illegible]?chat=0

### Create a connection

The connection picker includes Home Assistant and Spotify. The speaker wants to run Gadgets in his basement for home automation.

[17:04](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1024s) [A connection dialog lists available services, including Home Assistant and Spotify.](https://assets.ai.engineer/sites/aiecode2025/sha256/3ba5ba4b765c314234420853e5a74c53155f5d7527f2179a82ad66459db6f7cf.webp)

Create New Connection
Choose what this gadget should be able to use.

Search services, apps, data sources...

Agent
Gadgets · Allow this gadget to start new AI agent conversations with selected tools.

Email
Email · Send and receive emails.

GitHub
GitHub Repository, GitHub Issue, GitHub Pull Request

Google
Gmail Mailbox, Google Doc, BigQuery

Home Assistant
Home Assistant, Home Assistant Area, Home Assistant Label, Home Assistant Device, Home Assistant Entity

Linear
Linear Workspace, Linear Team, Linear Issue

Notion
Notion Workspace, Notion Page or Database

Spotify
Spotify Account, Spotify Playlist

Supabase
Supabase Project, Supabase Organization

Interface text:
Jun 30  6:02 PM
Home - Gadgets
Gadgets talk notes - Goo[illegible]
localhost:3000
gadgets
Home
Gatekeepers
Explore
Gadgets
Blueprints
What are we work[illegible]
Ask a question, build an app, or create an agent that [illegible]
with your tools and data.
Start a new conversation...

## Full transcript

[0:00](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=0s) [intro jingle] Okay.

[0:24](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=24s) Hi. All right. I've got a lot to talk about, so I'm gonna launch right into it here. Um, so Swyx says that you only get to make one point at every talk, uh, one key takeaway, and so I figured I'd just lead with that.

[0:37](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=37s) My, uh, key point is personal AI codegen breaks traditional cloud infrastructure. And to clarify what I mean about that, the word personal here is, uh, is, is doing a lot of work.

[0:49](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=49s) It's, uh, load-bearing, as Claude would say. Um, my point is that, um, if we want to see this future where, um, everyone has personal apps and, like, can personalize, uh, the apps that they run, um, the infrastructure we're using today, um, uh, for, for software in general is, is not the right thing, and we need something completely

[1:09](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=69s) different. So to explain what I mean, um, so think, think about the way that, uh, uh, software is produced and distributed today. You have a developer in an ivory tower who builds an app and then sends it down to the, the people, the users who use the app, and many of them are happy with it, but some

[1:29](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=89s) of them are not. Some of them, uh, say, "This app needs, uh, some additional features for my use case." And so they go to the developer, and they say, "Oh, great developer, will you please grant my feature request?

[1:43](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=103s) Your app is literally unusable without it." And so then the, the developer's representative, the product manager, takes these feature requests and files them into Jira, where they are never seen again.

[1:56](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=116s) Um, but sometimes, sometimes the product manager sees the feature request and says, "Ah, I, you know, I want that too." And then that feature request goes onto the roadmap, and the developer, um, works on it.

[2:09](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=129s) And the developer is implementing all these features, features that, uh, you know, each one is only used by a small subset of users, and each one is adding all these if statements to their code and making things messy, and, uh, they don't like it because the code base is becoming a mess, and each of these features are

[2:26](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=146s) really kind of boring to implement. And so the developer says, "Ah, I know what I need to do.

[2:32](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=152s) We need a rewrite. We need to-- We need a new architecture that has a plug-in system, and then every one of these features can be a plug-in, and it can be nice and clean and easy to build, and the core can stay clean."

[2:48](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=168s) And so the developer goes off and starts working on the, the new architecture with the plug-in system, and, uh, there are still feature requests coming in. And the developer says, "Well, we can't do those features yet because, uh, we need the plug-in system.

[3:03](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=183s) This will be so much easier once we have the plug-in system, and if we do it now, we're just delaying that, and we'll just have to redo it later anyway."

[3:09](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=189s) And so, um, the years go by, and, uh, the new architecture is not ready yet, and none of the features are being implemented, and people are saying, "What are they doing?

[3:21](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=201s) This developer has given up on their product," and, uh, everybody is sad.

[3:27](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=207s) So AI seems to present a new alternative to this. What if, uh, the developer could create their app, the first version of their app, give it to the users, and the users, if they need a new feature, could say-- uh, could ask their AI agent to write that feature just for them, add it to the app?

[3:51](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=231s) Um, then everyone gets the features they need. No one is bogged down in everyone else's features, uh, and the developer gets to keep the, the core app nice and clean and beautiful.

[4:03](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=243s) But there's a, there's a problem with this, which is that none of the, the infrastructure we build software on today is, like, remotely designed for this. You've got, uh, Apple and Google for the past fifteen years, uh, gatekeeping their systems to the point where there's, like, five companies that can build mobile apps now, and, uh, 'cause everyone

[4:26](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=266s) else has been banned. Um, and it's almost, like, easier to, in the United States, to buy a gun than it is to, like, get access to your own phone to, like, install unsigned software.

[4:36](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=276s) You go to Google, and you say, "I want to install unsigned software," and now they're gonna say, "Oh, whoa, hold on, buddy. Uh, you seem upset. Uh, you should, uh, go home and think about this.

[4:46](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=286s) Uh, if you still want that unsigned software in twenty-four hours, yeah, then you can come back and talk to us."

[4:53](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=293s) Um, [laughs] fortunately, we have a workaround for all of that, which is the web. On the web, everyone can build whatever they want, and it turns out it's fine. It's not the security disaster that Apple and Google keep telling us would happen.

[5:07](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=307s) So you can build whatever you want on the web, but there's a different problem on the web, which is that for the past, uh, twenty-five years of, uh, cloud architecture, we've been running in the wrong direction.

[5:21](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=321s) Uh, w- when you distribute a web app,

[5:25](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=325s) you run it on your own server. Like, put it on your server, and then users send requests to your server where the one version of your app, the one, um, you know, blessed version runs, uh, for every single user.

[5:39](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=339s) And so that's convenient for developers. That's why we've done it is so the developer can make sure things stay updated and everyone's on the same version. But, um, it obviously means that users cannot customize their apps.

[5:53](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=353s) So, you know, last year, uh, vibe coding comes along, and we have all these vibe coding, um, uh, platforms out there, and the-- most of them are-

[6:05](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=365s) Targeting web apps because that's the easy thing to target, but they're all targeting this existing infrastructure, which is actually, like, not the right way to do it.

[6:14](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=374s) Um, we need something entirely different, and hence my point. Do you, uh,

[6:22](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=382s) do you like how the word breaks kind of wiggles every now and then?

[6:25](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=385s) That was, uh, that was something Claude put in there, and, uh, it was so stupid, I just had to keep it. Um, uh, I wanna know where in Claude's training data it, uh, it, it learned that you could make words wiggle to give them emphasis 'cause, like,

[6:42](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=402s) I, you know, I understand the red, I understand the underline, but, uh, the wiggle, like, I don't think that's, that's from humans. I thi- I think that's an AI original. [laughs]

[6:53](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=413s) Thi- this is ASI, folks, uh, you know. This is beyond my puny human brain's ability to comprehend. Um, anyway,

[7:03](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=423s) uh, so you might be wondering at this point, like, who is this, this guy who hasn't introduced himself up on stage, um, giving a Richard Stallman-esque rant about how we should have the freedom to modify our own software, and what does he know about, uh, cloud infrastructure?

[7:17](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=437s) So I'm Kenton Varda. I created Cloudflare Workers. I started the project, um, back in 2017 when I joined Cloudflare. I am still the lead engineer today. Um, it now is, uh, you know, it's a serverless application hosting platform.

[7:32](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=452s) We have millions of developers. We serve trillions of requests per day.

[7:36](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=456s) But what I'm gonna talk to you a little bit about today is, uh, sort of a side project I've been working on on top of Workers which is, um,

[7:45](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=465s) uh, designed to... I- is my exploration in how to, uh, uh, solve this problem.

[7:52](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=472s) So, uh, this thing you're looking at right now is actually a little app that I created in this platform. But,

[8:00](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=480s) um, going to the, the front page here.

[8:04](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=484s) So you have your, your vibe code prompt. You know, these things are a dime a dozen. Um, you s- all seen this before, but I'm just gonna put in a little prompt to ma- to show that it works.

[8:13](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=493s) Uh, make a silly counter app. Silly max it.

[8:20](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=500s) Something silly. All right. But I'm not actually gonna sit here and watch it. Oh, no, it said error.

[8:29](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=509s) Yep, the internet doesn't work. That's okay. That's not the most important part of my talk. So, um,

[8:37](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=517s) huh. So wh- what I w- what I want you to understand about this environment

[8:45](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=525s) is, uh, this is not like your typical vibe coding environment where you're deploying apps to a webpage. This is, um, uh, y- you need to think about it more like a, like an Office suite.

[8:58](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=538s) So think about Google Docs. You open Google Docs, you have a bunch of documents, hundreds, maybe thousands of documents. You open one, you edit it, you share it with people.

[9:07](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=547s) This is the same thing except instead of documents, you have gadgets, and each gadget is an application with code. They can all be different code. I have, um, I have an app here which is, like, a collaborative whiteboard app.

[9:21](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=561s) Like, this is a one-shot prompt. Um, I have a, uh, an app here which... So I get a lot of email in Spanish. It's a long story. I don't know Spanish, but I need help, like, filtering all the Spanish email.

[9:34](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=574s) So I made a little app to help me do that, uh, a gadget. Um, I have a gadget to help me sort, uh, pull requests that I need to, uh, review on GitHub.

[9:44](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=584s) And, uh, but those are, you know, things that I just, like, vibe coded from scratch, but we also have this concept over here of blueprints. And, um, a blueprint is someone made a gadget, and they decided that it was useful, and they took a, a blueprint of it, which is just taking the code, exporting the code without

[10:04](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=604s) the data, which they can then share with someone else, and then other people can, uh, instantiate gadgets from these blueprints.

[10:12](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=612s) So, um, we have like a, you know, document editor app here, a Kanban board, and, um, uh, a slide builder. So, like, you know, typical Office apps. Uh, I'm gonna instantiate...

[10:24](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=624s) So, so this, this slide builder, um, was built by my, my colleague Philip here, um, who's a product manager at Cloudflare, and of course, these days, all product managers are also prolific engineers.

[10:35](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=635s) Um, so he, you know, he vibed this in, in an afternoon, I believe. But, uh, if I instantiate this gadget, I get this nice little slide deck. Um, you know, it has things.

[10:46](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=646s) I can edit it and so on. Yay. And if I shared it, it would... Well,

[10:52](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=652s) so an important point here is that when I instantiate this app, it is only for one slide deck. If I want multiple slide decks, I make multiple instances of the gadget, uh, one for each.

[11:04](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=664s) And the reason for that is that all gadgets are, um, shareable and, uh, you know, you can collaborate with other people on them. And the sharing model is implemented by the platform instead of by the app itself.

[11:18](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=678s) So if I click up here, I get sort of a, a share dialog, kind of like a Google Docs share dialog, and I can create a share link and send it to people.

[11:25](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=685s) And, uh, because each gadget is just the one thing that you wanna share, that means that the platform can implement the sharing model and the access control such that the gadget itself can't possibly get that wrong.

[11:40](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=700s) So I'm gonna go over to actually another instance of the same, uh, slides app. This is the, um, the slides I originally wrote for this talk, which yesterday I decided, uh, these slides were trash, and I threw them all away and rewrote it.

[11:55](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=715s) Um, but the, the reason they're bad is, is entirely my fault. It's not Philip's fault. It's, uh, not the software's fault. Um, but this, this can still serve as an example, uh, to, to demonstrate some of what you can do on this platform.

[12:10](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=730s) So if I, uh, click on here, I can see the conversation. You know, of course, I didn't edit the slides myself by hand. I asked the agent to make them for me, right?

[12:19](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=739s) Um, and every app in this platform automatically integrates with agents so that you can do that. And so what I did is I gave Claude a link to this document, this Google Doc, where I had described all of the gadgets that I wanted or the, all the, the slides that I wanted in my, um, in my presentation.

[12:41](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=761s) And crucially, though, this is the interesting point, I said, "If you need, uh, if you need to add any new features to the Slides app itself to support some of these slides, feel free to do so."

[12:54](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=774s) And it did. Um, Claude read all the code for the app and read my doc and said, "Yes, actually, let's see. Slide three needs a, uh, strikethrough formatting. That's not implemented."

[13:06](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=786s) Um, we can add that. Um, some of the slides require things to be centered and, you know, I guess Philip's design taste is too good for centering text, uh, but my, uh, more pedestrian taste called for some centering, and that's okay.

[13:21](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=801s) Claude can add that. Um, more interestingly, slides, uh, five and six here, so I asked for this, like, really crappy diagram of the cloud, right? And the, the app, um,

[13:36](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=816s) didn't support sort of, like, arbitrary diagrams. It supported, you know, uh, box diagrams and arrows and such, but not an arbitrary drawing like this. And so Claude said, "Okay, that's okay.

[13:46](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=826s) We can add a feature. We'll add a feature that allows, uh, you to insert a bunch of SVG." Just paste it into this box here, and now it becomes, uh, part of the slide.

[13:56](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=836s) And now that's not very useful for any human, but it was perfectly useful for Claude, who then generated the SVG.

[14:03](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=843s) Now, at this point, you might be looking at this and saying, "That's a little scary. SVG can contain JavaScript. Uh, are there XSS bugs here?" And the answer to that is, uh, it doesn't really matter because of the way this environment is set up.

[14:18](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=858s) So the UI that you see for the app here is running inside a null-origin iframe sandbox, um, with Content Security Policy set so that it basically cannot talk to anything, any of the rest of the world, can't access any cookies, so on.

[14:35](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=875s) Um, the only thing it can do is postMessage to the parent frame. And through that postMessage channel, we set up a, a Cap'n Web RPC, uh, session, which forwards onto the server and all the way back to the server code for this gadget, which is, uh, this code here, which is written as a, a Durable Object on

[14:58](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=898s) Cloudflare Workers. And, uh, basically, that means-- So, so this, this server code runs in a dynamic worker sandbox, uh, on the server side, where it too is prevented from talking to any of the rest of the world.

[15:13](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=913s) So now we've set up this environment where there's a Vibe-coded client and a Vibe-coded server, and they can only talk to each other and produce the UI, uh, for the user.

[15:23](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=923s) And so if you have an XSS bug, it actually doesn't end up mattering because it, it can't leak anything. Um, they're prevented from doing so, and it'll basically-- There is no security bug you can have in this code that matters.

[15:38](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=938s) Um, and that makes it safe to, you know, go and do things.

[15:44](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=944s) So, uh, I, uh, there's a whole lot that I would like to talk about that I won't have time for here, unfortunately.

[15:53](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=953s) So the, um, uh... So there, there, like, for instance, the, uh, we created a whole system by which these apps can talk to external services in a safe way, but I could give, you know, two more talks about that.

[16:11](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=971s) Um, we created, um, uh, there's a lot of stuff here.

[16:18](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=978s) The, the points that I wanna make in the time that I have left, though, is,

[16:23](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=983s) so everything you see here is, uh, is built on-- Everything except for the LLM is built on Cloudflare Workers. Um, a lot of people don't know this, but you can actually build complex apps on Workers.

[16:35](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=995s) There are no containers involved here. There's just dynamic workers. There are no, there's no database involved. It u- just uses Durable Objects. Um, and furthermore, all of this is actually running locally on my laptop, which is why it doesn't matter that, uh, the internet didn't work.

[16:52](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1012s) Because, uh, so this is all running on, uh, workerd, which is our open source runtime. A lot of people don't know this, the Cloudflare Workers runtime is open source.

[17:01](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1021s) You can self-host it. And I'm excited about that because we have in here a, uh, Home Assistant, uh, connector and a Spotify connector, and I wanna run this in my basement and, uh, use it to do home automation tasks.

[17:17](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1037s) Um, so this is where, though, I have to give a little bit of an apology. Um, so a couple of months ago, when I submitted the, the, uh, the proposal for this talk, this was, like, a side project I was working on.

[17:33](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1053s) And the plan was I was gonna come here, and I was gonna present it, and then I was just at the end of the talk gonna yeet it onto GitHub so that everyone could go and download it and play with it themselves.

[17:43](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1063s) In the last couple of weeks, um, there's been a lot of excitement inside Cloudflare, and this has become a more serious project. And so last Thursday, Dane, our CTO, pulled me, uh, into a room and said, "Kenton,

[17:58](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1078s) I don't think you should yeet this. I don't think this is yeet material. I think we need a, uh, we need to be more careful and disciplined and intentional about how we release this.

[18:08](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1088s) So let's hold it off for a few weeks." And I was pretty upset about that because I promised in the abstract that I was going to open source it, but sorry.

[18:17](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1097s) Uh, that's not happening today. It will happen soon, though.

[18:21](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1101s) Um, and I wish the silly counter worked because GPT makes some silly counters, but, um, oh well, it's not a big deal.

[18:31](https://www.youtube.com/watch?v=RmS5s6Wbin4&t=1111s) And that's, uh, that's all I got. [audience applauding] [upbeat music]
