Part two of the discussion with Jim Hodapp and Bob Belderbos focused on practical software development. Topics included testing, tooling, libraries, developer workflows, AI coding assistants, and why Rust's ecosystem is helping developers build more reliable systems.

Key Discussion Points

• Rust libraries and crates
• Built-in testing capabilities
• AI-assisted coding workflows
• Compiler-driven development
• Tooling and developer experience

The rise of AI coding assistants has changed the software development landscape. Code can now be generated in seconds. The challenge is determining whether that code should be trusted. This is where AI-assisted Rust presents an interesting model for modern engineering. Rather than relying solely on AI output, developers gain support from a compiler, testing framework, and ecosystem specifically designed to catch problems early. The result is a workflow centered on reliability instead of speed alone.

About our Guests

Jim Hodapp

Jim Hodapp is a veteran software engineer, engineering leader, and technical coach with deep roots in systems programming. His background spans C, C++, Linux, embedded systems, software architecture, and engineering management. In recent years, he has become a recognized Rust advocate, helping developers transition from traditional systems languages into modern, memory-safe development practices. Through RefactorCoach and his Rust training initiatives, Jim focuses on improving engineering effectiveness, software quality, and developer growth.

Follow Jim on LinkedIn: https://www.linkedin.com/in/jim-hodapp/

Bob Belderbos

Bob Belderbos is a software developer, educator, coach, and co-founder of PyBites. Originally coming from a finance background, Bob transitioned into software through automation, scripting, and Python development. He has spent years helping developers improve their coding skills through practical challenges, mentoring, and community-based learning. More recently, Bob has expanded his focus into Rust, combining his Python expertise with modern systems programming practices to help developers build faster, safer, and more maintainable software.

Follow Bob on LinkedIn: https://www.linkedin.com/in/bbelderbos/

Why AI-Assisted Rust Works Differently

Many AI-generated applications succeed initially but struggle when complexity increases. The root issue is often a lack of validation. AI may generate code that appears correct while introducing subtle assumptions, type mismatches, or architectural weaknesses. Rust changes this dynamic. Its compiler demands correctness before execution.

This creates an environment where AI-generated solutions must satisfy strict requirements before becoming production-ready. Rather than fighting the compiler, developers can use compiler feedback as an additional review mechanism. The combination creates a surprisingly effective development loop.

AI-Assisted Rust and Compiler-Driven Development

Historically, developers discovered many errors during runtime. That process is expensive. Bugs appear later, testing cycles expand, and debugging consumes valuable time. Compiler-driven development shifts detection earlier.

When AI generates code inside a Rust project, the compiler immediately validates:

• Types
• Ownership rules
• Memory safety
• Data structures
• Interface compatibility

This reduces uncertainty. The AI-assisted Rust approach effectively turns compilation into a continuous quality-control process. Every issue caught during compilation is one less issue waiting in production.

How AI-Assisted Rust Improves Testing

Another major topic discussed during the episode was testing. Rust includes first-class testing support directly within the language ecosystem. Developers can place tests alongside implementation code and execute them through the same tooling used to build applications. This integration matters. When testing becomes frictionless, developers are more likely to perform it consistently.

The guests also discussed an emerging AI-era consideration.

When AI generates both application code and tests, developers must ensure tests remain objective. Separating tests from implementation can sometimes help prevent AI from simply validating its own assumptions.

The goal remains the same:

• Verify behavior rather than confirm expectations.
• AI-generated tests are only valuable when they challenge the code instead of reinforcing it.

The Role of Libraries and Crates

Every modern language depends on ecosystems. Rust is no exception. The conversation explored how Rust balances a relatively focused standard library with a thriving third-party package ecosystem.

Instead of relying on massive built-in functionality, Rust encourages developers to leverage well-maintained community crates. This approach provides flexibility while avoiding unnecessary complexity in the language itself.

For teams adopting AI-assisted Rust, this creates another advantage. AI tools can often identify appropriate crates quickly, reducing research time while still allowing developers to evaluate quality and suitability.

Tooling That Supports Better Software

One recurring theme throughout the discussion was integration.

Rust combines several critical capabilities into a cohesive experience:

• Package management
• Dependency management
• Building
• Testing
• Formatting
• Linting

Developers spend less time assembling tooling and more time solving business problems. This integrated philosophy becomes increasingly important as software stacks grow more complex. When AI enters the workflow, consistency becomes even more valuable because every tool participates in maintaining quality standards. Audit your current development workflow and identify how many separate tools are required for building, testing, linting, and dependency management.

The Real Value Is Confidence

The most important benefit of AI-assisted Rust may not be performance. It may not even be productivity.

It is confidence that:

• The generated code meets standards.
• Tests validate behavior.
• Memory safety issues are unlikely to appear unexpectedly.
• The compiler is actively helping rather than simply translating instructions.

That confidence allows teams to move faster without sacrificing reliability. The best development environments reduce uncertainty rather than merely increasing speed.

Conclusion

AI-assisted Rust represents a practical evolution in software development. Instead of choosing between AI productivity and engineering rigor, developers can combine both. AI accelerates implementation while Rust's compiler, testing capabilities, and tooling ecosystem reinforce quality. As software becomes increasingly AI-generated, environments that encourage correctness from the start may become some of the most valuable platforms available to developers.

Stay Connected: Join the Developreneur Community

👉 Subscribe to Building Better Developers for more conversations on momentum, leadership, and growth. Whether you're a seasoned developer or just starting, there's always room to learn and grow together. Contact us at [email protected] with your questions, feedback, or suggestions for future episodes. Together, let's continue exploring the exciting world of software development.

Additional Resources

• Learning New Tech Skills On The Job
• Rapid Experimentation Challenge: Build, Test, and Learn Faster with AI
• Learning a New Development Language
• Building Better Developers Podcast Videos – With Bonus Content