Overview
Jonathan Kelley uses the five-year evolution of the Rust-based Dioxis project to explain what ambitious software development looks like in the age of coding agents. Beginning in 2021, the team pursued a cross-platform framework that combined native performance with HTML, CSS, and React-inspired programming, despite lacking reusable components for rendering, hot reload, packaging, and other essential infrastructure. By 2026, the project had expanded into a broad application stack with native rendering, code sharing, a custom web engine, and a general hot-reload system. The arrival of capable AI coding agents then changed the team’s development economics—but not immediately for the better. An early burst of AI-generated Rust produced tens of thousands of lines, yet little met the project’s merge standards. After refining their practices, the team found agents highly effective at documentation-heavy integrations, debugging obscure platform behavior, building testing infrastructure, and automating release maintenance. However, agents remained unreliable at choosing meaningful tests, preserving long-term architectural coherence, and inferring poorly expressed intent. Kelley’s conclusion is that implementation effort is falling while architectural judgment, validation, maintainability, and human code review are becoming more important. The engineering standard therefore rises rather than disappears: code is cheap, but quality remains expensive.
Sections
Project and AI Adoption Timeline
The progression from a speculative Rust framework to an AI-accelerated production project.
- Kelley committed the first code to the project during the final summer of his undergraduate studies, choosing to explore a Rust cross-platform framework instead of pursuing a conventional internship or AI research.
- The 2021 design proposed writing applications in Rust while using HTML and CSS for markup, at a time when the speaker considered React Native unstable and Flutter slow.
- The team spent the following years constructing missing infrastructure, including rendering, hot reload, packaging, and browser-related technology.
- By 2026, the project reportedly exceeded its original mission and had achieved substantial adoption, downloads, and end-user reach.
- During the six months preceding the talk, improvements in coding agents—especially their Rust capability—changed the team’s view of AI-assisted development.
- The first intensive experiment generated tens of thousands of lines, but only a small fraction satisfied merge standards, prompting the team to reconsider its workflow.
- After refining its methods, the team used agents for difficult integrations, debugging, release maintenance, documentation, and test infrastructure, supporting releases weekly or several times per week.
- The talk concludes with the Dioxis team joining Cognition, the company that acquired the project.
Technical Systems and Measurements
Concrete architectural components, capabilities, and reported performance characteristics.
- The framework uses Rust for application logic, HTML and CSS for interface markup, and a reactive model inspired by React, while avoiding a virtual machine, inter-process communication, and JavaScript.
- The completed stack reportedly includes cross-platform support, native rendering, Rust hot reload, bundle splitting, shared components, and a common codebase for web, iOS, and Android applications.
- Blitz is a lightweight HTML and CSS rendering engine assembled from a browser-grade CSS engine extracted from Firefox, a custom HTML DOM, and a hybrid GPU rendering pipeline.
- Blitz applications are reported to have package sizes below 5 MB and runtime memory consumption below 50 MB.
- Subsecond is described as a general hot-reload engine for Rust, C, and C++ that recompiles changed code and patches running applications in place within 100 milliseconds.
- Subsecond reportedly supports major operating systems and web targets compiled to WebAssembly.
- The team used agents to integrate Kotlin and Swift plugins into the build system; initial implementation reportedly took one day, followed by approximately two weeks of test construction and real-device validation.
- Agents were particularly effective at constructing fuzzing infrastructure that subjects applications to millions of malformed, adversarial, or unexpected inputs.
Key Tradeoffs
Explicit contrasts used to define the framework and the proper role of coding agents.
- The 2021 Rust design was presented as an alternative to React Native and Flutter: the existing frameworks allegedly suffered from instability, speed, and native-API compatibility issues, while Rust offered direct native construction without a VM, IPC, or JavaScript.
- Blitz was contrasted with Electron applications, which were characterized as consuming substantial memory and storage; Blitz targeted a package below 5 MB and runtime memory below 50 MB.
- Research and prototype software can prioritize iteration speed, whereas foundational infrastructure must emphasize continuous correctness, maintainability, compatibility, documentation, testing, and stable releases.
- Agents can implement, search, and refactor with exceptional speed and persistence, but humans remain better positioned to define architecture, meaningful test conditions, long-term evolution, and acceptable quality.
Strategic Implications
Broader conclusions derived from the project’s experience.
- AI does not eliminate the speed-quality tradeoff; it relocates it. Implementation becomes faster, but review capacity, architectural clarity, and validation become the limiting resources.
- A difficult language can become more strategically attractive when agents absorb its routine cognitive burden while the system retains the language’s performance and safety properties.
- The highest-value uses of agents may be repetitive release and maintenance work rather than headline-generating feature creation, because this protects scarce expert attention without delegating core judgment.
- AI-generated code amplifies the quality of its environment: coherent foundations and precise intent produce leverage, while weak architecture and vague instructions produce technical debt at greater speed.
- As writing code becomes less costly, reading code becomes more important because maintainers must still determine whether generated changes are correct, adaptable, and consistent with the product’s future.