Building ambitious software - Jonathan Kelley, Dioxus Labs & Cognition

AI coding agents have made writing code cheap, but they raise rather than lower the bar for software engineering - success now depends on architecture, code re...

Building Ambitious Software: A Case Study in AI-Assisted Systems Engineering

Abstract

The proliferation of large language model (LLM)-based coding agents has substantially reduced the marginal cost of producing source code. This synthesis examines the consequences of that shift through the lens of Dioxus, a cross-platform application framework written in Rust and maintained by a three-person core engineering team. Drawing on the team's transition from skepticism toward agentic tooling to systematic adoption, the analysis identifies where coding agents deliver disproportionate value - knowledge-intensive integration work, tedious maintenance, and documentation - and where they remain deficient, notably in authoring meaningful tests and inferring contributor intent. The central finding is that cheap code production raises rather than lowers the bar for software engineering: architectural judgment, line-by-line review, and codebase quality become the binding constraints on output. Practical implications include reallocating engineering time toward design, treating codebase quality as an input to agent performance, and adopting fuzzing over agent-authored unit tests.

1. Introduction

Coding agents - LLM-driven systems capable of autonomously reading, modifying, and validating source code within a repository - have progressed rapidly, including in systems languages such as Rust that were historically underrepresented in training corpora relative to Python and JavaScript. A common inference from this progress is that the economic value of software engineering expertise declines as code generation becomes commoditized.

This synthesis argues the opposite. Evidence from the development of Dioxus, Blitz, and Subsecond indicates that when code production becomes inexpensive, the scarce resources shift upstream to software architecture, code review, and quality control. As the maintainers observed:

"Code is now cheap, but quality is not."

The central question addressed here is not whether coding agents can produce functioning code - the evidence indicates they clearly can - but where their output requires human oversight, and what organizational and technical adaptations are necessary to convert increased code volume into shipped, reliable software. Section 2 establishes technical context. Section 3 analyzes agent capabilities and failure modes. Section 4 distills implementation-level insights. Sections 5 and 6 discuss implications and conclusions.

2. Background and Related Work

Dioxus originated in 2021 as a solo project to build a cross-platform application framework in Rust, using HTML and CSS as the markup and styling layer. The motivation was dissatisfaction with incumbent options: React Native was perceived as janky, and Flutter as too slow. The design objective was native performance - no virtual machine, no inter-process communication (IPC), no JavaScript runtime - while preserving the ergonomics of web tooling and React-style reactivity, requiring the team to build reactivity, font rendering, hot reloading, and bundling from scratch.

The framework has since accumulated approximately 37,000 GitHub stars, millions of downloads, and an estimated cumulative reach of 200 million end users across AI assistants, voting software, data science tooling, and satellite collision-avoidance systems. Two subsystems provide relevant technical context: Blitz, a lightweight rendering engine extracted from Firefox's CSS engine paired with a custom HTML DOM and hybrid GPU pipeline; and Subsecond, a generic hot-reload engine for Rust, C, and C++. These artifacts define a codebase of sufficient scale and technical depth that the team's later experience with coding agents constitutes a nontrivial stress test of agentic tooling in systems programming contexts.

3. Core Analysis

3.1 From Skepticism to the "Slop Cannon" Problem

The Dioxus team, composed of Rust engineers, was initially skeptical of AI coding tools, reporting that they had not "felt the AGI" despite broader industry enthusiasm. This changed over a six-month period as agents demonstrably improved at Rust-specific tasks. However, early adoption produced a distinct failure mode: agents generated tens of thousands of lines of code, the majority of which did not meet the quality bar required for merging. The team characterizes this risk as becoming a "slop cannon" - a state in which code volume increases without a corresponding increase in usable output. This forced a deliberate reflection on which tasks agents were suited for before scaling adoption, indicating that naive agent deployment without process adaptation degrades rather than improves engineering throughput.

3.2 Domains of Disproportionate Value

Coding agents demonstrated the greatest value in knowledge-heavy problems requiring breadth across build systems, runtimes, operating systems, languages, and APIs rather than depth of novel reasoning. A concrete example is the implementation of Kotlin and Swift plugins integrated into the Dioxus build system - functionality comparable to React Native's turbo modules - completed in two to three weeks versus an estimated multi-year timeline through conventional development. Agents also accelerated debugging of CSS and layout defects in Blitz by recalling specific behavioral quirks of Chrome, Safari, and WebKit engines, effectively substituting for institutional knowledge that would otherwise require years of accumulated experience.

Beyond novel feature work, agents proved highly effective at mundane, tedious maintenance: verifying release checklists, backporting bug fixes, and keeping documentation synchronized with code changes. This contributed to a measurable increase in release cadence, with the team shipping patch releases multiple times per week - a frequency attributed directly to agent-assisted maintenance work. Notably, the team reports that agents removed the incentive to take shortcuts, enabling development "the right way" where time constraints previously forced compromises.

3.3 Persistent Limitations

Despite these gains, coding agents exhibit specific and consistent weaknesses. Test authorship remains a significant gap: agents tend to produce sloppy or trivial tests, such as verifying object construction without exercising meaningful logic paths. This limitation is partially mitigated by using agents as a sounding board for enumerating edge cases and test conditions, and by redirecting agent effort toward building fuzzing harnesses for adversarial or malformed input - a task better suited to agents' strength in breadth-first exploration than to designing targeted unit assertions.

A second limitation concerns architectural restraint. Agents are willing to execute large refactors or structural changes when a feature does not fit existing abstractions, a behavior that contrasts with the caution typically exercised by human engineers wary of destabilizing a codebase. While this willingness can accelerate necessary restructuring, it also means agents can produce "spaghetti code" at a velocity exceeding human error rates, necessitating sustained architectural oversight. Finally, agents cannot yet reliably interpret user intent from external contributors' pull requests, requiring human review and deliberate prompt engineering to extract correct implementations from ambiguous specifications.

4. Technical Insights

Several implementation-level findings merit attention for teams evaluating similar workflows:

• Bundle and memory footprint: Blitz applications maintain under 5 MB bundle size and under 50 MB runtime memory consumption, a footprint substantially smaller than comparable Electron-based applications - achieved through a custom rendering pipeline rather than agent-assisted work, but relevant as the performance baseline the team sought to preserve while accelerating feature development with agents.
• Hot-reload latency: Subsecond patches running Rust, C, and C++ applications in under 100 ms, a capability that plausibly interacts favorably with agent-driven development by shortening feedback loops during iterative code generation and review.
• Integration task acceleration: The Kotlin/Swift plugin work (2-3 weeks versus years) represents the clearest quantified productivity gain, specifically in knowledge-heavy, integration-style engineering rather than algorithmic novelty.
• Team scale invariance: A three-person core engineering team sustained an increased release cadence and expanded scope, suggesting that agent-assisted maintenance can substitute for additional headcount in specific task categories (documentation, backporting, checklist verification) without a proportional increase in core staff.
• Trade-off in test strategy: Given agents' weakness in unit test quality, fuzzing harnesses represent a more productive allocation of agent effort for adversarial input coverage, while meaningful unit and integration test design remains a human-directed activity.

5. Discussion

These findings support a reframing of the relationship between code generation cost and engineering value. As code production costs approach zero, the constraints on shipped software quality shift entirely to architecture, review discipline, and judgment about what should be built and how it should be structured. This is consistent with the team's observation that "reading code has always been more important than writing code," a principle rendered more consequential, not less, as the volume of agent-produced code increases.

A notable industry tension emerges between the temptation to measure agent value by lines of code produced and the demonstrated reality that unreviewed volume produces the "slop cannon" failure mode. Organizations adopting agentic tooling without corresponding investment in review capacity and architectural planning risk accumulating technical debt at agent-accelerated speed. Open questions remain regarding how test-authoring limitations will evolve, whether contributor-intent interpretation will improve with better context-provision mechanisms, and how prompt engineering practices might be formalized as a distinct engineering discipline rather than an ad hoc skill.

6. Conclusion

The Dioxus team's experience indicates that coding agents have not diminished the importance of software engineering expertise but relocated it - from code authorship toward architecture, review, and quality control. Practical takeaways include reserving agent deployment for knowledge-heavy integration and maintenance tasks, maintaining line-by-line human review regardless of AI-assisted tooling, substituting fuzzing for agent-authored unit tests, and treating prompt engineering as a determinant of implementation quality. As agentic tooling continues to mature, the organizations that benefit most will likely be those that pair increased code production capacity with proportionally increased investment in the human judgment required to govern it.

Sources

• Building ambitious software - Jonathan Kelley, Dioxus Labs & Cognition - Original Creator (YouTube)
• Analysis and summary by Sean Weldon using AI-assisted research tools

About the Author

Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.

LinkedIn | Website | GitHub