troels.im

The AI-Augmented Developer's Rust Series

I've spent the past year deep in AI-assisted development. Hundreds of coding sessions. Thousands of dollars in API costs. Production systems shipped. Lessons learned the hard way.

One pattern kept emerging: the shipping fastest weren't done using the cleverest prompts. It boiled down to catching errors before production and spend less time debugging!

Today I'm releasing something I wish I'd had when I started: The AI-Augmented Developer's Rust Series — a two-volume guide to building full-stack applications with Rust, specifically designed for developers using AI coding assistants.

Get the books at fullstackrustapp.com →

The Problem This Solves

Here's the uncomfortable truth about AI-generated code: studies show up to 40% of it contains bugs or security flaws.

In Python or JavaScript, those bugs slip through. They become runtime surprises — the 2 AM production alerts, the security incidents, the customer-facing errors that erode trust.

I watched this pattern play out repeatedly in my own work. AI would generate plausible-looking code. Tests would pass. Code review would approve. Then production would reveal edge cases that broke production.

The solution wasn't better prompts. It was a better compiler.

Why Rust Changes the Equation

Rust's strict type system and ownership model do something remarkable: they catch entire categories of bugs at compile time. Memory safety issues. Data races. Unhandled errors. Null pointer exceptions.

When AI generates Rust code, the compiler becomes your verification layer. The AI writes fast. The compiler verifies correctness. You ship with confidence.

Google's production data backs this up:

  • 1000x fewer memory safety vulnerabilities in Rust code
  • 4x lower rollback rates compared to C/C++
  • 25% less time spent in code review

These statistics apply equally to AI-generated code. When the compiler enforces correctness, fewer bugs reach production — regardless of who or what wrote the code.

What's in the Books

Volume 1: Rust Foundations

Move Fast AND Fix Things

This isn't another "learn Rust syntax" tutorial. It's a your reference guide to understanding why Rust's constraints are features that compliment your AI workflow.

You'll learn:

  • Ownership and Borrowing — the #1 source of AI-generated Rust bugs, and how the compiler catches them all
  • The Type System — how strict types guide AI toward correct code
  • Fearless Concurrency — compile-time prevention of data races that slip through in other languages
  • Async/Await — Rust's async model and the bugs it prevents
  • Error Handling — Result and Option types that force complete error coverage
  • Memory Management — smart pointers, lifetimes, and zero-cost abstractions

Each chapter demonstrates how these features act as safety nets for AI-generated code. Not abstract theory — practical patterns you'll use daily.

Volume 2: Full-Stack Applications

Ship Faster Without Shipping Bugs

Theory is worthless without application. Volume 2 builds a complete Ethereum wallet from scratch — WebAssembly frontend, REST API backend, Web3 integration.

You'll build:

  • Yew Frontend — WebAssembly-based SPA with components, routing, and state management
  • Axum Backend — type-safe REST API with authentication and database integration
  • Web3 Integration — wallet generation, transaction signing, balance checking
  • Shared Types — the same types compile for frontend and backend, catching integration bugs at compile time
  • Production Patterns — testing, deployment, and security best practices

This is not a toy example. It's a complete application demonstrating patterns you'd use in production systems.

Who This Is For

These books are designed for a specific developer profile:

  • You're already using AI coding assistants (Claude, Copilot, Cursor)
  • You want compile-time verification of AI-generated code
  • You're coming from TypeScript, Python, or JavaScript and want to add Rust
  • You want to build full-stack web applications, not just CLI tools
  • You want production patterns, not academic exercises

If you're skeptical about Rust's learning curve — I address that directly. Every chapter includes mental model shifts for developers from dynamic languages, with TypeScript and Python comparisons throughout.

The AI-Augmented Approach

Most Rust books teach Rust. These books teach Rust in the context of AI-assisted development.

Every chapter demonstrates:

  • How to prompt AI effectively for Rust code
  • What the compiler catches that you would have missed
  • How to review AI-generated implementations with confidence
  • Patterns that make AI output more reliable

This reflects how I actually work now. I don't write Rust without AI assistance. I don't trust AI output without compiler verification. The combination is more powerful than either alone.

Pricing

I've priced these to be accessible while reflecting the depth of content:

  • Rust Foundations — $29
  • Full-Stack Applications — $39
  • The Bundle (both volumes) — $47

Buy once, own forever. Complete source code included. Code snapshots at each chapter stage showing how the project evolves.

Get the books at fullstackrustapp.com →

The Bigger Picture

This release connects to everything I've been building at CompoundCoders.

The ACE framework — Accurate prompting, Chaining, Evaluation — provides methodology. These books provide the technical foundation that makes that methodology effective. Rust's compiler is the evaluation layer that verifies AI output systematically.

If you've been following my work on AI-assisted development, this is the missing piece: a language where the tooling catches the bugs that AI introduces.

If you're new here, this is a good place to start. The books stand alone as comprehensive Rust guides. The AI-augmented angle is a bonus that becomes increasingly valuable as you integrate AI into your workflow.

What's Next

I'm continuing to develop tooling around these patterns. Wonop Code embodies many of these principles. The educational content at CompoundCoders extends them.

But the books are complete and available now. 900+ pages. Full source code. Real-world project.

If you're ready to ship faster without shipping bugs, this is how.

Get the books at fullstackrustapp.com →

Questions about the books or the approach? Reply to this post or find me on the usual channels. I read everything.