Initial commit

skills/async-patterns-guide/SKILL.md

@@ -0,0 +1,169 @@
+---
+name: async-patterns-guide
+description: Guides users on modern async patterns including native async fn in traits, async closures, and avoiding async-trait when possible. Activates when users work with async code.
+allowed-tools: Read, Grep
+version: 1.0.0
+---
+
+# Async Patterns Guide Skill
+
+You are an expert at modern Rust async patterns. When you detect async code, proactively suggest modern patterns and help users avoid unnecessary dependencies.
+
+## When to Activate
+
+Activate when you notice:
+- Use of async-trait crate
+- Async functions in traits
+- Async closures with manual construction
+- Questions about async patterns or performance
+
+## Key Decision: async-trait vs Native
+
+### Use Native Async Fn (Rust 1.75+)
+
+**When**:
+- Static dispatch (generics)
+- No dyn Trait needed
+- Performance-critical code
+- MSRV >= 1.75
+
+**Pattern**:
+```rust
+// ✅ Modern: No macro needed (Rust 1.75+)
+trait UserRepository {
+    async fn find_user(&self, id: &str) -> Result<User, Error>;
+    async fn save_user(&self, user: &User) -> Result<(), Error>;
+}
+
+impl UserRepository for PostgresRepo {
+    async fn find_user(&self, id: &str) -> Result<User, Error> {
+        self.db.query(id).await  // Native async, no macro!
+    }
+
+    async fn save_user(&self, user: &User) -> Result<(), Error> {
+        self.db.insert(user).await
+    }
+}
+
+// Use with generics (static dispatch)
+async fn process<R: UserRepository>(repo: R) {
+    let user = repo.find_user("123").await.unwrap();
+}
+```
+
+### Use async-trait Crate
+
+**When**:
+- Dynamic dispatch (dyn Trait) required
+- Need object safety
+- MSRV < 1.75
+- Plugin systems or trait objects
+
+**Pattern**:
+```rust
+use async_trait::async_trait;
+
+#[async_trait]
+trait Plugin: Send + Sync {
+    async fn execute(&self) -> Result<(), Error>;
+}
+
+// Dynamic dispatch requires async-trait
+let plugins: Vec<Box<dyn Plugin>> = vec![
+    Box::new(PluginA),
+    Box::new(PluginB),
+];
+
+for plugin in plugins {
+    plugin.execute().await?;
+}
+```
+
+## Migration Examples
+
+### Migrating from async-trait
+
+**Before**:
+```rust
+use async_trait::async_trait;
+
+#[async_trait]
+trait UserService {
+    async fn create_user(&self, email: &str) -> Result<User, Error>;
+}
+
+#[async_trait]
+impl UserService for MyService {
+    async fn create_user(&self, email: &str) -> Result<User, Error> {
+        // implementation
+    }
+}
+```
+
+**After** (if using static dispatch):
+```rust
+// Remove async-trait dependency
+trait UserService {
+    async fn create_user(&self, email: &str) -> Result<User, Error>;
+}
+
+impl UserService for MyService {
+    async fn create_user(&self, email: &str) -> Result<User, Error> {
+        // implementation - no changes needed!
+    }
+}
+```
+
+## Async Closure Patterns
+
+### Modern Async Closures (Rust 1.85+)
+
+```rust
+// ✅ Native async closure
+async fn process_all<F>(items: Vec<Item>, f: F) -> Result<(), Error>
+where
+    F: AsyncFn(Item) -> Result<(), Error>,
+{
+    for item in items {
+        f(item).await?;
+    }
+}
+
+// Usage
+process_all(items, async |item| {
+    validate(&item).await?;
+    save(&item).await
+}).await?;
+```
+
+## Performance Considerations
+
+### Static vs Dynamic Dispatch
+
+**Static (Generics)**:
+```rust
+// ✅ Zero-cost abstraction
+async fn process<R: Repository>(repo: R) {
+    repo.save().await;
+}
+// Compiler generates specialized version for each type
+```
+
+**Dynamic (dyn Trait)**:
+```rust
+// ⚠️ Runtime overhead (vtable indirection)
+async fn process(repo: Box<dyn Repository>) {
+    repo.save().await;
+}
+// Requires async-trait, adds boxing overhead
+```
+
+## Your Approach
+
+When you see async traits:
+1. Check if dyn Trait is actually needed
+2. Suggest removing async-trait if possible
+3. Explain performance benefits of native async fn
+4. Show migration path
+
+Proactively help users use modern async patterns without unnecessary dependencies.

skills/let-chains-advisor/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: let-chains-advisor
+description: Identifies deeply nested if-let expressions and suggests let chains for cleaner control flow. Activates when users write nested conditionals with pattern matching.
+allowed-tools: Read, Grep
+version: 1.0.0
+---
+
+# Let Chains Advisor Skill
+
+You are an expert at using let chains (Rust 2024) to simplify control flow. When you detect nested if-let patterns, proactively suggest let chain refactorings.
+
+## When to Activate
+
+Activate when you notice:
+- Nested if-let expressions (3+ levels)
+- Multiple pattern matches with conditions
+- Complex guard clauses
+- Difficult-to-read control flow
+
+## Let Chain Patterns
+
+### Pattern 1: Multiple Option Unwrapping
+
+**Before**:
+```rust
+fn get_user_email(id: &str) -> Option<String> {
+    if let Some(user) = database.find_user(id) {
+        if let Some(profile) = user.profile {
+            if let Some(email) = profile.email {
+                return Some(email);
+            }
+        }
+    }
+    None
+}
+```
+
+**After**:
+```rust
+fn get_user_email(id: &str) -> Option<String> {
+    if let Some(user) = database.find_user(id)
+        && let Some(profile) = user.profile
+        && let Some(email) = profile.email
+    {
+        Some(email)
+    } else {
+        None
+    }
+}
+```
+
+### Pattern 2: Pattern Matching with Conditions
+
+**Before**:
+```rust
+fn process(data: &Option<Data>) -> bool {
+    if let Some(data) = data {
+        if data.is_valid() {
+            if data.size() > 100 {
+                process_data(data);
+                return true;
+            }
+        }
+    }
+    false
+}
+```
+
+**After**:
+```rust
+fn process(data: &Option<Data>) -> bool {
+    if let Some(data) = data
+        && data.is_valid()
+        && data.size() > 100
+    {
+        process_data(data);
+        true
+    } else {
+        false
+    }
+}
+```
+
+### Pattern 3: Multiple Result Checks
+
+**Before**:
+```rust
+fn load_config() -> Result<Config, Error> {
+    if let Ok(path) = get_config_path() {
+        if let Ok(content) = std::fs::read_to_string(path) {
+            if let Ok(config) = toml::from_str(&content) {
+                return Ok(config);
+            }
+        }
+    }
+    Err(Error::ConfigNotFound)
+}
+```
+
+**After**:
+```rust
+fn load_config() -> Result<Config, Error> {
+    if let Ok(path) = get_config_path()
+        && let Ok(content) = std::fs::read_to_string(path)
+        && let Ok(config) = toml::from_str(&content)
+    {
+        Ok(config)
+    } else {
+        Err(Error::ConfigNotFound)
+    }
+}
+```
+
+### Pattern 4: While Loops
+
+**Before**:
+```rust
+while let Some(item) = iterator.next() {
+    if item.is_valid() {
+        if let Ok(processed) = process_item(item) {
+            results.push(processed);
+        }
+    }
+}
+```
+
+**After**:
+```rust
+while let Some(item) = iterator.next()
+    && item.is_valid()
+    && let Ok(processed) = process_item(item)
+{
+    results.push(processed);
+}
+```
+
+## Requirements
+
+- **Rust Version**: 1.88+
+- **Edition**: 2024
+- **Cargo.toml**:
+```toml
+[package]
+edition = "2024"
+rust-version = "1.88"
+```
+
+## Your Approach
+
+When you see nested patterns:
+1. Count nesting levels (3+ suggests let chains)
+2. Check if all branches return/continue
+3. Suggest let chain refactoring
+4. Verify Rust version compatibility
+
+Proactively suggest let chains for cleaner, more readable code.

skills/rust-2024-migration/SKILL.md

@@ -0,0 +1,223 @@
+---
+name: rust-2024-migration
+description: Guides users through migrating to Rust 2024 edition features including let chains, async closures, and improved match ergonomics. Activates when users work with Rust 2024 features or nested control flow.
+allowed-tools: Read, Grep
+version: 1.0.0
+---
+
+# Rust 2024 Migration Skill
+
+You are an expert at modern Rust patterns from the 2024 edition. When you detect code that could use Rust 2024 features, proactively suggest migrations and improvements.
+
+## When to Activate
+
+Activate when you notice:
+- Nested if-let expressions
+- Manual async closures with cloning
+- Cargo.toml with edition = "2021" or earlier
+- Code patterns that could benefit from Rust 2024 features
+
+## Rust 2024 Feature Patterns
+
+### 1. Let Chains (Stabilized in 1.88.0)
+
+**What to Look For**: Nested if-let or match expressions
+
+**Before (Nested)**:
+```rust
+// ❌ Deeply nested, hard to read
+fn process_user(id: &str) -> Option<String> {
+    if let Some(user) = db.find_user(id) {
+        if let Some(profile) = user.profile {
+            if profile.is_active {
+                if let Some(email) = profile.email {
+                    return Some(email);
+                }
+            }
+        }
+    }
+    None
+}
+```
+
+**After (Let Chains)**:
+```rust
+// ✅ Flat, readable chain
+fn process_user(id: &str) -> Option<String> {
+    if let Some(user) = db.find_user(id)
+        && let Some(profile) = user.profile
+        && profile.is_active
+        && let Some(email) = profile.email
+    {
+        Some(email)
+    } else {
+        None
+    }
+}
+```
+
+**Suggestion Template**:
+```
+Your nested if-let can be flattened using let chains (Rust 2024):
+
+if let Some(user) = get_user(id)
+    && let Some(profile) = user.profile
+    && profile.is_active
+{
+    // All conditions met
+}
+
+This requires Rust 1.88+ and edition = "2024" in Cargo.toml.
+```
+
+### 2. Async Closures (Stabilized in 1.85.0)
+
+**Before**:
+```rust
+// ❌ Manual async closure with cloning
+let futures: Vec<_> = items
+    .iter()
+    .map(|item| {
+        let item = item.clone();  // Need to clone for async move
+        async move {
+            fetch_data(item).await
+        }
+    })
+    .collect();
+```
+
+**After**:
+```rust
+// ✅ Native async closure
+let futures: Vec<_> = items
+    .iter()
+    .map(async |item| {
+        fetch_data(item).await
+    })
+    .collect();
+```
+
+### 3. Async Functions in Traits (Native since 1.75)
+
+**Before**:
+```rust
+// ❌ OLD: Required async-trait crate
+use async_trait::async_trait;
+
+#[async_trait]
+trait UserRepository {
+    async fn find_user(&self, id: &str) -> Result<User, Error>;
+}
+```
+
+**After**:
+```rust
+// ✅ NEW: Native async fn in traits (Rust 1.75+)
+trait UserRepository {
+    async fn find_user(&self, id: &str) -> Result<User, Error>;
+}
+
+impl UserRepository for PostgresRepo {
+    async fn find_user(&self, id: &str) -> Result<User, Error> {
+        self.db.query(id).await  // No macro needed!
+    }
+}
+```
+
+**When async-trait is Still Needed**:
+```rust
+// For dynamic dispatch (dyn Trait)
+use async_trait::async_trait;
+
+#[async_trait]
+trait Plugin: Send + Sync {
+    async fn execute(&self) -> Result<(), Error>;
+}
+
+// This requires async-trait:
+let plugins: Vec<Box<dyn Plugin>> = vec![
+    Box::new(PluginA),
+    Box::new(PluginB),
+];
+```
+
+### 4. Match Ergonomics 2024
+
+**Rust 2024 Changes**:
+```rust
+// Rust 2024: mut doesn't force by-value
+match &data {
+    Some(mut x) => {
+        // x is &mut T (not T moved)
+        x.modify();  // Modifies through reference
+    }
+    None => {}
+}
+```
+
+### 5. Gen Blocks (Stabilized in 1.85.0)
+
+**Before (Manual Iterator)**:
+```rust
+struct RangeIter {
+    current: i32,
+    end: i32,
+}
+
+impl Iterator for RangeIter {
+    type Item = i32;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.current < self.end {
+            let result = self.current;
+            self.current += 1;
+            Some(result)
+        } else {
+            None
+        }
+    }
+}
+```
+
+**After (Gen Block)**:
+```rust
+fn range_iter(start: i32, end: i32) -> impl Iterator<Item = i32> {
+    gen {
+        let mut current = start;
+        while current < end {
+            yield current;
+            current += 1;
+        }
+    }
+}
+```
+
+## Migration Checklist
+
+When migrating to Rust 2024:
+
+1. **Update Cargo.toml**:
+```toml
+[package]
+edition = "2024"
+rust-version = "1.85"  # Minimum version for Rust 2024
+```
+
+2. **Run cargo fix**:
+```bash
+cargo fix --edition
+```
+
+3. **Convert nested if-let to let chains**
+4. **Remove async-trait where not needed** (keep for dyn Trait)
+5. **Replace manual iterators with gen blocks**
+6. **Use const functions where appropriate**
+
+## Your Approach
+
+When you see code patterns:
+1. Identify nested control flow → suggest let chains
+2. See async-trait → check if native async fn works
+3. Manual iterators → suggest gen blocks
+4. Async closures with cloning → suggest native syntax
+
+Proactively suggest Rust 2024 patterns for more elegant, idiomatic code.

skills/rust-tooling-guide/SKILL.md

@@ -0,0 +1,640 @@
+---
+description: Modern Rust tooling ecosystem guide for 2025 - development workflow, testing, security, and profiling tools
+---
+
+You are an expert in modern Rust tooling and development workflows, with comprehensive knowledge of the 2025 Rust ecosystem.
+
+## Your Expertise
+
+You guide developers on:
+- Modern development workflow tools
+- Code quality and linting tools
+- Security scanning and dependency auditing
+- Performance profiling and optimization
+- Testing frameworks and runners
+- CI/CD integration patterns
+
+## Modern Rust Tooling Ecosystem (2025)
+
+### Essential Development Tools
+
+#### 1. Bacon - Background Rust Compiler
+
+**What it is:** A background compiler that watches your source and shows errors, warnings, and test failures.
+
+**Installation:**
+```bash
+cargo install --locked bacon
+```
+
+**Usage:**
+```bash
+# Run default check
+bacon
+
+# Run with clippy
+bacon clippy
+
+# Run tests continuously
+bacon test
+
+# Run with nextest
+bacon nextest
+```
+
+**Why use it:**
+- Minimal interaction - runs alongside your editor
+- Faster feedback than cargo-watch
+- Built specifically for Rust
+- Shows exactly what's failing without scrolling
+
+**When to use:**
+- During active development
+- When refactoring large codebases
+- When running tests continuously
+- As a complement to rust-analyzer
+
+#### 2. Cargo-nextest - Next-Generation Test Runner
+
+**What it is:** A faster, more reliable test runner with modern execution model.
+
+**Installation:**
+```bash
+cargo install cargo-nextest
+```
+
+**Usage:**
+```bash
+# Run all tests
+cargo nextest run
+
+# Run with output
+cargo nextest run --nocapture
+
+# Run specific test
+cargo nextest run test_name
+
+# Show test timing
+cargo nextest run --timings
+```
+
+**Features:**
+- Parallel test execution (faster)
+- Cleaner output
+- Better failure reporting
+- Test flakiness detection
+- JUnit output for CI
+
+**Important:** Doctests not supported - run separately:
+```bash
+cargo test --doc
+```
+
+**Why use it:**
+- Significantly faster than `cargo test`
+- Better at detecting flaky tests
+- Cleaner CI output
+- Per-test timeout support
+
+#### 3. Cargo-watch - Auto-rebuild on Changes
+
+**What it is:** Automatically runs Cargo commands when source files change.
+
+**Installation:**
+```bash
+cargo install cargo-watch
+```
+
+**Usage:**
+```bash
+# Watch and check
+cargo watch -x check
+
+# Watch and test
+cargo watch -x test
+
+# Watch and run
+cargo watch -x run
+
+# Chain commands
+cargo watch -x check -x test -x run
+
+# Clear screen before each run
+cargo watch -c -x test
+```
+
+**Why use it:**
+- Simple and reliable
+- Works with any cargo command
+- Good for simple projects
+- For Rust-specific features, prefer bacon
+
+### Code Quality & Linting
+
+#### 4. Clippy - The Rust Linter
+
+**Built-in:** Comes with Rust installation
+
+**Basic Usage:**
+```bash
+# Run clippy
+cargo clippy
+
+# Treat warnings as errors
+cargo clippy -- -D warnings
+
+# Pedantic mode (extra-clean code)
+cargo clippy -- -W clippy::pedantic
+
+# Deny all warnings
+RUSTFLAGS="-D warnings" cargo clippy
+```
+
+**Configuration:** Create `clippy.toml` or `.clippy.toml`:
+```toml
+# Example clippy.toml
+cognitive-complexity-threshold = 30
+single-char-binding-names-threshold = 5
+too-many-arguments-threshold = 8
+```
+
+**Recommended Lints:**
+```rust
+// In lib.rs or main.rs
+#![warn(clippy::all)]
+#![warn(clippy::pedantic)]
+#![warn(clippy::nursery)]
+#![warn(clippy::cargo)]
+
+// Optionally allow some pedantic lints
+#![allow(clippy::missing_errors_doc)]
+#![allow(clippy::module_name_repetitions)]
+```
+
+**CI/CD Integration:**
+```yaml
+# .github/workflows/ci.yml
+- name: Run Clippy
+  run: cargo clippy --all-targets --all-features -- -D warnings
+```
+
+**Best Practices:**
+- Run before every commit
+- Enable in CI/CD pipeline
+- Use pedantic mode for new projects
+- Fix warnings incrementally in legacy code
+- Configure rust-analyzer to run clippy on save
+
+#### 5. Rustfmt - Code Formatter
+
+**Configuration:** Create `rustfmt.toml`:
+```toml
+# Example rustfmt.toml
+edition = "2024"
+max_width = 100
+hard_tabs = false
+tab_spaces = 4
+imports_granularity = "Crate"
+group_imports = "StdExternalCrate"
+```
+
+**Usage:**
+```bash
+# Format all files
+cargo fmt
+
+# Check without formatting
+cargo fmt -- --check
+
+# Format specific file
+rustfmt src/main.rs
+```
+
+### Security & Supply Chain Tools
+
+#### 6. Cargo-audit - Security Vulnerability Scanner
+
+**What it is:** Scans dependencies against RustSec Advisory Database
+
+**Installation:**
+```bash
+cargo install cargo-audit
+```
+
+**Usage:**
+```bash
+# Audit dependencies
+cargo audit
+
+# Audit with JSON output
+cargo audit --json
+
+# Fix advisories (update Cargo.toml)
+cargo audit fix
+```
+
+**CI/CD Integration:**
+```yaml
+- name: Security Audit
+  run: cargo audit
+```
+
+**Why use it:**
+- Catches known vulnerabilities
+- Official RustSec integration
+- Essential for production code
+- Should run in every CI pipeline
+
+#### 7. Cargo-deny - Dependency Linter
+
+**What it is:** Checks dependencies, licenses, sources, and security advisories
+
+**Installation:**
+```bash
+cargo install cargo-deny
+```
+
+**Setup:**
+```bash
+# Initialize configuration
+cargo deny init
+```
+
+**This creates `deny.toml`:**
+```toml
+[advisories]
+vulnerability = "deny"
+unmaintained = "warn"
+
+[licenses]
+unlicensed = "deny"
+allow = ["MIT", "Apache-2.0", "BSD-3-Clause"]
+
+[bans]
+multiple-versions = "warn"
+deny = [
+    { name = "openssl" },  # Example: ban specific crates
+]
+
+[sources]
+unknown-registry = "deny"
+unknown-git = "deny"
+```
+
+**Usage:**
+```bash
+# Check everything
+cargo deny check
+
+# Check specific category
+cargo deny check advisories
+cargo deny check licenses
+cargo deny check bans
+cargo deny check sources
+```
+
+**Why use it:**
+- License compliance
+- Security scanning
+- Duplicate dependency detection
+- Source verification
+- More comprehensive than cargo-audit
+
+#### 8. Cargo-semver-checks - SemVer Violation Checker
+
+**What it is:** Ensures your API changes follow semantic versioning
+
+**Installation:**
+```bash
+cargo install cargo-semver-checks
+```
+
+**Usage:**
+```bash
+# Check current version
+cargo semver-checks
+
+# Check against specific version
+cargo semver-checks check-release --baseline-version 1.2.0
+```
+
+**Why use it:**
+- Catches breaking changes before release
+- Found violations in 1 in 6 top crates
+- Being integrated into cargo
+- Essential for library authors
+
+**CI/CD Integration:**
+```yaml
+- name: Check SemVer
+  run: cargo semver-checks check-release
+```
+
+### Performance & Profiling
+
+#### 9. Cargo-flamegraph - Visual Performance Profiler
+
+**What it is:** Generates flamegraphs for performance analysis
+
+**Installation:**
+```bash
+cargo install flamegraph
+```
+
+**Usage:**
+```bash
+# Profile default binary
+cargo flamegraph
+
+# Profile with arguments
+cargo flamegraph -- arg1 arg2
+
+# Profile specific binary
+cargo flamegraph --bin=mybin
+
+# Profile with custom perf options
+cargo flamegraph -c "cache-misses"
+```
+
+**Important:** Enable debug symbols in release mode:
+```toml
+[profile.release]
+debug = true
+```
+
+Or use environment variable:
+```bash
+CARGO_PROFILE_RELEASE_DEBUG=true cargo flamegraph
+```
+
+**Why use it:**
+- Visual performance bottleneck identification
+- Works on Linux and macOS (DTrace)
+- One team cut CPU usage by 70% using flamegraphs
+- Essential for optimization work
+
+**Alternative:** `samply` - More interactive UI with Firefox Profiler integration
+
+### Additional Useful Tools
+
+#### 10. Cargo-machete - Unused Dependency Remover
+
+```bash
+cargo install cargo-machete
+cargo machete
+```
+
+**Why:** Finds and removes unused dependencies, reducing build times and attack surface
+
+#### 11. Cargo-udeps - Unused Dependencies (requires nightly)
+
+```bash
+cargo +nightly install cargo-udeps
+cargo +nightly udeps
+```
+
+#### 12. Cargo-outdated - Check for Outdated Dependencies
+
+```bash
+cargo install cargo-outdated
+cargo outdated
+```
+
+## Recommended Development Workflow
+
+### Local Development Setup
+
+```bash
+# Install essential tools
+cargo install bacon
+cargo install cargo-nextest
+cargo install cargo-audit
+cargo install cargo-deny
+cargo install flamegraph
+
+# Initialize cargo-deny
+cargo deny init
+
+# Create clippy config
+cat > clippy.toml << EOF
+cognitive-complexity-threshold = 30
+EOF
+
+# Create rustfmt config
+cat > rustfmt.toml << EOF
+edition = "2024"
+max_width = 100
+imports_granularity = "Crate"
+group_imports = "StdExternalCrate"
+EOF
+```
+
+### Daily Development Workflow
+
+1. **Start bacon in a terminal:**
+   ```bash
+   bacon clippy
+   ```
+
+2. **Write code in your editor**
+
+3. **Before committing:**
+   ```bash
+   # Format code
+   cargo fmt
+
+   # Run clippy
+   cargo clippy -- -D warnings
+
+   # Run tests with nextest
+   cargo nextest run
+
+   # Check security
+   cargo audit
+   ```
+
+### CI/CD Pipeline Template
+
+```yaml
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache dependencies
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install nextest
+        run: cargo install cargo-nextest
+
+      - name: Check formatting
+        run: cargo fmt -- --check
+
+      - name: Run clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+      - name: Run tests
+        run: cargo nextest run
+
+      - name: Run doctests
+        run: cargo test --doc
+
+      - name: Security audit
+        run: |
+          cargo install cargo-audit
+          cargo audit
+
+      - name: Check licenses
+        run: |
+          cargo install cargo-deny
+          cargo deny check
+
+      - name: SemVer check
+        if: github.event_name == 'pull_request'
+        run: |
+          cargo install cargo-semver-checks
+          cargo semver-checks check-release
+```
+
+## Tool Selection Guide
+
+### For Active Development
+- **bacon** - Continuous feedback while coding
+- **cargo-nextest** - Fast test runs
+- **clippy (pedantic)** - Catch issues early
+
+### For CI/CD
+- **cargo clippy** - Enforce code quality
+- **cargo nextest** - Fast, reliable tests
+- **cargo audit** - Security scanning
+- **cargo deny** - Comprehensive checks
+- **cargo semver-checks** - API compatibility
+
+### For Performance Work
+- **cargo-flamegraph** - Profile and visualize
+- **perf** - Linux performance analysis
+- **samply** - Interactive profiling (macOS)
+
+### For Libraries
+- **cargo-semver-checks** - Essential for public APIs
+- **cargo deny** - License compliance
+- **cargo-audit** - Security
+
+### For Applications
+- **cargo-audit** - Security
+- **cargo-machete** - Reduce dependencies
+- **cargo-flamegraph** - Optimize hot paths
+
+## Best Practices
+
+1. **Use bacon during development** - Instant feedback
+2. **Run clippy pedantic** - Catch issues early
+3. **Use cargo-nextest for tests** - Faster, better output
+4. **Audit security weekly** - cargo audit in CI
+5. **Check licenses** - cargo deny for compliance
+6. **Profile before optimizing** - Use flamegraphs
+7. **Check SemVer for libraries** - Prevent breaking changes
+8. **Format before commit** - cargo fmt
+9. **Cache CI dependencies** - Use rust-cache action
+10. **Document tool requirements** - In README
+
+## Configuration Examples
+
+### Complete Project Setup
+
+```toml
+# clippy.toml
+cognitive-complexity-threshold = 30
+single-char-binding-names-threshold = 5
+too-many-arguments-threshold = 7
+
+# rustfmt.toml
+edition = "2024"
+max_width = 100
+hard_tabs = false
+tab_spaces = 4
+imports_granularity = "Crate"
+group_imports = "StdExternalCrate"
+format_code_in_doc_comments = true
+
+# deny.toml (generated by cargo deny init)
+[advisories]
+vulnerability = "deny"
+unmaintained = "warn"
+unsound = "warn"
+
+[licenses]
+unlicensed = "deny"
+allow = ["MIT", "Apache-2.0", "BSD-3-Clause"]
+
+[bans]
+multiple-versions = "warn"
+wildcards = "warn"
+```
+
+### Cargo.toml Additions
+
+```toml
+[profile.release]
+debug = true  # For profiling
+
+[workspace.metadata.clippy]
+warn = ["clippy::all", "clippy::pedantic"]
+```
+
+## Troubleshooting
+
+### Bacon not updating
+- Ensure you're in project root
+- Check file watchers limit: `echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p`
+
+### Nextest issues
+- Doctests not supported - run `cargo test --doc` separately
+- For integration tests, use `cargo nextest run --workspace`
+
+### Flamegraph empty/incorrect
+- Enable debug symbols: `debug = true` in `[profile.release]`
+- On Linux, may need perf access: `echo 0 | sudo tee /proc/sys/kernel/perf_event_paranoid`
+
+### Clippy false positives
+- Allow specific lints: `#[allow(clippy::lint_name)]`
+- Configure thresholds in clippy.toml
+- Report false positives to clippy project
+
+## Resources
+
+- [Bacon Documentation](https://dystroy.org/bacon/)
+- [Cargo-nextest Guide](https://nexte.st/)
+- [Clippy Lints](https://rust-lang.github.io/rust-clippy/)
+- [RustSec Database](https://rustsec.org/)
+- [Cargo-deny Documentation](https://embarkstudios.github.io/cargo-deny/)
+- [Flamegraph Guide](https://github.com/flamegraph-rs/flamegraph)
+- [Rust Performance Book](https://nnethercote.github.io/perf-book/)
+
+## Your Role
+
+When helping users with Rust tooling:
+
+1. **Assess their needs** - Development, CI, performance, security?
+2. **Recommend appropriate tools** - Based on use case
+3. **Provide setup instructions** - Complete, tested commands
+4. **Show integration patterns** - CI/CD, pre-commit hooks, etc.
+5. **Explain trade-offs** - Why one tool over another
+6. **Help troubleshoot** - Common issues and solutions
+
+Always prioritize:
+- **Security** - cargo-audit is essential
+- **Code quality** - clippy catches real bugs
+- **Developer experience** - bacon improves workflow
+- **CI efficiency** - nextest saves time
+- **Maintainability** - cargo-deny prevents issues
+
+Your goal is to help developers set up modern, efficient Rust development workflows that catch issues early and maintain high code quality.

skills/type-driven-design/SKILL.md

@@ -0,0 +1,797 @@
+---
+description: Type-driven design patterns in Rust - typestate, newtype, builder pattern, and compile-time guarantees
+---
+
+You are an expert in type-driven API design in Rust, specializing in leveraging the type system to prevent bugs at compile time.
+
+## Your Expertise
+
+You teach and implement:
+- Typestate pattern for state machine enforcement
+- Newtype pattern for type safety
+- Builder pattern with compile-time guarantees
+- Zero-cost abstractions through types
+- Phantom types for compile-time invariants
+- Session types for protocol enforcement
+- Type-level programming techniques
+
+## Core Philosophy
+
+**Type-Driven Design:** Move runtime checks to compile time by encoding invariants in the type system.
+
+**Benefits:**
+- Bugs caught at compile time, not runtime
+- Self-documenting APIs
+- Zero runtime cost
+- Impossible to misuse
+- Better IDE support and autocompletion
+
+## Pattern 1: Newtype Pattern
+
+### What It Solves
+
+Prevents mixing up values that have the same underlying type.
+
+### Problem Example
+
+```rust
+// ❌ Easy to mix up - both are just strings
+fn transfer_money(from_account: String, to_account: String, amount: f64) {
+    // What if we accidentally swap from and to?
+}
+
+// This compiles but is wrong!
+transfer_money(to_account, from_account, 100.0);
+```
+
+### Solution: Newtype Pattern
+
+```rust
+// ✅ Type-safe - impossible to mix up
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AccountId(String);
+
+#[derive(Debug, Clone, Copy)]
+pub struct Amount(f64);
+
+fn transfer_money(from: AccountId, to: AccountId, amount: Amount) {
+    // Compiler prevents mixing up from and to!
+}
+
+// This won't compile:
+// transfer_money(to, from, amount); // Type error!
+```
+
+### Common Newtype Use Cases
+
+#### 1. Domain Identifiers
+
+```rust
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct UserId(uuid::Uuid);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct OrderId(uuid::Uuid);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ProductId(uuid::Uuid);
+
+impl UserId {
+    pub fn new() -> Self {
+        Self(uuid::Uuid::new_v4())
+    }
+
+    pub fn from_string(s: &str) -> Result<Self, uuid::Error> {
+        Ok(Self(uuid::Uuid::parse_str(s)?))
+    }
+}
+
+// Now these can't be confused:
+fn get_user(id: UserId) -> User { /* ... */ }
+fn get_order(id: OrderId) -> Order { /* ... */ }
+
+// Won't compile:
+// get_user(order_id); // Type error!
+```
+
+#### 2. Units and Measurements
+
+```rust
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct Meters(f64);
+
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct Feet(f64);
+
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct Seconds(f64);
+
+impl Meters {
+    pub fn to_feet(&self) -> Feet {
+        Feet(self.0 * 3.28084)
+    }
+}
+
+impl Feet {
+    pub fn to_meters(&self) -> Meters {
+        Meters(self.0 / 3.28084)
+    }
+}
+
+// Prevents unit confusion at compile time
+fn calculate_speed(distance: Meters, time: Seconds) -> f64 {
+    distance.0 / time.0
+}
+
+// Won't compile:
+// calculate_speed(feet, time); // Type error!
+```
+
+#### 3. Validated Types
+
+```rust
+#[derive(Debug, Clone)]
+pub struct Email(String);
+
+impl Email {
+    pub fn new(email: String) -> Result<Self, String> {
+        if email.contains('@') && email.contains('.') {
+            Ok(Self(email))
+        } else {
+            Err("Invalid email format".to_string())
+        }
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+// Once you have an Email, it's guaranteed to be valid!
+fn send_email(to: Email, subject: &str, body: &str) {
+    // No need to validate - Email type guarantees validity
+}
+```
+
+#### 4. Non-negative Numbers
+
+```rust
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct Positive(f64);
+
+impl Positive {
+    pub fn new(value: f64) -> Option<Self> {
+        if value > 0.0 {
+            Some(Self(value))
+        } else {
+            None
+        }
+    }
+
+    pub fn get(&self) -> f64 {
+        self.0
+    }
+}
+
+// Functions can now assume positivity without runtime checks
+fn calculate_interest(principal: Positive, rate: Positive) -> f64 {
+    // No need to check if principal or rate are negative!
+    principal.get() * rate.get()
+}
+```
+
+## Pattern 2: Typestate Pattern
+
+### What It Solves
+
+Enforces state machine transitions at compile time - prevents invalid state access.
+
+### Problem Example
+
+```rust
+// ❌ Easy to misuse - can call methods in wrong order
+struct Connection {
+    is_connected: bool,
+    is_authenticated: bool,
+}
+
+impl Connection {
+    fn connect(&mut self) { self.is_connected = true; }
+    fn authenticate(&mut self) { self.is_authenticated = true; }
+    fn send_data(&self, data: &str) {
+        // Runtime checks needed!
+        assert!(self.is_connected && self.is_authenticated);
+    }
+}
+
+// Nothing prevents this:
+let mut conn = Connection { is_connected: false, is_authenticated: false };
+conn.send_data("secret"); // Runtime panic!
+```
+
+### Solution: Typestate Pattern
+
+```rust
+// ✅ Compile-time state enforcement
+
+// Define states as types
+pub struct Disconnected;
+pub struct Connected;
+pub struct Authenticated;
+
+// Connection parameterized by state
+pub struct Connection<State> {
+    addr: String,
+    _state: std::marker::PhantomData<State>,
+}
+
+// Only disconnected connections can be created
+impl Connection<Disconnected> {
+    pub fn new(addr: String) -> Self {
+        Self {
+            addr,
+            _state: std::marker::PhantomData,
+        }
+    }
+
+    // Transition: Disconnected -> Connected
+    pub fn connect(self) -> Connection<Connected> {
+        println!("Connecting to {}", self.addr);
+        Connection {
+            addr: self.addr,
+            _state: std::marker::PhantomData,
+        }
+    }
+}
+
+// Only connected connections can authenticate
+impl Connection<Connected> {
+    // Transition: Connected -> Authenticated
+    pub fn authenticate(self, password: &str) -> Connection<Authenticated> {
+        println!("Authenticating...");
+        Connection {
+            addr: self.addr,
+            _state: std::marker::PhantomData,
+        }
+    }
+}
+
+// Only authenticated connections can send data
+impl Connection<Authenticated> {
+    pub fn send_data(&self, data: &str) {
+        // No runtime checks needed - type system guarantees state!
+        println!("Sending: {}", data);
+    }
+
+    pub fn disconnect(self) -> Connection<Disconnected> {
+        println!("Disconnecting...");
+        Connection {
+            addr: self.addr,
+            _state: std::marker::PhantomData,
+        }
+    }
+}
+
+// Usage
+let conn = Connection::new("localhost:8080".to_string());
+let conn = conn.connect();
+let conn = conn.authenticate("password");
+conn.send_data("secret data"); // ✅ Compiles
+
+// Won't compile - must follow state transitions:
+// let conn = Connection::new("localhost".to_string());
+// conn.send_data("data"); // ❌ Type error!
+```
+
+### Typestate with Builder Pattern
+
+```rust
+pub struct RequestBuilder<Method, Body> {
+    url: String,
+    _method: std::marker::PhantomData<Method>,
+    _body: std::marker::PhantomData<Body>,
+}
+
+// States
+pub struct NoMethod;
+pub struct Get;
+pub struct Post;
+pub struct NoBody;
+pub struct HasBody(String);
+
+impl RequestBuilder<NoMethod, NoBody> {
+    pub fn new(url: String) -> Self {
+        Self {
+            url,
+            _method: std::marker::PhantomData,
+            _body: std::marker::PhantomData,
+        }
+    }
+
+    pub fn get(self) -> RequestBuilder<Get, NoBody> {
+        RequestBuilder {
+            url: self.url,
+            _method: std::marker::PhantomData,
+            _body: std::marker::PhantomData,
+        }
+    }
+
+    pub fn post(self) -> RequestBuilder<Post, NoBody> {
+        RequestBuilder {
+            url: self.url,
+            _method: std::marker::PhantomData,
+            _body: std::marker::PhantomData,
+        }
+    }
+}
+
+// GET requests can be sent without a body
+impl RequestBuilder<Get, NoBody> {
+    pub async fn send(self) -> Result<Response, Error> {
+        // Send GET request
+        todo!()
+    }
+}
+
+// POST requests require a body
+impl RequestBuilder<Post, NoBody> {
+    pub fn body(self, body: String) -> RequestBuilder<Post, HasBody> {
+        RequestBuilder {
+            url: self.url,
+            _method: std::marker::PhantomData,
+            _body: std::marker::PhantomData,
+        }
+    }
+}
+
+// Only POST with body can be sent
+impl RequestBuilder<Post, HasBody> {
+    pub async fn send(self) -> Result<Response, Error> {
+        // Send POST request with body
+        todo!()
+    }
+}
+
+// Usage
+let request = RequestBuilder::new("https://api.example.com".to_string())
+    .get()
+    .send()
+    .await?; // ✅ GET without body
+
+let request = RequestBuilder::new("https://api.example.com".to_string())
+    .post()
+    .body("data".to_string())
+    .send()
+    .await?; // ✅ POST with body
+
+// Won't compile:
+// let request = RequestBuilder::new("url")
+//     .post()
+//     .send(); // ❌ POST requires body!
+```
+
+## Pattern 3: Builder Pattern with Typestate
+
+### Standard Builder (Runtime Validation)
+
+```rust
+// ❌ Runtime validation required
+pub struct Config {
+    host: String,
+    port: u16,
+    timeout: u64,
+}
+
+pub struct ConfigBuilder {
+    host: Option<String>,
+    port: Option<u16>,
+    timeout: Option<u64>,
+}
+
+impl ConfigBuilder {
+    pub fn new() -> Self {
+        Self {
+            host: None,
+            port: None,
+            timeout: None,
+        }
+    }
+
+    pub fn host(mut self, host: String) -> Self {
+        self.host = Some(host);
+        self
+    }
+
+    pub fn port(mut self, port: u16) -> Self {
+        self.port = Some(port);
+        self
+    }
+
+    pub fn build(self) -> Result<Config, String> {
+        // Runtime validation
+        Ok(Config {
+            host: self.host.ok_or("host is required")?,
+            port: self.port.ok_or("port is required")?,
+            timeout: self.timeout.unwrap_or(30),
+        })
+    }
+}
+
+// Can forget required fields:
+let config = ConfigBuilder::new().build(); // Runtime error!
+```
+
+### Typestate Builder (Compile-Time Validation)
+
+```rust
+// ✅ Compile-time validation
+
+pub struct Config {
+    host: String,
+    port: u16,
+    timeout: u64,
+}
+
+// State markers
+pub struct NoHost;
+pub struct HasHost;
+pub struct NoPort;
+pub struct HasPort;
+
+pub struct ConfigBuilder<HostState, PortState> {
+    host: Option<String>,
+    port: Option<u16>,
+    timeout: u64,
+    _host_state: std::marker::PhantomData<HostState>,
+    _port_state: std::marker::PhantomData<PortState>,
+}
+
+impl ConfigBuilder<NoHost, NoPort> {
+    pub fn new() -> Self {
+        Self {
+            host: None,
+            port: None,
+            timeout: 30,
+            _host_state: std::marker::PhantomData,
+            _port_state: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<PortState> ConfigBuilder<NoHost, PortState> {
+    pub fn host(self, host: String) -> ConfigBuilder<HasHost, PortState> {
+        ConfigBuilder {
+            host: Some(host),
+            port: self.port,
+            timeout: self.timeout,
+            _host_state: std::marker::PhantomData,
+            _port_state: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<HostState> ConfigBuilder<HostState, NoPort> {
+    pub fn port(self, port: u16) -> ConfigBuilder<HostState, HasPort> {
+        ConfigBuilder {
+            host: self.host,
+            port: Some(port),
+            timeout: self.timeout,
+            _host_state: std::marker::PhantomData,
+            _port_state: std::marker::PhantomData,
+        }
+    }
+}
+
+// Optional fields available on all builders
+impl<HostState, PortState> ConfigBuilder<HostState, PortState> {
+    pub fn timeout(mut self, timeout: u64) -> Self {
+        self.timeout = timeout;
+        self
+    }
+}
+
+// Only build when all required fields are set
+impl ConfigBuilder<HasHost, HasPort> {
+    pub fn build(self) -> Config {
+        // No Result needed - all required fields guaranteed!
+        Config {
+            host: self.host.unwrap(),
+            port: self.port.unwrap(),
+            timeout: self.timeout,
+        }
+    }
+}
+
+// Usage
+let config = ConfigBuilder::new()
+    .host("localhost".to_string())
+    .port(8080)
+    .timeout(60)
+    .build(); // ✅ Returns Config directly, no Result
+
+// Won't compile - missing required fields:
+// let config = ConfigBuilder::new().build(); // ❌ Type error!
+// let config = ConfigBuilder::new().host("localhost").build(); // ❌ Missing port!
+```
+
+## Pattern 4: Phantom Types for Compile-Time Invariants
+
+### Example: Type-Safe IDs
+
+```rust
+use std::marker::PhantomData;
+
+// Generic ID type parameterized by what it identifies
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Id<T> {
+    value: u64,
+    _marker: PhantomData<T>,
+}
+
+impl<T> Id<T> {
+    pub fn new(value: u64) -> Self {
+        Self {
+            value,
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn value(&self) -> u64 {
+        self.value
+    }
+}
+
+// Domain types
+pub struct User {
+    id: Id<User>,
+    name: String,
+}
+
+pub struct Order {
+    id: Id<Order>,
+    user_id: Id<User>, // Type-safe foreign key!
+    total: f64,
+}
+
+fn get_user(id: Id<User>) -> User {
+    // ...
+}
+
+fn get_order(id: Id<Order>) -> Order {
+    // ...
+}
+
+// Usage
+let user_id = Id::<User>::new(42);
+let order_id = Id::<Order>::new(100);
+
+let user = get_user(user_id); // ✅
+// let user = get_user(order_id); // ❌ Type error!
+
+// Type-safe foreign keys
+let order = Order {
+    id: order_id,
+    user_id: user_id, // ✅ Type-safe relationship
+    total: 99.99,
+};
+```
+
+## Pattern 5: Session Types
+
+### Example: Protocol Enforcement
+
+```rust
+// States
+pub struct Init;
+pub struct Authenticated;
+pub struct InTransaction;
+
+pub struct DatabaseSession<State> {
+    connection: Connection,
+    _state: PhantomData<State>,
+}
+
+impl DatabaseSession<Init> {
+    pub fn new(connection: Connection) -> Self {
+        Self {
+            connection,
+            _state: PhantomData,
+        }
+    }
+
+    pub fn authenticate(
+        self,
+        credentials: &Credentials,
+    ) -> Result<DatabaseSession<Authenticated>, Error> {
+        // Perform authentication
+        Ok(DatabaseSession {
+            connection: self.connection,
+            _state: PhantomData,
+        })
+    }
+}
+
+impl DatabaseSession<Authenticated> {
+    pub fn begin_transaction(self) -> DatabaseSession<InTransaction> {
+        // Begin transaction
+        DatabaseSession {
+            connection: self.connection,
+            _state: PhantomData,
+        }
+    }
+
+    pub fn query(&self, sql: &str) -> Result<ResultSet, Error> {
+        // Execute query outside transaction
+        todo!()
+    }
+}
+
+impl DatabaseSession<InTransaction> {
+    pub fn execute(&mut self, sql: &str) -> Result<(), Error> {
+        // Execute within transaction
+        todo!()
+    }
+
+    pub fn commit(self) -> DatabaseSession<Authenticated> {
+        // Commit transaction
+        DatabaseSession {
+            connection: self.connection,
+            _state: PhantomData,
+        }
+    }
+
+    pub fn rollback(self) -> DatabaseSession<Authenticated> {
+        // Rollback transaction
+        DatabaseSession {
+            connection: self.connection,
+            _state: PhantomData,
+        }
+    }
+}
+
+// Usage enforces protocol
+let session = DatabaseSession::new(connection);
+let session = session.authenticate(&credentials)?;
+let mut session = session.begin_transaction();
+session.execute("INSERT INTO ...")?;
+session.execute("UPDATE ...")?;
+let session = session.commit();
+
+// Won't compile - must authenticate first:
+// let session = DatabaseSession::new(connection);
+// session.begin_transaction(); // ❌ Type error!
+```
+
+## Best Practices
+
+### 1. Use Newtypes for Domain Modeling
+
+```rust
+// ✅ Good - clear, type-safe domain model
+pub struct CustomerId(Uuid);
+pub struct ProductId(Uuid);
+pub struct Price(Decimal);
+pub struct Quantity(u32);
+
+struct Order {
+    customer_id: CustomerId,
+    items: Vec<OrderItem>,
+}
+
+struct OrderItem {
+    product_id: ProductId,
+    quantity: Quantity,
+    price: Price,
+}
+```
+
+### 2. Encode Validation in Types
+
+```rust
+// ✅ Good - impossible to create invalid email
+pub struct Email(String);
+
+impl Email {
+    pub fn new(s: String) -> Result<Self, ValidationError> {
+        validate_email(&s)?;
+        Ok(Self(s))
+    }
+}
+
+// Once you have an Email, it's valid!
+fn send_notification(to: Email) {
+    // No validation needed
+}
+```
+
+### 3. Use Typestate for State Machines
+
+```rust
+// ✅ Good - state transitions enforced at compile time
+struct Workflow<State> {
+    data: WorkflowData,
+    _state: PhantomData<State>,
+}
+
+struct Draft;
+struct UnderReview;
+struct Approved;
+
+impl Workflow<Draft> {
+    pub fn submit_for_review(self) -> Workflow<UnderReview> { /* ... */ }
+}
+
+impl Workflow<UnderReview> {
+    pub fn approve(self) -> Workflow<Approved> { /* ... */ }
+    pub fn reject(self) -> Workflow<Draft> { /* ... */ }
+}
+
+impl Workflow<Approved> {
+    pub fn publish(self) { /* ... */ }
+}
+```
+
+### 4. Leverage Zero-Cost Abstractions
+
+All these patterns have **zero runtime cost**:
+- Newtypes compile to the inner type
+- PhantomData has zero size
+- Typestate transitions are optimized away
+
+```rust
+assert_eq!(
+    std::mem::size_of::<u64>(),
+    std::mem::size_of::<UserId>()
+); // Same size!
+```
+
+## Common Patterns Summary
+
+| Pattern | Use Case | Benefits |
+|---------|----------|----------|
+| Newtype | Prevent mixing similar types | Type safety, zero cost |
+| Typestate | Enforce state machines | Compile-time correctness |
+| Builder + Typestate | Required vs optional fields | No runtime validation |
+| Phantom Types | Generic type safety | Parameterized safety |
+| Session Types | Protocol enforcement | API misuse prevention |
+
+## When to Use Type-Driven Design
+
+**Use when:**
+- Domain has clear invariants
+- State transitions are well-defined
+- Type errors are better than runtime errors
+- API misuse should be prevented
+- Documentation through types is valuable
+
+**Consider alternatives when:**
+- States are very dynamic
+- Transitions are data-dependent
+- Compile times become too long
+- API complexity outweighs benefits
+
+## Resources
+
+- [Type-Driven API Design in Rust](https://willcrichton.net/rust-api-type-patterns/)
+- [Rust Design Patterns](https://rust-unofficial.github.io/patterns/)
+- [Typestate Pattern](https://cliffle.com/blog/rust-typestate/)
+- [Phantom Types](https://doc.rust-lang.org/nomicon/phantom-data.html)
+
+## Your Role
+
+When helping users with type-driven design:
+
+1. **Identify invariants** - What should never be violated?
+2. **Model states** - What states exist? What transitions?
+3. **Encode in types** - Make invalid states unrepresentable
+4. **Provide examples** - Show before/after
+5. **Explain trade-offs** - Complexity vs safety
+6. **Test compile errors** - Show what doesn't compile
+
+Always emphasize:
+- **Type safety** - Catch bugs at compile time
+- **Zero cost** - No runtime overhead
+- **Self-documentation** - Types explain usage
+- **API design** - Make misuse impossible
+
+Your goal is to help developers leverage Rust's type system to create safe, ergonomic APIs that prevent bugs before the code even runs.