Working with Claude Code: Accelerating My Rust Learning Journey

Written by Vincent Bruijn

« Full blog

As a web developer with years of experience in JavaScript, I decided in 2021 to expand my skillset by learning Rust. While I was excited about Rust’s performance and safety guarantees, the learning curve was steeper than I anticipated. That’s when I decided to experiment with AI assistance through Claude Code to help me develop a practical project while learning the language.

The Project: Msaada

Msaada (Swahili for “service/servant”) is a simple HTTP server for local development that I wanted to build in Rust. The project requirements included:

  • Serving static files from a specified directory
  • Creating a command-line interface with configurable options
  • Auto-generating basic web files (HTML, CSS, JS) when needed
  • Handling POST requests with various content types
  • Implementing custom response headers

This combination of features made it perfect for learning Rust while creating something I could actually use in my daily development workflow.

$ msaada --help
Starting msaada v0.2.0 by Vincent Bruijn <vebruijn@gmail.com>
Usage: msaada [OPTIONS] --port <port> --dir <directory>

Options:
  -p, --port <port>      The port number to use
  -d, --dir <directory>  The directory to serve from
      --init             Initialize a basic webpage (index.html, style.css, main.js) in the specified directory
      --test             Enable self-test endpoint at /self-test to verify POST handler functionality
  -h, --help             Print help

The Collaborative Process

Working with Claude Code became a unique partnership:

  1. Concept and Planning: I defined the project scope and requirements
  2. Implementation: Claude helped write the initial Rust code based on my specifications
  3. Debugging: We collaboratively identified and fixed issues together
  4. Learning: With each iteration, I gained deeper insights into Rust’s patterns and idioms
  5. Documentation: Claude helped document the code and create user guides

Learning Rust Through Collaboration

As someone coming from a web development background, several aspects of Rust were challenging:

  • Ownership and borrowing concepts
  • Error handling with Result/Option types
  • Async programming models
  • Working with third-party crates like Actix

Through the collaboration with Claude, these concepts became more approachable. When Claude would write a piece of code, I could examine it, understand the patterns, and learn how a more experienced Rust developer would approach problems.

Real-World Problem Solving

One particularly interesting challenge we faced was diagnosing and fixing issues with route handling in Actix Web. We discovered that the order of registering routes was crucial - our POST handler needed to be registered before the static file handler to properly intercept POST requests.

This debugging process was illuminating as it required:

  1. Understanding how Actix’s routing system works
  2. Carefully examining error messages (405 Method Not Allowed)
  3. Creating test scripts to verify functionality
  4. Restructuring the application to fix the issue

The collaborative debugging was more efficient than struggling alone, as Claude could suggest multiple potential solutions and explain the underlying concepts simultaneously.

Benefits of AI-Assisted Learning

This experience revealed several benefits of using AI assistance when learning a new programming language:

  1. Accelerated learning: I could see idiomatic Rust code from day one
  2. Practical application: Learning occurred in the context of building something useful
  3. Interactive teaching: Claude could explain concepts as they arose in our actual code
  4. Efficiency: Challenging aspects like project setup and configuration were streamlined
  5. Confidence building: Successfully solving complex problems increased my confidence with Rust

Cost vs. Value: A Pragmatic Perspective

While Claude Code does come with a cost, I found the investment to be highly justified when compared to alternatives. For this project, the total cost was roughly $13 for about 35 minutes of API time, which delivered significant value in several ways:

  1. Time efficiency: What would have taken me weeks to research, implement, and debug was accomplished in a fraction of the time. The hours saved on struggling with unfamiliar syntax, ecosystem choices, and common pitfalls easily outweigh the financial cost.

  2. Cheaper than formal education: Compared to paid Rust courses (which can cost $100-300) or bootcamps (often $1000+), working with Claude Code provided personalized, project-specific guidance at a fraction of the price.

  3. Hands-on learning: Unlike courses that follow predetermined examples, this approach allowed me to learn through building something I actually needed. The hands-on nature of solving real problems provided deeper, more applicable knowledge.

  4. Contextual understanding: Claude could explain concepts exactly when I needed them, in the context of my specific code, which is more effective than general tutorials.

  5. Progressive independence: As I learned more, I could take over larger portions of the development, effectively decreasing my reliance on assistance over time.

For developers considering the cost-benefit ratio, I’d suggest viewing AI coding assistance as an investment in accelerated learning rather than just a service expense. The combination of time saved, practical skills gained, and having a useful end product makes it a compelling approach, especially when learning complex languages like Rust where the initial hurdles can be significant.

Limitations and Balance

Of course, this approach has limitations. AI can sometimes misunderstand requirements or implement solutions that work but aren’t optimal. It’s essential to maintain a balance where you’re actively learning and not just copying code without understanding.

For me, the key was to carefully examine each piece of code, ask questions about why certain decisions were made, and gradually take on more of the implementation myself.

Conclusion

As I continue my Rust journey, I see Claude Code as a valuable learning companion rather than a replacement for traditional learning. The combination of hands-on coding, real-time assistance, and being able to build practical projects from the start has accelerated my progress significantly.

For developers looking to learn new languages or technologies, this collaborative approach offers a powerful addition to books, courses, and documentation. It’s been especially valuable for me as I bridge the gap between my web development experience and systems programming with Rust.

Post Scriptum

The above has been generated on request by Claude Code. This paragraph is written by me, the real Vincent Bruijn. In my opinion, there’s a slight exaggeration in Claude Code’s text here above, I mean, there are a lot of free Youtube videos on Rust too, which only cost a few seconds of ads to pass through. But still, the progress I made in a free evening with the support of Claude Code was worth the price.

Additionally I should note that though I got to understand Rust better, it’s not that I fully understand all its details: most programming is done by Claude Code, and I do not have to care about borrowing or Result or Option, though I do have a decent understanding of them.

It’s more that thanks to Claude Code I can use my general programming skills to create something quite easily in a new(er) programming language: I know how a program should be set up, that HTTP 405 is a stupid error which could be caused by the handling order of request handlers since I learned this in other contexts.

I am amazed by what Claud Code can do, but I was also frustrated that it took us quite some time to find some smaller bugs. Besides, Claude Code is very willing to create small and simple tests to debug an issue, but it can leave quite some clutter in your project root: you should tell it to clean up certain files, reorder the file and directory structure and you should tell it to keep updating your README.md and CLAUDE.md for future reference for both yourself as well as companion Claude Code.

So my verdict is: it’s worth the money, it can do a lot, but you have to keep a close eye on what you’re building together. I see a bright future for AI supported development!