# Building ambitious software — Jonathan Kelley, Dioxus Labs & Cognition

Jonathan Kelley, Dioxus Labs

[Talk page](https://ai.engineer/talks/H7vFrcNWXzs-building-ambitious-software) · [Video](https://www.youtube.com/watch?v=H7vFrcNWXzs)

## Building Ambitious Software in the Age of AI

Jonathan Kelley’s Dioxus team learned that coding agents can absorb Rust’s mechanical difficulty and accelerate specialized integrations, debugging, and release work. The harder problems—choosing architecture, designing meaningful tests, communicating intent, and deciding what deserves to ship—remain stubbornly human.

### Dioxus started as a bet on one cross-platform stack

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

In 2021, Jonathan Kelley spent his final undergraduate summer starting [Dioxus](https://github.com/dioxuslabs/dioxus), a cross-platform application framework written in Rust. The proposition was appealingly direct: build web, desktop, and mobile interfaces with Rust, HTML, and CSS instead of moving among platform-specific languages, IDEs, and build systems. Rust would produce native applications without a virtual machine, JavaScript runtime, or inter-process bridge, while familiar web markup and React-inspired reactivity would preserve access to web concepts and tooling. [0:22](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=22s)

![Recording frame at 104 seconds](https://ai.engineer/api/talk-essay-media/ce66aac6d551fddb9c24c683d74ce8fdb8242eb469ed2bbda79f3c5c3df30108)

Recording frame at 104 seconds

The easy-sounding abstraction concealed an enormous implementation burden. In the ecosystem available at the time, Dioxus could not simply assemble ready-made pieces for reactivity, font rendering, hot reloading, and bundling. The team had to build much of the application stack itself. “Building a web browser” became one of the necessary intermediate steps rather than an adjacent research project. [1:53](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=113s)

Five years later, Dioxus supported the major capabilities in that original plan: shared full-stack and native code, cross-platform rendering, hot reload, and bundle splitting. Kelley reported nearly 37,000 GitHub stars, millions of downloads, and an estimated cumulative audience above 200 million across applications including AI assistants, voting software, data-science tools, and satellite collision-avoidance systems. The end-user figure is an estimate presented in the recording, not a measured deployment census. [2:29](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=149s)

The developer experience was deliberately compressed around a conventional Rust project: fewer files, unified tooling, optimized assets, little platform-specific code, and a `main.rs` entry point. That simplicity mattered because the product was not only its visible output. Developers had to understand the project structure, compile it across platforms, and build businesses against its APIs.

Two projects show how far the team pushed the stack. **Blitz** is a lightweight HTML and CSS renderer built from a browser-grade CSS engine extracted from Firefox, a custom HTML/DOM implementation, and a hybrid GPU pipeline. Kelley reported Blitz applications below five megabytes and below 50 megabytes of runtime memory. **Subsecond** watches Rust, C, or C++ source files, recompiles only the changed portions, and patches the running native application in place in roughly 100 milliseconds; the same approach extends to Rust compiled to WebAssembly. [3:59](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=239s)

Those systems established the quality culture that shaped the later agent experiment. A small team had spent years reading every contribution, maintaining an ambitious release cadence, and writing essentially all of Dioxus by hand. Generated code would be judged against that existing standard, not merely against whether it compiled or demonstrated a feature.

### Fast Rust generation produced a backlog, not a release

[5:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=337s)

The team had been skeptical that agentic coding and high-quality systems work belonged together. That changed when coding agents became markedly better at Rust. The team responded by exhausting its coding-agent subscriptions and generating tens of thousands of lines for long-desired features, integrations, and bug fixes. Almost none of that output cleared the question that mattered: should this be merged? [5:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=337s)

![Recording frame at 350 seconds](https://ai.engineer/api/talk-essay-media/913752944ba1643c761bbc68754a688972544dde539aff1ea8dd1dbc4e52eafc)

Recording frame at 350 seconds

The code remained in drafts because implementation volume had outrun reviewable quality. Kelley calls this failure mode becoming a “slop cannon”: an agent can rapidly produce plausible changes, but every unmerged change still consumes attention, creates uncertainty, and competes with real maintenance work. The observable result was not a faster product. It was a much larger queue of code that the maintainers did not trust.

The postmortem produced a surprising reversal. Dioxus had spent years making Rust easier for people through readable code, good tools, and helpful errors. Agents were less sensitive to that ergonomic work. Instead, they handled Rust’s mechanical burden directly: following edge cases, satisfying the type system, and repeatedly negotiating with the borrow checker. The learning curve the team had tried to flatten for humans became useful because an agent could absorb it while preserving Rust’s compile-time constraints. [7:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=420s)

### Ambitious software needs a different quality bar

[8:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=480s)

The lessons apply most strongly to foundational software, where users build on the code itself. Research prototypes can prioritize discovery, and an application may hide its internals behind a polished interface. Dioxus has to keep working, remain fixable when it fails, preserve APIs across patch releases, and maintain accurate examples, documentation, tests, and benchmarks. A shortcut in the framework becomes somebody else’s broken build or stalled business. [8:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=480s)

![Recording frame at 592 seconds](https://ai.engineer/api/talk-essay-media/ee2802a40c23403dfe749e9f80c0835b3e38c6d0377f935d206d4eee2433abbd)

Recording frame at 592 seconds

Velocity therefore compounds through the existing architecture. New work lands on a “substrate” made of module boundaries, APIs, tests, and maintenance conventions. A sound substrate makes later features easier to add and repair. A poor one turns every additional feature into another dependency on an unstable base. Dioxus still has dozens of desired features, but shipping them faster cannot justify breaking APIs relied on by millions of users.

### Agents work well as patient specialists

[9:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=596s)

The first strong use case was not indiscriminate feature generation. It was knowledge-heavy engineering. A three-person core team cannot retain every detail of every operating system, build system, runtime, language, API, binary format, and implementation quirk. Coding agents can patiently search documentation, inspect bespoke interfaces, examine binaries, and compare unfamiliar implementations without becoming tired of the investigation. [9:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=596s)

![Recording frame at 686 seconds](https://ai.engineer/api/talk-essay-media/a94b50242a6d84bf7811efce4a38d6ce130c138a8b810c8ec460ee49bce18dd7)

Recording frame at 686 seconds

A concrete example was adding deeply integrated Kotlin and Swift plugins to Dioxus’s build system. Comparable native-module infrastructure had taken years of handwritten development elsewhere. With agents, Dioxus shipped its version in roughly two to three weeks. Kelley recalls that the initial implementation may have arrived in about a day; the remaining time—roughly two weeks—went into designing test cases and exercising the integration on real devices. Generation accelerated the first draft, but verification still dominated the path to a shippable feature. [10:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=656s)

Blitz supplied another good fit. CSS painting and layout bugs often require reading specifications and checking how established browser engines handle obscure cases. An agent can retrieve the relevant rule and compare Chrome, Safari, or WebKit behavior while the engineer stays focused on the local rendering problem. That reduces the pressure to insert a quick workaround simply because investigating the correct behavior would otherwise take too long.

These examples share a useful boundary: the system already has an architectural destination, while the agent supplies patient research and implementation labor. The agent makes doing the careful version cheaper. It does not decide whether the integration belongs in the product or how the surrounding system should evolve.

### Release chores scale better than test judgment

[12:15](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=735s)

The less glamorous use case may be more valuable: agents can repeatedly perform work that a small team cannot afford to do by hand. Checking that a release tarball extracts into the correct directory or confirming that examples and documentation still match the code consumes time that could otherwise go into architectural work. Editor extensions illustrate the harder edge of this problem: a team may struggle to retest an extension after every patch, but verifying that it installs in Zed and works during actual use is difficult for agents too. Automating release chores does not by itself solve that end-to-end check. [12:15](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=735s)

![Recording frame at 815 seconds](https://ai.engineer/api/talk-essay-media/0ffaf82a6b397a7c388235e2f638f40504445ae4c16ac9b76111e29e7f7b63ca)

Recording frame at 815 seconds

Three recurring mechanisms paid off:

- **Release verification:** Agents can walk release checklists and inspect packaging details consistently.
- **Maintenance across branches:** They can backport bug fixes onto stable releases, reducing the manual cost of supporting shipped versions.
- **Documentation audits:** They can find missing examples and stale comments, including comments that still describe behavior changed by a human code edit.

Kelley links this automation to a concrete operational change: the latest Dioxus version had received more patch releases than any previous one, with releases arriving weekly or multiple times per week. The talk does not isolate which automation contributed how much, but the team became willing to release at a cadence it previously considered too risky.

Testing exposed the boundary of this success. An agent can write a test for nearly any API, but that does not mean it has chosen a consequential behavior. Given a constructor, it may simply test that constructor. Foundational end-to-end behavior requires product knowledge, an appropriate test interface, and a runner capable of reproducing the environment. Humans still enumerate the important conditions and build much of that testing structure. [14:21](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=861s)

Agents remain useful as a sounding board for candidate conditions and edge cases, and they excel at constructing **fuzzing harnesses**. A fuzzing harness repeatedly drives software with millions of ordinary, malformed, or adversarial inputs to expose crashes and assumptions that hand-written examples miss. Here the target behavior is already clear—feed varied inputs into a defined interface and report failures—so the agent can handle the repetitive harness construction without being asked to decide what product behavior matters most.

### Architecture and review remain the bottleneck

[16:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=963s)

Once implementation becomes cheap, architecture consumes more of the schedule. Agent contributions inherit the quality of the system they enter: a poor foundation still produces poor contributions, even when code arrives at exceptional speed. When a feature does not fit, an agent may readily undertake a huge refactor or redesign the architecture rather than hesitate over the scope of the change. Humans and agents can both write spaghetti code; agents can now write it faster. Dioxus consequently spends much of its development time deciding which future features the architecture must accommodate and how today’s interfaces should leave room for them. Kelley expects architecture to take an even larger share of engineering time as implementation improves, provided developers communicate their intent clearly. [16:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=963s)

![Recording frame at 1002 seconds](https://ai.engineer/api/talk-essay-media/2c59c8e788b29f0b892c720b7b734c5d9781212ea10a718b2ed031e3c60d89fc)

Recording frame at 1002 seconds

What separates generated code from shipped software? The diagram synthesizes the practices described here: architectural intent shapes implementation, tests and real-device checks examine behavior, and maintainers read the code they ship. Its arrows show relationships rather than a fixed release order. In the Kotlin and Swift integration, an initial implementation arrived in about a day, while test cases and real-device testing took roughly two weeks. That contrast makes the remaining work visible: producing code quickly still leaves substantial work to decide whether it belongs in the product.

What turns generated code into shipped software?
An explanatory synthesis of the talk’s practices, not a prescribed sequence. Architecture shapes implementation; testing examines behavior; maintainers review code and decide what clears the quality bar.
- Architecture and intent — Define how the feature fits today and how the system may evolve.
- Agent implementation — Generate code and investigate unfamiliar APIs or platform details.
- Tests and real environments — For the Kotlin and Swift integration, roughly two weeks went into test cases and real-device testing.
- Line-by-line review — Maintainers read every PR, with AI review helping spot bugs.
- Merge and release — Generated output still has to clear the project's quality bar.
- Architecture and intent → Agent implementation (shapes the contribution)
- Agent implementation → Tests and real environments (behavior needs testing)
- Agent implementation → Line-by-line review (code needs inspection)
- Line-by-line review → Merge and release (maintainers judge what belongs)

### Reading code is still the job

[17:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1023s)

Dioxus still reviews every pull request line by line, using AI review as another bug-finding input rather than a replacement for maintainers reading what they ship. Open-source contributions make this especially important: contributors often want one bug fixed or one feature accepted, while maintainers have to consider the codebase’s long-term shape. A locally successful patch can still be glued into the wrong abstraction.

Intent must also travel through text. Agents cannot infer the maintainers’ unwritten model of how Dioxus should evolve, and contributors may not communicate that model clearly. Prompt quality therefore affects implementation quality in a practical sense: a better description carries more architectural decisions, constraints, and acceptance criteria into the agent’s work. It is not mind reading, and it does not remove the need to inspect the result.

The technical conclusion is deliberately old-fashioned: reading code eventually matters more than writing it. Coding agents make lines of code cheap, but they do not make quality cheap. Engineering value remains in choosing an elegant shape for a complex system, anticipating how it will change, preserving flexibility, and taking responsibility for what ships. Faster implementation raises that bar because weak decisions can now propagate much faster. [18:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1083s)

Kelley closes by connecting that work to Cognition: Cognition acquired Dioxus, and the Dioxus team joined the company. He also notes that Cognition is hiring people to work on the next generation of software-development tools. [18:41](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1121s)

## Key takeaways

- A large volume of plausible code is not progress if maintainers cannot justify merging it; unchecked agent output can become a “slop cannon.”
- Rust’s difficulty can become an advantage when agents absorb borrow-checker work and edge cases while developers retain its structural constraints.
- Agents pay off as patient specialists on knowledge-heavy integrations and specification-driven debugging, especially when architecture and desired behavior are already clear.
- Release checks, backports, documentation audits, and fuzzing harnesses are strong automation targets; selecting meaningful end-to-end tests still requires human judgment.
- Code is cheap, but quality is not. Architecture, explicit intent, verification, and careful review become more important as implementation accelerates.

## Resources

- [Dioxus repository](https://github.com/dioxuslabs/dioxus) — The Rust full-stack application framework discussed throughout the talk. Its README shows the cross-platform project structure, hot-reloading workflow, native integrations, examples, and contribution paths.

## Related talks

- [Full Walkthrough: Workflow for AI Coding — Matt Pocock](https://ai.engineer/talks/-QFHIoCo-Ko-ai-coding-workflow) — Develops the planning, vertical-slice, testing, review, and architectural practices needed to turn coding-agent output into maintainable changes.
- [Why Rust is the Ideal Language for Vibe-Coding](https://ai.engineer/talks/ugUeZ8-b-u0-why-rust-is-ideal-language-vibe-coding) — Offers another perspective on Rust’s suitability for AI-assisted coding, alongside Dioxus’s experience of agents handling Rust’s learning curve.
- [Harness Engineering is not Enough: Why Software Factories Fail](https://ai.engineer/talks/Ib5GBkD555M-why-software-factories-fail) — Pairs Kelley’s experience with a discussion of why harness engineering alone may be insufficient for software factories.

## Slides

### Five years ago

Jonathan Kelley spent his last undergraduate summer exploring Dioxus, a cross-platform app framework in Rust. The slide shows an early Reddit announcement alongside “5 years ago...”

[0:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=24s) [An early Dioxus announcement beside the words “5 years ago.”](https://assets.ai.engineer/sites/aiecode2025/sha256/5e09413482a2c9f09aa9a9d227eeec4e7a6f47cc7ce07fe80c6bd52ef404ab05.webp)

5 years ago...

Sneak peak at a Dioxus - a new Rust UI toolkit for the Web, Desktop, Mobile, and more!

Dioxus Sneak Peek
[illegible]

Interface text:
r/rust · 5y ago
jkelleyrtp
796
89
Share
2

### The cross-platform problem

A range of devices and platforms illustrates the challenge of building many apps with too few engineers. Kelley’s proposed framework would use Rust with HTML and CSS across platforms.

[0:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=58s) [Devices and platform logos accompany a question about building a cross-platform app framework.](https://assets.ai.engineer/sites/aiecode2025/sha256/8105d4e392cff43ce8f840db6db91b46591575dadb0992763d52b808a122be83.webp)

The problem: too many apps, too few engineers

What if we had an actually good cross-platform app framework?

### A simple but ambitious idea

In 2021, few off-the-shelf components were available to build Dioxus. Kelley says the team had to build everything from reactivity and font rendering to hot reload and application bundling from scratch.

[1:52](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=112s) [A list of framework responsibilities spans rendering, tooling and platform support.](https://assets.ai.engineer/sites/aiecode2025/sha256/747c42b34d1c32f1c9030c52932422c25f1ec5db2da0f158fd0f402595296b12.webp)

a simple idea,
but am ambitious one

state management, reactivity, font rendering, layout, css resolution, application routing, web-server, build tools, hot-reload, web (wasm), desktop (mac, win, linux), mobile (ios, Android)

4

### Dioxus in 2026

Kelley says Dioxus shares components across web, iOS and Android. He gives a cumulative estimate of over 200 million end users for its apps. The slide reports 2m+ downloads and a recent acquisition by Cognition.

[2:28](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=148s) [Dioxus’s reported stars, project ranking, downloads, users and acquisition are listed.](https://assets.ai.engineer/sites/aiecode2025/sha256/2a72ba1d1e6acf4b0d8ef3e861395d350d85dda8917116a80b6ccf0bcdae0f55.webp)

DIOXUS in 2026

- 37k ⭐
- top 50 Rust project
- 2m+ downloads
- 200m+ end-users
- recently acquired by Cognition! 🎉

### Traditional and Dioxus app stacks

The diagram contrasts separate infrastructure, server, client and platform app directories with a small Dioxus project. Kelley says a main.rs is enough to get started.

[3:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=204s) [A complex traditional app directory and tool logos are compared with a small Dioxus project tree.](https://assets.ai.engineer/sites/aiecode2025/sha256/6abb0b339e183ae1dd3099600c128c7b841440c97d41f58f1abfa278b7dc8b6d.webp)

Traditional App Stacks
.
└── instagram/
    ├── infra/
    │   ├── staging.tf
    │   └── production.tf
    ├── database/
    │   └── migrations.sql
    ├── server/
    │   ├── Requirements.txt
    │   ├── Dockerfile
    │   └── main.py
    ├── server-client-swift/
    ├── server-client-kotlin/
    ├── server-client-javascript/
    ├── ios-app/
    │   ├── main.swift
    │   ├── deps.pod
    │   └── assets/
    ├── android-app/
    │   ├── gradlew
    │   ├── buildSrc
    │   ├── main.java
    │   └── assets/
    └── web-app/
        ├── vite.config.js
        ├── tsconfig.json
        ├── package.json
        ├── main.ts
        └── assets/

Dioxus App Stack
.
└── instagram-dioxus/
    ├── Cargo.toml
    ├── assets/
    └── src/
        └── main.rs

6

### Dioxus at a glance

A signal holds the counter state while two buttons increment or decrement it. The slide lists Dioxus features alongside 300k+ lines of Rust and 3 engineers.

[5:06](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=306s) [Dioxus features and a Rust code example, with the statement that three engineers wrote over 300,000 lines of Rust.](https://assets.ai.engineer/sites/aiecode2025/sha256/20078f8443d07812859e7ae0506c4a3542545de67369388ea4699bf3e2f973a6.webp)

Dioxus at a glance:
- React-like architecture
- Signal-based state management
- Bundle and hot-reload cross-platform
- HTML/CSS widgets and styles
- Builtin web-server and RPC

use dioxus::prelude::*;

fn main() {
    dioxus::launch(App);
}

#[component]
fn App() -> Element {
    let mut count = use_signal(|| 0);

    rsx! {
        Stylesheet { href: asset!("/assets/main.css") }
        h1 { "Dioxus Counter: {count}" }
        button { onclick: move |_| count += 1, "Increment" }
        button { onclick: move |_| count -= 1, "Decrement" }
    }
}

300k+ lines of Rust, 3 engineers

Interface text:
main.rs
Run | Debug
9

### Coding agents and Rust

After a long period of skepticism, Kelley says Dioxus was surprised by how much coding agents improved at Rust. The slide pairs the team’s Claude Code experience with Greg Brockman’s view of Rust as a language for agents.

[5:36](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=336s) [Two social media posts discuss coding agents and Rust above the statement that everything changed when coding agents arrived.](https://assets.ai.engineer/sites/aiecode2025/sha256/38963d9d218de9eab6219f112f7f95e898e9152b47e01e03584127253bef39bc.webp)

Dioxus @dioxuslabs · Dec 5, 2025

guys Claude Code just conquered Rust

it went from stupid in Rust to extremely, extremely smart

I just built a vmware vsphere clone today with built-in vnc, websocket proxy, etc in about 6 hours of work

we're cooked

Greg Brockman
@gdb

rust is a perfect language for agents, given that if it compiles it's ~correct

3:12 PM · Jan 2, 2026 · 1.8M Views

"everything changed when the
coding agents attacked"

10

Interface text:
Dioxus post: 51 replies · 45 reposts · 931 likes · 129K views
Greg Brockman post: 486 replies · 687 reposts · 5.9K likes · 1.3K bookmarks

### From inflated expectations to engineering

Kelley maps the team’s experience onto a hype curve: excitement produced thousands of lines of Rust, but little met their quality bar. The team then reflected on what worked and moved toward engineering.

[6:16](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=376s) [An expectations-over-time curve marks inflated expectations, disillusionment, and a slope toward productivity alongside three stages of reaction to coding agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/89ff2f1d96c5d4add7a8423d11752424a4971109e46e46e460a3009c1836a671.webp)

1. we can build the worlddd!
2. ... okay this is slop
3. actual real engineering

Y-axis: Expectations
X-axis: Time

Innovation Trigger
1 Peak of Inflated Expectations
2 Trough of Disillusionment
3 Slope of Enlightenment
Plateau of Productivity

11

### Rust and AI for agentic engineering

Kelley argues that coding agents can handle edge cases and the borrow checker, reducing the burden of writing Rust while its strictness becomes an advantage.

[6:59](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=419s) [The slide says Rust is strict and asks whether Rust plus AI equals agentic engineering.](https://assets.ai.engineer/sites/aiecode2025/sha256/cf793aee5a24527642cbf58de12712e42084eee17294da78af251ea8a7d99b13.webp)

Rust is strict, and that's a good thing

Rust + AI = agentic engineering?

12

### Agentic engineering in ambitious projects

Kelley introduces lessons from using coding agents on Dioxus, including where they work well and where they still fall short.

[7:38](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=458s) [Section title: agentic engineering in ambitious projects.](https://assets.ai.engineer/sites/aiecode2025/sha256/450d965023742f254fcc03fb0d1a89b67b148e07499ad2dd4d39a2f0787e6267.webp)

agentic engineering in
ambitious projects

13

### Building ambitious software

Kelley describes a tension between shipping features quickly and maintaining quality. For Dioxus, code must keep working and remain easy to fix as the project grows.

[8:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=483s) [Five goals: ship faster, ship fewer bugs, ship across platforms, ship higher-quality code, and ship code that is easy to maintain.](https://assets.ai.engineer/sites/aiecode2025/sha256/21a6263886746cf9f90cdd48b9ef874f0c987b381a6d180cc276913b5aff6105.webp)

what's important when building ambitious software?

ship faster
ship fewer bugs
ship across platforms
ship higher quality code
ship easy to maintain code

14

### Infinite patience and massive knowledge

Kelley says coding agents helped Dioxus ship Kotlin and Swift plugins in two to three weeks, much of it spent testing, and accelerated CSS and layout debugging in the Blitz web engine.

[9:55](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=595s) [Examples of native geolocation interfaces and a CSS website illustrate experimentation and breadth of knowledge.](https://assets.ai.engineer/sites/aiecode2025/sha256/08836f6a517d64fadb382b3a9fffe503f66a348b8c946af0923edb782524397c.webp)

Infinite patience and massive knowledge

experimentation, debugging, wide breadth of knowledge, do things "right"

Geolocation plugin demo
One-shot location fetching through the Dioxus geolocation plugin. Manage permissions, request access, and inspect the last fix received from the device.

Allow “Geolocation” to use your location?
Access your approximate location to provide location-based services
Allow Once
Allow While Using App
Don’t Allow

Current position
The plugin resolves the device location once per request (no background watch). Configure the query and then fetch the coordinates.

Geolocation Demo
[illegible]
Allow GeolocationDemo to access this device’s approximate location?
While using the app
Only this time
Don’t allow

How it works
Android: [illegible]
iOS: [illegible]

happily reverse engineer native apis

Rapidly build modern websites without ever leaving your HTML.
A utility-first CSS framework packed with classes like [illegible] that can be composed to build any design, directly in your markup.
Get started
[illegible]

blitz - knows everything about the css spec

15

Interface text:
Dioxus
Coarse location
NEEDS PROMPT
High accuracy: on
tailwindcss
[illegible]

### Coding agents excel at the mundane

Kelley uses agents to check releases, backport fixes and catch stale documentation, giving his small team more time for architecture while maintaining quality across releases.

[12:13](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=733s) [Examples include checking releases, filtering release notes, backporting fixes, checking documentation, and building tools for tedious work.](https://assets.ai.engineer/sites/aiecode2025/sha256/dd3d2886ec0449524616c0e4227889504720259378d0016a2dec779552b9fd98.webp)

Coding agents excel at the mundane

Much easier to maintain a high quality bar

- verifying archive formats for releases and distribution
- verifying and filtering release note comments
- backporting and cherry picking fixes to stable releases
- verifying docs and comments actually match the code
- building bespoke tools and scripts for rare but tedious work

16

### Review code line by line

The Dioxus team uses AI review to spot bugs, but still reads every PR line by line. Kelley stresses that communicating intent to coding agents matters for implementation quality.

[17:01](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1021s) [The slide says the team still reviews code line by line and that communication skills are more important than ever.](https://assets.ai.engineer/sites/aiecode2025/sha256/5479b102d9cf185790662abcf66642c770f381546bd64c72423049f1e525ecca.webp)

we still review our code, line by line

good communication skills are more important than ever

19

### Code is cheap. Quality is not.

Kelley argues that coding agents make code cheap, while quality still requires designing solutions to complex problems and keeping systems flexible as requirements change.

[18:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1085s) [Slide stating, “Code is cheap. Quality is not.”](https://assets.ai.engineer/sites/aiecode2025/sha256/00c89d5fc5f1b3aa54253898e8b378b76c1fc14c0522b866919ee1c70b3bfac4.webp)

Code is cheap.
Quality is not.

20

### Building Ambitious Software

The Dioxus team joined Cognition, which is hiring people to build tools for the next generation of software.

[18:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1120s) [Closing slide for Dioxus in the Age of AI, with the Cognition logo and an invitation to help build new tools.](https://assets.ai.engineer/sites/aiecode2025/sha256/94a9f9c52a767140d771f9a70b1f469ba5fb30cdb92c663e79c1bde637bdeb18.webp)

Building Ambitious Software
Dioxus in the Age of AI

Cognition

The future needs new tools. Help us build them!

21

### AI Engineer World's Fair

[19:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1147s) [White AI Engineer World's Fair logo in a rectangular outline on a black background, with a website address below.](https://assets.ai.engineer/sites/aiecode2025/sha256/9f9b3fe0fe51bb3e5913b34fbfa03100ffacf25fc6f7c625122cf4eb0039bde6.webp)

AI Engineer
World’s Fair

HTTPS://AI.ENGINEER

## Full transcript

[0:01](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1s) [music]

[0:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=12s) Hello, my name is Jonathan Kelly and

[0:15](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=15s) today we're going to talk about what it

[0:17](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=17s) means to build ambitious software in the

[0:19](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=19s) age of AI.

[0:22](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=22s) 5 years ago, I made the first commit

[0:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=24s) ever to a project called Diosis. I used

[0:28](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=28s) the last summer I had as an

[0:29](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=29s) undergraduate and instead of getting an

[0:31](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=31s) internship at Google or doing research

[0:33](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=33s) in AI like many of my friends at the

[0:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=35s) time, I spent it exploring an idea I had

[0:38](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=38s) for a crossplatform app framework

[0:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=40s) written in the Rust programming

[0:42](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=42s) language.

[0:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=44s) In 2021, Rust was still pretty niche,

[0:47](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=47s) but the ecosystem was growing, the

[0:49](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=49s) tooling was improving, and the pitch of

[0:51](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=51s) native performance, a solid type system,

[0:54](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=54s) and simple cross compilation really sold

[0:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=56s) me. It's extremely nerdy.

[1:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=60s) The idea for Diosis was straightforward.

[1:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=63s) What if we had an crossplatform app

[1:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=65s) framework? Instead of waiting through

[1:08](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=68s) dozens of tool chains, programming

[1:09](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=69s) languages, and idees, what if we simply

[1:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=72s) wrote our all of our apps in Rust using

[1:16](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=76s) HTML and CSS as the markup language?

[1:19](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=79s) This was back in the day 2021 where

[1:21](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=81s) React Native was janky, Flutter was too

[1:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=84s) slow, and neither performed well with

[1:26](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=86s) native APIs. On the flip, with Rust, we

[1:30](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=90s) could build native abstractly with no

[1:32](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=92s) VM, no IPC, no JavaScript. And if we

[1:36](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=96s) used a little bit of HTML and CSS for

[1:39](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=99s) the UI and take some inspiration from

[1:41](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=101s) React for the reactivity, we could reuse

[1:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=104s) vast amounts of web components and web

[1:46](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=106s) tooling. The goal was an extremely

[1:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=108s) powerful app framework that was still

[1:50](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=110s) quite familiar to the average developer.

[1:53](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=113s) Sounds easy, right? Well, as they say,

[1:57](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=117s) we choose to build an app framework from

[1:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=118s) scratch, not because it's easy, but

[2:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=120s) because we thought it would be easy.

[2:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=123s) In reality, trying to challenge React

[2:04](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=124s) Native and Flutter is extremely

[2:06](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=126s) ambitious. In 2021, there were very few

[2:09](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=129s) off-the-shelf components you could use

[2:11](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=131s) to build Dioxis. Everything from

[2:13](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=133s) reactivity to font rendering to hot

[2:16](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=136s) reloading and application bundling had

[2:18](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=138s) to be built from scratch. There's

[2:20](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=140s) nothing we could use. For us, tasks like

[2:23](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=143s) building a web browser were just

[2:25](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=145s) necessary steps along the way.

[2:29](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=149s) Now today in 2026, Diosis has achieved

[2:33](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=153s) and far surpassed its original mission.

[2:36](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=156s) We support all the features we

[2:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=157s) originally set out to build from

[2:39](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=159s) crossplatform support to native

[2:41](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=161s) rendering to Rust hot reload and bundle

[2:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=164s) splitting. We've basically reinvented

[2:47](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=167s) and improved the entire app development

[2:49](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=169s) stack.

[2:50](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=170s) Users can ship a powerful full stack web

[2:53](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=173s) application in the exact same codebase

[2:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=176s) sharing components as their iOS and

[2:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=178s) Android apps.

[3:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=180s) The Daxis project now has nearly 37,000

[3:04](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=184s) stars on GitHub with millions of

[3:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=185s) downloads. Apps built in Dioxis are

[3:08](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=188s) rolled across the globe with a

[3:11](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=191s) cumulative estimate of over 200 million

[3:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=192s) end users. Users have built things like

[3:15](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=195s) AI assistance, software for voting, data

[3:19](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=199s) science tools, and even collision

[3:21](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=201s) avoidance system for satellites in

[3:23](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=203s) space.

[3:25](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=205s) We've put a ton of effort into making

[3:27](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=207s) Dioxis as userfriendly as possible.

[3:30](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=210s) Fewer files, build tooling, hot

[3:32](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=212s) reloading, asset optimization,

[3:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=215s) everything you need to easily ship

[3:36](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=216s) across all platforms.

[3:38](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=218s) Because Dioxis apps are written in Rust,

[3:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=220s) they are structurally very simple. You

[3:43](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=223s) rarely need to drop into platform

[3:45](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=225s) specific code because all rest projects

[3:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=228s) are alike. It's very easy for developers

[3:50](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=230s) to dive into a new project. You can

[3:52](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=232s) completely skip annoying build system

[3:53](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=233s) setup. All you need is a main.rs to get

[3:57](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=237s) started.

[3:59](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=239s) One of the most ambitious goals we had

[4:01](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=241s) for ship lightweight but fully featured

[4:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=245s) HTML and CSS rendering engine called

[4:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=247s) Blitz. We extracted the browser grade

[4:09](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=249s) CSS engine out of Firefox, built our own

[4:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=252s) HTML DOM, and developed a hybrid GPU

[4:15](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=255s) rendering pipeline.

[4:17](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=257s) Compared to Electron apps, which are RAM

[4:19](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=259s) and storage hogs, Blitz apps are

[4:21](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=261s) lightweight, coming in at less than 5

[4:23](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=263s) megabytes bundle sizes and consume less

[4:25](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=265s) than 50 megabytes of RAM at runtime. And

[4:28](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=268s) they're pretty cool. You can write your

[4:29](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=269s) own custom components, spinning cubes,

[4:31](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=271s) you can customize the browser however

[4:32](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=272s) you want. It's a very cool project.

[4:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=275s) We also worked on a tool called

[4:36](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=276s) Subsecond uh which is our generic hot

[4:39](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=279s) reload engine for Rust, C and C++.

[4:42](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=282s) Subsecond watches your code for edits,

[4:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=284s) recompiles parts of the code that

[4:46](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=286s) changed and patches the running app in

[4:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=288s) place all in 100 100 milliseconds. This

[4:51](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=291s) was an incredibly difficult technical

[4:53](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=293s) challenge and is the only hot reload

[4:55](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=295s) engine for native compiled code to have

[4:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=298s) such wide language and runtime support.

[5:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=300s) It works on every major system and even

[5:02](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=302s) the web is compiled into web assembly.

[5:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=305s) No one has done this before

[5:09](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=309s) because these projects we've worked on

[5:11](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=311s) along the way over the past 5 years are

[5:13](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=313s) incredibly ambitious and are the result

[5:15](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=315s) of a tiny but

[5:20](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=320s) over every line of code by with our own

[5:23](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=323s) two eyes and maintain a frequent but

[5:25](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=325s) ambitious release cadence.

[5:28](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=328s) The most amazing thing, every line of

[5:30](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=330s) code in Dioxis until very recently has

[5:33](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=333s) been painstakingly written by hand.

[5:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=337s) Why do I say recently? Well, if you

[5:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=340s) aren't aware, software engineering and

[5:42](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=342s) development has taken a massive turn in

[5:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=344s) the past 6 months. AI coding agents got

[5:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=348s) really, really good. And specifically,

[5:50](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=350s) they got really good at Rust. Our team,

[5:53](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=353s) a bunch of cracked rest engineers, has

[5:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=356s) been quite skeptical of AI for a long

[5:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=358s) time. We had not felt the AGI, so to

[6:01](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=361s) speak. And we definitely weren't using

[6:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=363s) AI in our day-to-day work. We thought

[6:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=365s) the two things were incompatible,

[6:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=367s) shipping high quality code

[6:10](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=370s) tools. Seeing them get really good at

[6:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=372s) Rust was a huge surprise to us. So, we

[6:15](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=375s) were finally excited.

[6:18](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=378s) With this newfound excitement, we

[6:20](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=380s) started building our team. maxed out our

[6:22](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=382s) cloud code subscriptions, turned out

[6:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=384s) tens of thousands of lines of Rust, and

[6:26](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=386s) built all sorts of features we had long

[6:27](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=387s) wished to have. Unfortunately, very

[6:30](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=390s) little of the code cleared our quality

[6:32](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=392s) bar of should we merge this in.

[6:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=395s) Thousands of lines of new features, bug

[6:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=397s) fixes, and integrations we had wanted

[6:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=400s) for years sat there and draft and

[6:42](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=402s) continue to sit there and draft. We

[6:45](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=405s) definitely did not know how to properly

[6:47](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=407s) wield these tools and it was way too

[6:49](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=409s) easy to become what we call a slop

[6:52](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=412s) cannon.

[6:54](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=414s) Um, so we reflected a bit and studied

[6:57](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=417s) what worked and what didn't.

[7:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=427s) to read, easy to write, good tools, good

[7:10](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=430s) error messages. The coding agents

[7:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=432s) generally don't care about this. We

[7:14](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=434s) tried to make Rust easel

[7:20](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=440s) with Dioxis still

[7:22](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=442s) because Rust is harder to write. The

[7:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=444s) coding agents deal with the development

[7:26](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=446s) burden for you. They handle the edge

[7:28](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=448s) cases and they fight the borrow checker,

[7:30](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=450s) saving you from the cognitive burden of

[7:32](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=452s) writing Rust apps. The learning curve

[7:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=455s) which we fought to reduce is now a

[7:38](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=458s) feature.

[7:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=460s) So throughout the process of adopting

[7:43](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=463s) the coding tools to work on Dioxis, we

[7:45](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=465s) learned a wide array of lessons.

[7:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=468s) Many of the thing the coding agents do

[7:50](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=470s) really well today and many things they

[7:52](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=472s) just aren't there yet. So the next

[7:55](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=475s) couple slides I want to talk about some

[7:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=476s) of the things we learned and what it

[7:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=478s) means to to build ambitious software

[8:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=480s) projects in the age of agent coding.

[8:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=485s) Um, it's important to talk about first

[8:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=487s) what it means to build an ambitious

[8:09](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=489s) software project. Um, there's many

[8:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=492s) different types of software out there.

[8:14](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=494s) Depends on what you ship every day. Um,

[8:17](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=497s) you might be doing research and the

[8:20](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=500s) quality of your code isn't the most

[8:21](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=501s) important thing. You might be doing

[8:22](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=502s) prototyping code and and iterating fast,

[8:25](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=505s) moving quickly is important. You might

[8:27](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=507s) be building applications which people

[8:29](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=509s) don't see the code internally. They just

[8:31](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=511s) see what it looks like on the outside.

[8:34](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=514s) But for us and for Diosis,

[8:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=517s) we care about a few different things.

[8:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=520s) Primarily, of course, we care that our

[8:42](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=522s) code works all the time and that if it

[8:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=524s) breaks, we can easily fix it. I think

[8:47](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=527s) this is something people don't think

[8:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=528s) about enough these days that you need to

[8:50](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=530s) continue to build easily maintainable

[8:52](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=532s) code and like the velocity that you ship

[8:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=536s) lays down on this substrate that you've

[8:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=538s) built and if the substrate isn't good,

[9:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=540s) nothing you build on top is going to be

[9:02](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=542s) good.

[9:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=543s) Secondarily, we care about shipping new

[9:06](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=546s) features.

[9:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=547s) Our road map is really long. It extends

[9:10](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=550s) into the far future. There's dozens of

[9:13](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=553s) features we still have yet to build for

[9:15](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=555s) Dioxis. And we want to ship these

[9:17](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=557s) quickly to keep up with the times, but

[9:20](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=560s) we also want to maintain quality. When

[9:23](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=563s) building a large ambitious project like

[9:25](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=565s) Deiosis, there's a constant tension of

[9:27](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=567s) shipping fast, adding new features, and

[9:30](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=570s) then also making sure you don't break

[9:31](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=571s) things and that in a patch release,

[9:33](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=573s) you're not like breaking APIs that

[9:36](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=576s) millions of people rely on. For a

[9:38](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=578s) project that people build their

[9:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=580s) businesses on, there's also a high bar

[9:42](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=582s) for releases. We need to maintain uh

[9:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=584s) high quality of our documentation, of

[9:47](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=587s) our examples, of our tests, of our

[9:49](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=589s) benchmarks. If it if anything is out of

[9:51](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=591s) place, people figure it out pretty

[9:53](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=593s) quickly.

[9:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=596s) So, we really do like coding agents as a

[10:01](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=601s) a form of an excellent assistant for

[10:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=603s) very hard technical problems. Coding

[10:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=605s) agents bring a level of patience and

[10:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=607s) massive knowledge that is very hard to

[10:10](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=610s) muster as an individual working on a

[10:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=612s) very large software project.

[10:14](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=614s) Many problems in Dioxis are knowledge

[10:16](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=616s) problems. Our team can't feasibly know

[10:19](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=619s) every detail about every build system,

[10:21](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=621s) every runtime, every operating system,

[10:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=624s) every programming language, every API,

[10:26](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=626s) every quirk. Fortunately, this is

[10:29](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=629s) exactly where the coding agents excel.

[10:32](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=632s) They can quickly quickly sift through

[10:34](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=634s) thousands of pages of documentation,

[10:36](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=636s) read all the bespoke APIs, dig into

[10:39](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=639s) binaries, reverse engineer APIs. They

[10:42](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=642s) have so much more patience than an

[10:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=644s) individual developer does.

[10:46](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=646s) We were able to implement things like

[10:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=648s) cotlin and swift plugins for dioxysis

[10:51](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=651s) deeply integrated into our build system

[10:54](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=654s) which is a really hard feature. If you

[10:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=656s) know react native turbo modules these

[10:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=658s) things took many years of development to

[11:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=660s) get right by people writing them by

[11:02](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=662s) hand. We were able to ship this in like

[11:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=665s) two to three weeks with coding agents

[11:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=667s) and we probably could have gone faster.

[11:08](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=668s) I think implementation was done in like

[11:10](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=670s) the first day and we spent two weeks

[11:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=672s) building test cases and testing on real

[11:13](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=673s) devices.

[11:15](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=675s) And in Blitz, the thing on the right,

[11:17](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=677s) our custom web engine, web agents have

[11:20](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=680s) accelerated debugging hard CSS, styling,

[11:23](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=683s) and layout issues for us. The agents

[11:25](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=685s) know the CSS spec exceptionally well.

[11:28](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=688s) You might be writing a line of code

[11:29](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=689s) that's trying to resolve some sort of

[11:31](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=691s) painting or layout issue. And the agents

[11:33](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=693s) can instantly recall exactly how Google

[11:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=695s) Chrome and Safari do it. Can tell you

[11:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=697s) the right way of handling it for your

[11:39](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=699s) problem. and you don't have to go open

[11:41](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=701s) the the WebKit source code that's nested

[11:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=704s) deep somewhere in Apple's Git

[11:47](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=707s) repositories.

[11:49](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=709s) We're able to invest time in doing

[11:51](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=711s) things the right way, not the hacky way,

[11:54](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=714s) which interestingly is a turn and

[11:57](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=717s) compared to how we used to do it. We

[11:59](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=719s) would always gauge a project based on

[12:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=720s) its complexity and tend to take

[12:02](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=722s) shortcuts as humans to ship things

[12:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=725s) faster but not at a high quality bar. So

[12:08](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=728s) coding agents give us the ability to

[12:10](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=730s) maintain quality and do things the right

[12:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=732s) way which is very interesting.

[12:15](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=735s) Um a less sexy application of coding

[12:18](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=738s) agents for ambitious projects is

[12:20](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=740s) actually doing the extremely mundane

[12:22](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=742s) tasks. Uh our team is very small. We

[12:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=744s) have three core engineers working on

[12:26](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=746s) Diosis. uh any time that we spend like

[12:29](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=749s) verifying the tarball extracts into the

[12:32](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=752s) right directory structure is like time

[12:34](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=754s) wasted from us thinking about the

[12:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=755s) architecture and the the hard problems

[12:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=757s) of our software. Um Dioxis is a large

[12:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=760s) project and it's been a challenge to

[12:42](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=762s) maintain a high quality bar across the

[12:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=764s) entire codebase across every release. In

[12:46](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=766s) one release we might add an extension

[12:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=768s) for a new editor like zed. We might not

[12:51](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=771s) be able to test that editor every time

[12:53](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=773s) we do a patch release. And it might be

[12:54](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=774s) easy to break that. Applying agents to

[12:57](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=777s) the problem actually lets us automate

[12:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=778s) many of these like hard tedious tasks

[13:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=780s) that would have taken like countless

[13:02](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=782s) hours before.

[13:04](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=784s) And then for us like the code is the

[13:06](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=786s) product. People download the code, they

[13:08](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=788s) build on the code, users interact with

[13:11](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=791s) our APIs, they read our docs, and they

[13:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=792s) build on our architecture. So any

[13:14](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=794s) laziness in the the quality of the code,

[13:17](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=797s) the SDKs that we ship to users

[13:20](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=800s) translates directly into a worse

[13:22](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=802s) developer experience and people either

[13:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=804s) getting upset, their businesses being

[13:26](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=806s) stalled, or them turning off the

[13:27](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=807s) product. So coding agents have been

[13:30](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=810s) excellent at maintaining uh tasks like

[13:33](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=813s) verifying release checklists,

[13:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=815s) backporting bug fixes onto stable

[13:36](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=816s) releases, and ensuring our docs and

[13:38](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=818s) documents are of extremely high quality.

[13:41](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=821s) We still do write a lot of docu comments

[13:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=824s) ourselves, but it's very easy to give

[13:46](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=826s) the agent a task of making sure

[13:47](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=827s) everything is documented properly.

[13:49](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=829s) Everything has an example and everything

[13:51](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=831s) actually is documenting the thing that

[13:53](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=833s) it says in the way that it says. Um, as

[13:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=836s) humans, you know, you'll go edit the

[13:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=838s) code, but you won't edit the comment.

[13:59](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=839s) So, a lot of your comments will actually

[14:01](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=841s) be out of date over time and things get

[14:02](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=842s) very confusing. Um, and if you just look

[14:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=845s) at the numbers, we've shipped more patch

[14:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=847s) releases in our most recent DAXis

[14:09](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=849s) version than we ever had before. So,

[14:10](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=850s) we've been able to maintain weekly or

[14:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=852s) multiple times a week release cadence

[14:14](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=854s) for a large ambitious piece of software

[14:17](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=857s) in a way that we would be scared to do a

[14:18](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=858s) release earlier.

[14:21](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=861s) Um, one thing I'm not 100% convinced

[14:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=864s) yet, uh, we have found varying levels of

[14:27](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=867s) success is using AI to write tests or at

[14:30](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=870s) least blindly writing tests. Um, one

[14:34](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=874s) place we've struggled with Diosis is

[14:36](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=876s) testing. It can be very hard to test

[14:38](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=878s) foundational software, especially like

[14:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=880s) end to end for complex systems. It's

[14:43](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=883s) hard to test that your extension

[14:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=884s) installs into zed and works the way you

[14:46](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=886s) want it to do with literally opening zed

[14:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=888s) and like using the extension. Um, the

[14:52](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=892s) coding agents struggle here too to an

[14:54](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=894s) extent. Uh, they also are, you know,

[14:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=898s) have a tendency to write kind of sloppy

[14:59](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=899s) tests. you'll give it a constructor and

[15:01](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=901s) then it will go test the constructor and

[15:02](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=902s) that's not a very interesting test. Um

[15:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=905s) they can easily write tests for any

[15:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=907s) given API but much like humans they fail

[15:09](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=909s) to write the right tests. So we still

[15:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=912s) find ourselves enumerating test

[15:14](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=914s) conditions manually um crafting test

[15:16](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=916s) APIs our ourselves and handling test

[15:19](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=919s) runners um but it is sometimes a great

[15:22](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=922s) sounding board to come up with the test

[15:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=924s) ideas for a particular thing you're

[15:26](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=926s) trying to to make sure has coverage and

[15:28](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=928s) then enumerating the the edge conditions

[15:31](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=931s) um but one place that we have actually

[15:32](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=932s) really enjoyed using coding agents to do

[15:34](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=934s) testing is building test harnesses. So

[15:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=937s) fuzzing is a critical part of building

[15:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=940s) like production grade software which

[15:43](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=943s) means taking your application and

[15:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=944s) putting it under millions of different

[15:46](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=946s) inputs and quite often adversarial

[15:49](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=949s) inputs basically like malformed inputs

[15:52](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=952s) or uh ways of using the software that

[15:54](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=954s) users should not be using the software

[15:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=956s) but they they can use the software and

[15:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=958s) coding agents are excellent at building

[16:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=960s) these harnesses.

[16:03](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=963s) Um, one thing we've found that code

[16:06](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=966s) extra code architecture is still an art.

[16:08](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=968s) Um,

[16:11](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=971s) coding agents enable you to ship at an

[16:13](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=973s) exceptionally high velocity. I mentioned

[16:14](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=974s) this earlier. If the substrate on which

[16:16](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=976s) your coding agents code lands is bad,

[16:19](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=979s) their contributions will be bad as well.

[16:22](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=982s) Unlike a human engineer, coding agents

[16:23](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=983s) aren't typically afraid to voluntarily

[16:26](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=986s) go on a huge refactor of a system or

[16:28](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=988s) redesign the architecture when a feature

[16:29](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=989s) doesn't quite fit. They'll typically

[16:31](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=991s) just ship. Most of our development time

[16:33](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=993s) is actually now spent thinking about

[16:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=995s) software architecture about what

[16:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=997s) features we'll want in the future and

[16:38](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=998s) how the system will evolve. Just like

[16:40](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1000s) human engineers can write spaghetti

[16:42](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1002s) code, so can the agents, but now just

[16:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1004s) faster. However, I will say with fable

[16:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1008s) level tools, the actual code quality

[16:50](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1010s) itself is so high, provided you properly

[16:52](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1012s) communicate your intent, that proper

[16:55](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1015s) software architecture will probably take

[16:57](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1017s) the vast majority of time in the future.

[16:59](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1019s) Actual code writing, not so much.

[17:02](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1022s) Um, one thing we do for Daxis, which

[17:05](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1025s) maybe you guys still do, maybe you

[17:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1027s) don't, uh, is we review every PR line by

[17:10](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1030s) line. Um, we definitely use AI review to

[17:13](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1033s) spot bugs ahead of time, but we still do

[17:16](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1036s) like to read the code that we ship. We

[17:19](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1039s) receive lots and lots of PRs from

[17:21](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1041s) strangers. Actually, uh, Daxis is big

[17:23](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1043s) open source project. Uh, and not every

[17:25](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1045s) PR is made the same. Uh we find that

[17:28](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1048s) users can be quite bad at communicating

[17:29](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1049s) their intent to the models. Contributors

[17:32](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1052s) don't usually think deeply about how the

[17:33](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1053s) codebase should evolve over time. They

[17:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1055s) just want their bug fix or their feature

[17:36](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1056s) in. Uh and many solutions are glued in

[17:39](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1059s) place. So we're we're not quite at the

[17:41](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1061s) point where the coding agents can read

[17:43](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1063s) our minds. Uh and thus we're still

[17:45](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1065s) limited by the medium of text. And as

[17:48](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1068s) ridiculous as it sounds, prompt

[17:49](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1069s) engineering is quite real. The quality

[17:51](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1071s) of an implementation can be very much

[17:52](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1072s) dependent on the the prompt that you

[17:54](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1074s) give the model.

[17:56](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1076s) But in a sense, nothing really has

[17:58](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1078s) changed. Reading code has always been

[18:00](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1080s) more important than writing code. Um

[18:02](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1082s) maybe not in the beginning, but

[18:04](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1084s) eventually as the project evolves, uh it

[18:06](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1086s) does.

[18:07](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1087s) So my closing thoughts on on using

[18:10](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1090s) coding agents to build ambitious

[18:12](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1092s) software is that code is now cheap, but

[18:14](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1094s) quality is not. Um the the job of a

[18:18](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1098s) software engineer has never really been

[18:20](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1100s) about putting lines of code on the

[18:21](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1101s) screen. It's it's been about

[18:24](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1104s) architecting elegant solutions to

[18:26](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1106s) complex problems to thinking 10 steps

[18:28](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1108s) ahead about how a system will evolve

[18:30](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1110s) about retaining flexibility in the face

[18:32](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1112s) of changing requirements. These facts

[18:35](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1115s) have not changed and the bar for

[18:37](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1117s) software engineering is higher than

[18:39](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1119s) ever.

[18:41](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1121s) Uh if you would like to work on the

[18:43](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1123s) tools of the next generation of

[18:44](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1124s) software, Cognition, the people who have

[18:46](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1126s) acquired Dioxis are hiring. Uh the Daxis

[18:49](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1129s) team joined Cognition to be part of the

[18:50](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1130s) future and hopefully you will too. Thank

[18:53](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1133s) you.

[18:55](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1135s) [applause]

[19:10](https://www.youtube.com/watch?v=H7vFrcNWXzs&t=1150s) >> [music]
