A developer just shared something refreshingly honest: a detailed breakdown of using AI to build a 55-crate Rust project. No hype, no grand claims. Just a pragmatic assessment of where AI tools added value and where they didn't.
The headline number: roughly 30% productivity gain. But the interesting part isn't the percentage - it's where that gain came from and what it tells us about AI's actual role in serious development work.
Where AI Actually Helped
The developer's experience: AI tools excelled at boilerplate and repetitive tasks. Writing test cases, generating similar code structures across multiple crates, handling basic error handling patterns. The kind of work that's necessary but doesn't require creative problem-solving.
That 30% gain was concentrated in these areas. For a large Rust project with dozens of interdependent crates, that's significant. Less time writing repetitive code meant more time on architecture and optimisation.
The other big win: documentation. AI tools helped generate initial documentation drafts, format comments consistently, and maintain documentation structure across the codebase. Not perfect, but a solid starting point that saved hours.
Where AI Didn't Help
Here's the reality check: AI struggled with architectural decisions. Deciding how to structure the crate dependencies, where to draw module boundaries, how to design the public APIs - that stayed firmly in human territory.
The developer was clear about this: AI could suggest code once the architecture was defined, but it couldn't design the architecture itself. It couldn't make the high-level decisions that determine whether a codebase is maintainable long-term.
For anyone building complex systems, this distinction matters. AI is an acceleration tool for known patterns, not a replacement for engineering judgment. Use it to speed up implementation, not to make design choices.
The Rust Context
Why does this matter specifically for Rust? The language is known for being strict and demanding. The compiler catches errors early but requires careful attention to ownership, lifetimes, and type safety. That's both Rust's strength and its learning curve.
AI tools trained on Rust code understand these patterns. They can generate code that compiles more often than you'd expect. For developers learning Rust, that's valuable - seeing correct patterns speeds up the learning process.
But the developer also noted AI's limitations: it sometimes suggested valid Rust code that was idiomatic but inefficient. The code compiled and ran, but a human reviewer spotted better approaches. That's the gap - AI knows syntax and common patterns, but not always the deeper reasoning behind design choices.
The Testing Story
One area where AI genuinely shone: test generation. Given a function signature and basic specifications, AI tools could generate comprehensive test cases covering edge cases, error conditions, and happy paths.
The developer's assessment: AI-generated tests weren't perfect, but they provided solid coverage quickly. Human review was still necessary - some tests were redundant, others missed subtle cases - but the time savings were real.
For teams with limited testing resources, this is practical. Use AI to generate initial test suites, then have experienced developers review and refine them. It's a workflow that plays to each tool's strengths.
What This Means for Builders
The broader lesson from this honest breakdown: AI works best as a force multiplier for skilled developers, not a replacement for skill. It speeds up the parts of development that are time-consuming but straightforward.
For business owners and team leads, this suggests a clear strategy: invest in AI tools to reduce grunt work, but maintain focus on hiring and developing strong architectural thinking. The productivity gains are real, but they depend on having someone who can direct the tools effectively.
For individual developers, the takeaway is tactical: use AI for boilerplate, testing, and documentation. Keep the important decisions - structure, design, trade-offs - in your hands. That's where your expertise matters most.
The Honesty Matters
What makes this developer's account valuable isn't the specific percentages or techniques. It's the realistic framing. No claims that AI revolutionised the workflow. No suggestion it replaced human judgment. Just a clear-eyed view of what worked and what didn't.
That honesty is rare in tech writing, especially around AI. But it's what people actually need - practical guidance based on real experience, not aspirational demos.
If you're building at scale, whether in Rust or any other language, this model makes sense: use AI as an assistant for the routine work, freeing up mental space for the complex decisions. That's not significant, but it's effective. And in the end, effective beats significant every time.