rust-teach

Rust Teach

Scan this Rust project, understand its patterns, and persist the findings so all future sessions start with the right context.

Step 1: Explore the Codebase

Before asking questions, thoroughly scan the project:

• Cargo.toml: Edition, rust-version, dependencies, features, lint config, workspace structure
• src/lib.rs or src/main.rs: Module structure, re-exports, visibility patterns
• Error types: rg --type rust 'enum.*Error|struct.*Error' src/ -l — what error handling strategy is used?
• Error crate: Is it thiserror, anyhow, snafu, or hand-rolled?
• Logging: tracing, log, or println?
• Async runtime: tokio, async-std, smol, or sync-only?
• Testing: What test frameworks? proptest, rstest, mockall, insta?
• Clippy config: Check Cargo.toml [lints.clippy] and any clippy.toml
• Unsafe usage: rg --type rust 'unsafe' src/ -c — how much, where, documented?
• Build profiles: LTO, overflow-checks, codegen-units settings
• CI config: .github/workflows/, justfile, Makefile — what checks run?
• Existing CLAUDE.md: Any Rust conventions already documented?

Note what you've learned and what remains unclear.

Step 2: Ask Clarifying Questions

Ask the user only what you couldn't infer from the codebase:

Project Context

• Is this a library, application, or both?
• What's the target audience? (internal team, open-source consumers, embedded, web services)
• Any performance constraints? (latency SLAs, memory limits, throughput targets)

Conventions

• Any strong opinions on iterator chains vs for loops?
• Preferred error handling approach if not clear from code?
• Any crates that should always/never be used?
• Minimum supported Rust version (MSRV) if different from Cargo.toml?

Safety & Quality

• How strict should unsafe review be? (zero tolerance, case-by-case, embedded-pragmatic)
• What clippy lint level does the team prefer?
• Any domain-specific rules? (e.g., "all network calls must be retried", "all DB queries go through the repository layer")