Ever wondered if AI will actually replace programmers? It turns out it's not replacing the programmer, but it's definitely replacing the typing.
The Simple Version
Imagine you have an apprentice who can lay bricks at lightning speed. They never get tired and they follow the manual perfectly.
But here is the catch: the apprentice has no idea if the house they are building is actually stable or if the front door is in the wrong place. If you give them bad blueprints, they will just build a disaster faster than any human ever could.
How It Actually Works
The 'Slop Cannon' Effect
Jonathan Kelley and the Dioxus team discovered that AI agents can churn out tens of thousands of lines of code in a heartbeat. However, they found that almost none of it was actually mergeable.
When you prioritize quantity over quality, you create a 'slop cannon.' You get a mountain of code that looks correct at a glance but fails to meet the high bar of a production-ready system.
Rust as a Feature, Not a Bug
Rust is famous for its steep learning curve, specifically its strict borrow checker that prevents memory errors. For years, this was a hurdle for new developers.
Now, that hardness is an advantage. AI agents are incredibly good at absorbing these strict rules and edge cases, handling the 'boring' parts of memory safety while the human focuses on the logic.
The Automation Sweet Spot
AI doesn't excel at everything. It's a 'patient specialist' for mundane, high-effort tasks. Dioxus used agents to build Kotlin and Swift plugins in weeks instead of years.
They also used them for release checklists, backports, and documentation. These are tasks that are tedious for humans but logically structured for an LLM.
Technical Deep Dive
For the developers, the real insight lies in the distinction between functional code and semantic correctness. This is most evident in testing.
AI agents are great at writing fuzzing harnesses—tools that throw random data at a program to find crashes. This is because fuzzing is about coverage and edge-case generation, which LLMs handle well.
However, agents struggle with unit tests. They can write a test that passes, but they often fail to write the right test—the one that actually proves the business logic is correct. They understand the syntax of the API, but not the intent of the feature.
Dioxus also showcases extreme engineering, like a hot-reload engine that patches running native code in 100ms. AI can help write the boilerplate for such a system, but the architectural decision to lift a CSS engine from Firefox is a human-led strategic move.
Why This Matters
We are entering an era where the cost of generating code is approaching zero. When code is cheap, the value shifts away from the person who can write the most lines.
The premium is now on architecture and quality control. The developer's job is evolving from a 'writer' to a 'reviewer' and 'system designer.'
If you spend your time learning how to prompt for snippets, you're a typist. If you spend your time learning how to design robust systems, you're an architect.
Key Takeaways
- Code is a commodity: The ability to generate syntax is no longer a competitive advantage.
- Architecture is the moat: Designing how components interact is where the real value lies.
- Strict languages win: Hard languages like Rust are actually better for AI because the compiler provides a strict 'truth' for the AI to follow.
- Beware the slop: High output does not equal high progress; avoid becoming a 'slop cannon.'
- Automate the mundane: Use AI for plugins, documentation, and fuzzing, not high-level logic.
- Review > Write: The primary skill of the future developer is reading and auditing code, not typing it.