Abstract:

In this video, Rust expert Jon Gjengset, a self-professed skeptic of ML-based coding tools, puts the agentic AI assistant Claude Code to the test. He attempts to implement several complex, non-trivial changes to his sguaba crate, a library that heavily leverages Rust's type system for safety in spatial mathematics. The stream documents his unfiltered, first-time experience with "vibe coding," revealing a highly interactive process where he must constantly guide, correct, and refine the AI's proposals.

Over the course of the session, he successfully implements two features: a macro that provides compile-time validation for constructor arguments and a type-state builder that enforces a specific method-calling order. However, the process requires hitting the AI's usage limit. He concludes that while the tool is proficient at applying known patterns under heavy supervision, it struggles with the deep, nuanced reasoning required for this type of task. The experience does not disprove his initial skepticism, as it's unclear if the AI-assisted approach saved time compared to manual implementation.

Exploring AI-Assisted Rust Development: A Test of Claude Code

• 0:00:00 - Skepticism and Goal: Jon outlines his skepticism that AI coding assistants can handle complex, non-pattern-based programming. He sets out to test this by having Claude Code implement several challenging features for his type-safe Rust library, sguaba.
• 0:07:00 - The sguaba Crate Explained: He provides a detailed overview of the sguaba crate, which performs spatial math (e.g., 3D transformations). Its key feature is using Rust's type system to prevent programmers from accidentally mixing up different coordinate systems (e.g., a plane's frame of reference vs. GPS coordinates), thus ensuring correctness at compile time.
• 0:25:18 - Task 1: A Compile-Time Safe Macro: The first challenge is to create a macro for building Bearing and WGS84 types. The goal is to provide compile-time checks for values like elevation and latitude, so invalid inputs cause a compilation error rather than a runtime panic.
• 0:35:13 - Intensely Guiding the AI: Implementing the macro proves to be a highly interactive process. Jon must repeatedly correct Claude's plans, guiding it to handle different angle units (degrees vs. radians), parse negative numbers correctly, and use a specific macro syntax to remain consistent with the rest of the crate.
• 1:30:38 - Task 2: A Type-State Builder: The second task is to create a builder for constructing an Orientation from yaw, pitch, and roll angles. To prevent user error, the builder must use the type-state pattern to enforce that the values are set in the mandatory order: yaw, then pitch, then roll.
• 1:42:26 - A "Pair Programming" Session: Jon acts as the senior developer, guiding the AI toward a more robust design. He prompts it to use a simpler state machine and to generalize the builder to work for both Orientation and Rotation types, which avoids significant code duplication.
• 2:27:02 - Hitting the Usage Limit: After about 2.5 hours of intensive prompting and coding, Jon exhausts the message limit on his Claude Pro plan, bringing the experiment to an end after completing the first two (and easiest) of his four planned features.
• 2:36:06 - Concluding Thoughts: Jon reflects that the experience did not disprove his skepticism. He found the AI to be a "pattern-applying" tool that required constant supervision rather than an autonomous agent. While it wrote more thorough tests than he might have, the time spent prompting and correcting the AI meant it wasn't clearly faster than doing the work himself.
• 2:50:55 - Key Takeaway: AI for Testing: One of the most significant benefits Jon identified was the AI's ability to generate comprehensive tests, including compile_fail tests to check for correct compilation errors and numerous boundary-condition checks.