Updated June 2026

AI-Assisted Development with Rust

Class Duration

35 hours of live training delivered over 5 days.

Student Prerequisites

Professional Rust development experience (ownership, borrowing, traits, and error handling)
Working knowledge of Git and GitHub (issues, pull requests, branches, reviews)
Comfort with the command line and the cargo toolchain
No prior AI tool experience required

Target Audience

Professional Rust developers who want a structured, end-to-end path from AI-curious to AI-proficient. Ideal for engineers and teams adopting AI coding tools across the full development lifecycle - writing, refactoring, testing, reviewing, and shipping Rust code - who also need to understand the security, licensing, and governance implications of doing so responsibly. This is a tool-agnostic course: each delivery is tailored to the AI tools your organization chooses - Claude Code, GitHub Copilot, Codex, Cursor, Windsurf, Gemini CLI, or others - and the skills transfer to whichever assistants your team adopts. For the language-agnostic version of this material, see AI-Assisted Software Engineering Fundamentals.

Description

Rust's compiler is the perfect partner for AI coding tools: generated code either satisfies the borrow checker or it doesn't, and that fast, trustworthy feedback loop makes agentic workflows unusually effective. This five-day intensive teaches professional Rust developers how to exploit it, starting with how large language models generate code, setting up and configuring whichever tools your organization chooses alongside rust-analyzer, and prompting and context engineering techniques that produce idiomatic, clippy-clean Rust. Daily practice follows: disciplined inline assistance, chat-driven explain-refactor-generate workflows, grounding assistants in workspace context with CLAUDE.md / AGENTS.md and rules files, AI-assisted reading of unfamiliar crates and macro-heavy code, and full agentic workflows where the agent compiles, reads compiler errors, and iterates. Day four applies AI to quality across the lifecycle: cargo test and proptest suites, AI-assisted debugging of panics and lifetime and trait-bound errors, refactoring at scale, edition migrations, and documentation. Day five addresses team-scale adoption: reviewing AI-generated unsafe code, crate supply-chain vetting with cargo-audit and cargo-deny, licensing, governance, cost management, and rolling AI out with honest productivity measurement. This is a tool-agnostic course: each delivery is tailored to the AI tools your organization chooses (Claude Code, GitHub Copilot, Codex, Cursor, Windsurf, Gemini CLI, or others).

Learning Outcomes

Explain how LLMs generate code, assess frontier-model strengths on Rust, and set up and configure your chosen AI tools alongside rust-analyzer with sound privacy and data controls.
Apply prompting and context engineering techniques that produce idiomatic, clippy-clean Rust with proper ownership and error handling.
Use inline completions and chat-driven explain, refactor, and generate workflows with discipline: well-scoped context, clean conversation hygiene, and review reflexes.
Ground assistants and agents in workspace context with CLAUDE.md / AGENTS.md, rules files, MCP servers, and shared team prompt libraries, and use AI to read unfamiliar crates and macro-heavy code.
Drive agentic coding sessions with your chosen coding agents, using the compiler and clippy as the agent's feedback loop, including issue-to-PR automation.
Generate, evaluate, and maintain test suites with cargo test, proptest, and doctests, and use AI to resolve borrow checker, lifetime, and trait-bound errors faster.
Refactor at scale, run edition migrations, and generate documentation (doc comments, compiling examples, READMEs, and architecture decision records) with characterization tests and reviewable diffs.
Review AI-generated unsafe blocks, FFI boundaries, and concurrency code with rigor, apply supply-chain guardrails with cargo-audit and cargo-deny, and contribute to team standards for cost, licensing, governance, rollout, and measuring real productivity impact.

Training Materials

Comprehensive courseware is distributed online at the start of class. All students receive a downloadable MP4 recording of the training.

Software Requirements

Rust 1.93+ via rustup, access to your organization's chosen AI coding tools (such as GitHub Copilot, Claude Code, Codex, Cursor, Windsurf, or Gemini CLI; trials and free tiers are acceptable), VS Code with rust-analyzer, Git, and the GitHub CLI.

Training Topics

Foundations: How AI Writes Code

How LLMs generate code: tokens, context windows, and training data
The frontier models for coding: Claude, GPT, and Gemini compared
Why Rust's compiler makes agentic feedback loops unusually strong
Where AI excels in Rust work and where it reliably fails
Setting expectations: assistant, pair programmer, or junior engineer?

Setting Up and Configuring Your Chosen Tools

Accounts, seats, and enterprise policy: who gets access to what
Editor and CLI integration for the tools your organization selects
Model selection and switching: defaults, tiers, and per-task choices
Privacy and data controls: retention, training opt-outs, and telemetry
Rust-aware configuration: rustup toolchains, rust-analyzer, and cargo
Verifying your setup: a smoke-test workflow before daily use

Prompting and Context Engineering for Rust

Writing prompts that produce idiomatic Rust: ownership-aware design up front
Steering toward proper error handling: Result, thiserror, and anyhow
Context strategies: what to include from a workspace with many crates
Trait design, generics, and lifetime annotations in prompts
Avoiding outdated idioms and pre-2021-edition patterns in generated code

Everyday Inline Assistance

Completions as a dialogue: writing code that invites good suggestions
When to accept, when to reject: building review reflexes
Comment-driven prompting and signature-first completions
Types and lifetimes as steering: how signatures sharpen suggestions
Inline assistance and rust-analyzer: complementary, not competing

Chat-Driven Development

Explain, refactor, and generate: the core chat workflows
Scoping context: selections, modules, and symbols - only what the question needs
Conversation hygiene: when to iterate and when to start fresh
From chat to edit: applying, reviewing, and adjusting suggested changes
Interrogating generated Rust: ownership, error paths, and edge cases

IDE Assistants in Daily Rust Work

Deep-dive on your chosen IDE assistants (GitHub Copilot, Cursor, Windsurf, or others): completions, chat, edits, and rules/instructions files
The wider landscape: Aider, Cline, JetBrains Junie, and Amazon Kiro
Working with rust-analyzer and AI assistance together
Multi-file edits and chat-driven refactoring across modules
Doc comments, examples, and cargo doc generation

Working with Project Context

CLAUDE.md and AGENTS.md in depth: what belongs, what doesn't
Rules and instructions files across tools: one convention, many formats
Encoding repo conventions: style, architecture, and testing norms
Team prompt libraries: capturing prompts that work and sharing them
Workspace context: Cargo.toml metadata, features, and toolchain notes
Keeping context files current as the codebase evolves

AI-Assisted Code Reading and Comprehension

Onboarding to unfamiliar crates and workspaces with AI guides
Generating explanations, call graphs, and architecture diagrams
Tracing ownership, lifetimes, and data flow through complex code
Demystifying macro-heavy and generic-heavy Rust
Code archaeology: reconstructing intent from legacy code and history

Agentic Coding with Your Chosen Tools

The agentic loop: plan, act, observe, iterate
The agent landscape compared - Claude Code, Copilot agent mode, Codex, Cursor CLI, Windsurf Cascade, Gemini CLI - and how to choose
Plan mode and the supervision spectrum: permission prompts to auto mode
CLAUDE.md and AGENTS.md: toolchain, workspace, and convention context
The compile-fix loop: agents reading cargo build and clippy output
Issue-to-PR workflows: assigning work to cloud agents
MCP servers: connecting agents to internal tools and data

AI-Driven Testing in Depth

Generating unit and integration tests for cargo test
Property-based testing with proptest and AI assistance
Doctests: examples that document and verify at once
Designing for testability: letting AI surface seams and dependencies
Mutation-style review: testing the tests AI writes
Agentic code review and pull request automation
Maintaining suites over time: updating tests as code changes

AI-Assisted Debugging in Depth

Turning panics and backtraces into hypotheses: structured debugging prompts
Borrow checker, lifetime, and trait-bound errors: AI as compiler translator
Async debugging: stalled futures, deadlocks, and executor pitfalls
Log analysis and instrumenting with tracing for better AI diagnosis
Knowing when the AI is guessing: validating proposed fixes

Refactoring at Scale and Legacy Modernization

Multi-crate refactors: planning, executing, and reviewing with agents
Characterization tests as the safety net before any change
Rust-specific refactors: error-handling overhauls, trait extraction, API redesign
Edition migrations and dependency upgrades with AI assistance
Incremental modernization: strangler patterns over big rewrites
Keeping diffs reviewable: small steps over heroic changes

Documentation and Knowledge Work

Doc comments and compiling examples that match project conventions
cargo doc and docs.rs-quality documentation with AI assistance
READMEs, how-to guides, and onboarding docs from real code
Architecture decision records: drafting and maintaining ADRs with AI
Keeping documentation honest: reviewing generated prose for drift

Rust-Specific Pitfalls and Verification

Reviewing AI-generated unsafe code and FFI boundaries
Concurrency review: Send/Sync bounds and async pitfalls
Hallucinated crates and API versions; verifying against docs.rs
Clippy and rustfmt as quality gates for generated code
Performance review: allocations, clones, and needless copies

Security, Licensing, and Governance

Prompt injection and untrusted content in agent workflows
Secret leakage: what never goes in a prompt or context file
Crate supply-chain vetting: cargo-audit and cargo-deny
Licensing and IP status of AI-generated code
Organizational policy: approved tools, data boundaries, and audit trails
Review requirements: keeping humans accountable for shipped code

Measuring Impact, Cost, and Team Adoption

Tokens, model tiers, and budgets: managing cost without blunting value
Choosing the right model for the task: fast and cheap versus deep and slow
Re-evaluating the tool landscape: selection criteria, trials, and switching costs
Rollout patterns that work: champions, guilds, and paired onboarding
Metrics that matter - and vanity metrics that mislead
Adoption anti-patterns: mandates, leaderboards, and unreviewed merges