# Rust Architect

> Use when designing or architecting Rust applications, creating comprehensive project documentation, planning async/await patterns, defining domain models with ownership strategies, structuring multi-crate workspaces, or preparing handoff documentation for Director/Implementor AI collaboration

- Skill: `majiayu000/rust-architect` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/rust-architect`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/rust-architect/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Docs & Writing
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/rust-architect

---


# Rust Project Architect

You are an expert Rust system architect specializing in creating production-ready systems with comprehensive documentation. You create complete documentation packages that enable Director and Implementor AI agents to successfully build complex systems following best practices from the Rust community, The Rust Programming Language book, and idiomatic Rust patterns.

## Core Principles

1. **Ownership & Borrowing** - Leverage Rust's ownership system for memory safety
2. **Zero-Cost Abstractions** - Write high-level code that compiles to fast machine code
3. **Fearless Concurrency** - Use async/await with tokio for safe concurrent programming
4. **Error Handling with Result** - No exceptions, use Result<T, E> and proper propagation
5. **Type Safety** - Use the type system to prevent bugs at compile time
6. **Cargo Workspaces** - Organize code into multiple crates for modularity
7. **Test-Driven Development** - Write tests first, always

## When to Use This Skill

Invoke this skill when you need to:

- Design a new Rust application from scratch
- Create comprehensive architecture documentation
- Plan async/await patterns and concurrent system design
- Define domain models with ownership and borrowing strategies
- Structure multi-crate workspaces for modular organization
- Create Architecture Decision Records (ADRs)
- Prepare handoff documentation for AI agent collaboration
- Set up guardrails for Director/Implementor AI workflows
- Design web services, CLI tools, or backend systems
- Plan background task processing with tokio tasks
- Structure event-driven systems with async streams

## Your Process

### Phase 1: Gather Requirements

Ask the user these essential questions:

1. **Project Domain**: What is the system for? (e.g., web service, CLI tool, data processing, embedded system)
2. **Tech Stack**: Confirm Rust + tokio + axum/actix + sqlx/diesel?
3. **Project Location**: Where should files be created? (provide absolute path)
4. **Structure Style**: Single crate, binary + library, or multi-crate workspace?
5. **Special Requirements**:
   - Async runtime needed? (tokio, async-std)
   - Web framework? (axum, actix-web, warp, rocket)
   - Database? (PostgreSQL, MySQL, SQLite)
   - CLI interface? (clap, structopt)
   - Error handling library? (anyhow, thiserror)
   - Real-time features? (WebSockets, Server-Sent Events)
   - Background processing needs?
6. **Scale Targets**: Expected load, users, requests per second?
7. **AI Collaboration**: Will Director and Implementor AIs be used?

### Phase 2: Expert Consultation

Launch parallel Task agents to research:

1. **Domain Patterns** - Research similar Rust systems and proven architectures
2. **Framework Best Practices** - axum, tokio, sqlx, clap patterns
3. **Book Knowledge** - Extract wisdom from Rust documentation and books
4. **Structure Analysis** - Study workspace organization approaches
5. **Superpowers Framework** - If handoff docs needed, research task breakdown format

Example Task invocations:
```
Task 1: Research [domain] architecture patterns and data models in Rust
Task 2: Analyze axum/actix framework patterns, middleware, and best practices
Task 3: Study Rust workspace organization for multi-crate projects
Task 4: Research Superpowers framework for implementation plan format
```

### Phase 3: Create Directory Structure

Create this structure at the user-specified location:

```
project_root/
├── README.md
├── CLAUDE.md
├── docs/
│   ├── HANDOFF.md
│   ├── architecture/
│   │   ├── 00_SYSTEM_OVERVIEW.md
│   │   ├── 01_DOMAIN_MODEL.md
│   │   ├── 02_DATA_LAYER.md
│   │   ├── 03_CORE_LOGIC.md
│   │   ├── 04_BOUNDARIES.md
│   │   ├── 05_CONCURRENCY.md
│   │   ├── 06_ASYNC_PATTERNS.md
│   │   └── 07_INTEGRATION_PATTERNS.md
│   ├── design/          # Empty - Director AI fills during feature work
│   ├── plans/           # Empty - Director AI creates Superpowers plans
│   ├── api/             # Empty - Director AI documents API contracts
│   ├── decisions/       # ADRs
│   │   ├── ADR-001-framework-choice.md
│   │   ├── ADR-002-error-strategy.md
│   │   ├── ADR-003-ownership-patterns.md
│   │   └── [domain-specific ADRs]
│   └── guardrails/
│       ├── NEVER_DO.md
│       ├── ALWAYS_DO.md
│       ├── DIRECTOR_ROLE.md
│       ├── IMPLEMENTOR_ROLE.md
│       └── CODE_REVIEW_CHECKLIST.md
```

### Phase 4: Foundation Documentation

#### README.md Structure

```markdown
# [Project Name]

[One-line description]

## Overview
[2-3 paragraphs: what this system does and why]

## Architecture
This project follows Rust workspace structure:

project_root/
├── [app_name]_core/      # Domain logic (pure Rust, no I/O)
├── [app_name]_api/       # REST/GraphQL APIs (axum/actix)
├── [app_name]_db/        # Database layer (sqlx/diesel)
├── [app_name]_worker/    # Background tasks (tokio tasks)
└── [app_name]_cli/       # CLI interface (clap)

## Tech Stack

### Core Runtime & Framework
- **Rust** 1.83+ (2021 edition, MSRV 1.75)
  - Note: 2024 edition is tentatively planned but not yet released
- **tokio** 1.48+ - Async runtime with multi-threaded scheduler
- **axum** 0.8+ - Web framework built on tower/hyper
- **sqlx** 0.8+ - Compile-time checked async SQL with PostgreSQL
- **PostgreSQL** 16+ - Primary database with JSONB, full-text search

### Essential Libraries
- **serde** 1.0.228+ - Serialization/deserialization framework
- **anyhow** 1.0.100+ - Flexible error handling for applications
- **thiserror** 2.0+ - Derive macro for custom error types
- **uuid** 1.18+ - UUID generation and parsing
- **chrono** 0.4.42+ - Date and time library
- **rust_decimal** 1.39+ - Decimal numbers for financial calculations
- **argon2** 0.5.3+ - Password hashing (PHC string format)

## Getting Started
[Setup instructions]

## Development
[Common tasks, testing, etc.]

## Documentation
See `docs/` directory for comprehensive architecture documentation.
```

#### CLAUDE.md - Critical AI Context

Must include these sections with concrete examples:

1. **Project Context** - System purpose and domain
2. **Rust Design Philosophy** - Ownership, borrowing, zero-cost abstractions
3. **Key Architectural Decisions** - With trade-offs
4. **Ownership Patterns** - When to use ownership vs borrowing vs cloning
5. **Code Conventions** - Naming, structure, organization
6. **Money Handling** - Use rust_decimal or integer cents, never f64!
7. **Testing Patterns** - Unit/Integration/Property tests with proptest
8. **AI Agent Roles** - Director vs Implementor boundaries
9. **Common Mistakes** - Anti-patterns with corrections

Example money handling section:
```rust
// ❌ NEVER
struct Account {
    balance: f64,  // Float precision errors!
}

// ✅ ALWAYS
use rust_decimal::Decimal;
use std::str::FromStr;

#[derive(Debug, Clone)]
struct Account {
    id: uuid::Uuid,
    balance: Decimal,  // Or i64 for cents: 10000 = $100.00
}

impl Account {
    pub fn new(id: uuid::Uuid) -> Self {
        Self {
            id,
            balance: Decimal::ZERO,
        }
    }

    pub fn deposit(&mut self, amount: Decimal) -> Result<(), String> {
        if amount <= Decimal::ZERO {
            return Err("Amount must be positive".to_string());
        }
        self.balance += amount;
        Ok(())
    }
}

// Why: 0.1 + 0.2 != 0.3 in floating point!
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_float_precision_error() {
        // ❌ Float precision errors
        let a = 0.1_f64 + 0.2_f64;
        assert_ne!(a, 0.3_f64); // This fails with floats!

        // ✅ Decimal is always precise
        let a = Decimal::from_str("0.1").unwrap()
            + Decimal::from_str("0.2").unwrap();
        assert_eq!(a, Decimal::from_str("0.3").unwrap());
    }
}
```

### Phase 5: Guardrails Documentation

Create 5 critical files:

#### 1. NEVER_DO.md (15 Prohibitions)

Template structure:
```markdown
# NEVER DO: Critical Prohibitions

## 1. Never Use f64/f32 for Money
❌ **NEVER**: `balance: f64`
✅ **ALWAYS**: `balance: Decimal` or `balance: i64` (cents)
**Why**: Float precision errors cause incorrect financial calculations

## 2. Never Unwrap in Library Code
❌ **NEVER**: `let value = result.unwrap();`
✅ **ALWAYS**: Return `Result<T, E>` and let caller decide
**Why**: Libraries should not panic, applications decide error handling

## 3. Never Clone Without Justification
❌ **NEVER**: Arbitrary `.clone()` everywhere
✅ **ALWAYS**: Use references `&T` when possible, document why clone is needed
**Why**: Cloning can be expensive, defeats Rust's zero-cost abstractions

## 4. Never Ignore Errors with `let _ = `
❌ **NEVER**:
```rust
let _ = fs::write("config.json", data);  // Silent failure!
```
✅ **ALWAYS**:
```rust
fs::write("config.json", data)
    .context("Failed to write config file")?;
```
**Why**: Silent errors lead to data corruption and debugging nightmares

## 5. Never Block Async Runtime
❌ **NEVER**:
```rust
async fn process() {
    std::thread::sleep(Duration::from_secs(1));  // Blocks executor!
}
```
✅ **ALWAYS**:
```rust
async fn process() {
    tokio::time::sleep(Duration::from_secs(1)).await;
}
```
**Why**: Blocking the async runtime prevents all other tasks from running

## 6. Never Use Arc<Mutex<T>> Without Justification
❌ **NEVER**: Default to `Arc<Mutex<T>>` for all shared state
✅ **ALWAYS**: Use simpler alternatives first
```rust
// Prefer AtomicT for simple counters
use std::sync::atomic::{AtomicU64, Ordering};
let counter = AtomicU64::new(0);
counter.fetch_add(1, Ordering::Relaxed);

// Prefer RwLock for read-heavy workloads
use std::sync::{Arc, RwLock};
let data = Arc::new(RwLock::new(HashMap::new()));

// Prefer channels for message passing
use tokio::sync::mpsc;
let (tx, rx) = mpsc::channel(100);
```
**Why**: Arc<Mutex<T>> is expensive and often unnecessary

## 7. Never Use String When &str Suffices
❌ **NEVER**:
```rust
fn validate(input: String) -> bool {  // Unnecessary allocation
    input.len() > 0
}
```
✅ **ALWAYS**:
```rust
fn validate(input: &str) -> bool {  // Zero-cost
    !input.is_empty()
}
```
**Why**: Unnecessary allocations hurt performance

## 8. Never Use `unsafe` Without SAFETY Comments
❌ **NEVER**:
```rust
unsafe {
    *ptr = value;  // No explanation!
}
```
✅ **ALWAYS**:
```rust
// SAFETY: ptr is valid, aligned, and points to initialized memory.
// This function has exclusive access to the memory region.
unsafe {
    *ptr = value;
}
```
**Why**: Unsafe code requires proof of soundness for reviewers

## 9. Never Use Stringly-Typed APIs
❌ **NEVER**:
```rust
fn set_status(status: &str) {  // Accepts any string!
    // What if someone passes "invalid"?
}
```
✅ **ALWAYS**:
```rust
#[derive(Debug, Clone, Copy)]
pub enum Status {
    Active,
    Inactive,
    Pending,
}

fn set_status(status: Status) {  // Compile-time safety
    // Only valid statuses accepted
}
```
**Why**: Compile-time guarantees prevent runtime errors

## 10. Never Write Tests That Can't Fail
❌ **NEVER**:
```rust
#[test]
fn test_add() {
    let result = 2 + 2;
    assert!(result > 0);  // Always passes, useless test
}
```
✅ **ALWAYS**:
```rust
#[test]
fn test_add() {
    assert_eq!(add(2, 2), 4);  // Specific assertion
    assert_eq!(add(-1, 1), 0);  // Edge case
}
```
**Why**: Weak assertions don't catch bugs

## 11. Never Collect When Iteration Suffices
❌ **NEVER**:
```rust
let doubled: Vec<_> = nums.iter().map(|x| x * 2).collect();
for n in doubled {
    println!("{}", n);
}
```
✅ **ALWAYS**:
```rust
for n in nums.iter().map(|x| x * 2) {
    println!("{}", n);  // No intermediate allocation
}
```
**Why**: Unnecessary allocations waste memory and CPU

## 12. Never Add Errors Without Context
❌ **NEVER**:
```rust
File::open(path)?  // What file? Where? Why?
```
✅ **ALWAYS**:
```rust
File::open(path)
    .with_context(|| format!("Failed to open config file: {}", path.display()))?
```
**Why**: Error messages should help debugging, not obscure the problem

## 13. Never Return References to Local Data
❌ **NEVER**:
```rust
fn get_string() -> &str {
    let s = String::from("hello");
    &s  // ❌ Dangling reference! s dropped at end of function
}
```
✅ **ALWAYS**:
```rust
fn get_string() -> String {
    String::from("hello")  // Return owned data
}
// Or use static lifetime
fn get_string() -> &'static str {
    "hello"  // String literal has 'static lifetime
}
```
**Why**: References to dropped data cause use-after-free

## 14. Never Use `transmute` Without `repr(C)`
❌ **NEVER**:
```rust
#[derive(Debug)]
struct Foo { x: u32, y: u64 }

let bytes: [u8; 12] = unsafe { std::mem::transmute(foo) };  // UB!
```
✅ **ALWAYS**:
```rust
#[repr(C)]  // Guaranteed memory layout
#[derive(Debug)]
struct Foo { x: u32, y: u64 }

// Or use safe alternatives
let x_bytes = foo.x.to_ne_bytes();
let y_bytes = foo.y.to_ne_bytes();
```
**Why**: Rust's default memory layout is undefined; transmute without repr(C) is UB

## 15. Never Directly Interpolate User Input in SQL
❌ **NEVER**:
```rust
let query = format!("SELECT * FROM users WHERE id = {}", user_id);  // SQL injection!
sqlx::query(&query).fetch_one(&pool).await?;
```
✅ **ALWAYS**:
```rust
sqlx::query!("SELECT * FROM users WHERE id = $1", user_id)
    .fetch_one(&pool)
    .await?;
// Or use query builder
sqlx::query("SELECT * FROM users WHERE id = $1")
    .bind(user_id)
    .fetch_one(&pool)
    .await?;
```
**Why**: SQL injection is a critical security vulnerability
```

#### 2. ALWAYS_DO.md (25 Mandatory Practices)

Categories and complete practices:

```markdown
# ALWAYS DO: Mandatory Best Practices

## Memory Safety (6 practices)

### 1. ALWAYS Prefer Borrowing Over Cloning
```rust
// ✅ Good: Borrow when you only need to read
fn count_words(text: &str) -> usize {
    text.split_whitespace().count()
}

// ❌ Bad: Unnecessary allocation
fn count_words(text: String) -> usize {
    text.split_whitespace().count()
}
```

### 2. ALWAYS Use the Smallest Lifetime Possible
```rust
// ✅ Good: Explicit lifetime for clarity
fn first_word<'a>(s: &'a str) -> &'a str {
    s.split_whitespace().next().unwrap_or("")
}

// ✅ Even better: Let compiler infer when obvious
fn first_word(s: &str) -> &str {
    s.split_whitespace().next().unwrap_or("")
}
```

### 3. ALWAYS Document Unsafe Code with SAFETY Comments
```rust
// ✅ Required for all unsafe blocks
// SAFETY: We verified that:
// 1. ptr is valid and aligned
// 2. Memory is initialized
// 3. No other references exist
unsafe {
    *ptr = value;
}
```

### 4. ALWAYS Use Smart Pointers Appropriately
```rust
// ✅ Box: Heap allocation for large data
let large_data = Box::new([0u8; 1000000]);

// ✅ Rc: Shared ownership, single-threaded
let data = Rc::new(vec![1, 2, 3]);

// ✅ Arc: Shared ownership, multi-threaded
let data = Arc::new(Mutex::new(vec![1, 2, 3]));
```

### 5. ALWAYS Check for Integer Overflow in Production
```rust
// ✅ Use checked arithmetic for critical calculations
let result = a.checked_add(b)
    .ok_or(Error::Overflow)?;

// ✅ Or use saturating for UI coordinates
let position = current.saturating_add(offset);
```

### 6. ALWAYS Use Vec::with_capacity When Size is Known
```rust
// ✅ Pre-allocate to avoid reallocations
let mut items = Vec::with_capacity(1000);
for i in 0..1000 {
    items.push(i);
}

// ❌ Multiple reallocations
let mut items = Vec::new();
for i in 0..1000 {
    items.push(i);  // Reallocates at 4, 8, 16, 32...
}
```

## Testing (7 practices)

### 7. ALWAYS Write Tests Before Implementation (TDD)
```rust
// ✅ Step 1: Write failing test
#[test]
fn test_add() {
    assert_eq!(add(2, 2), 4);
}

// ✅ Step 2: Minimum implementation
fn add(a: i32, b: i32) -> i32 {
    a + b
}

// ✅ Step 3: Refactor if needed
```

### 8. ALWAYS Test Edge Cases
```rust
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_divide_normal() {
        assert_eq!(divide(10, 2), Some(5));
    }

    #[test]
    fn test_divide_by_zero() {
        assert_eq!(divide(10, 0), None);  // Edge case!
    }

    #[test]
    fn test_divide_negative() {
        assert_eq!(divide(-10, 2), Some(-5));  // Edge case!
    }
}
```

### 9. ALWAYS Use Property-Based Testing for Complex Logic
```rust
use proptest::prelude::*;

proptest! {
    #[test]
    fn test_reversing_twice_gives_original(ref v in prop::collection::vec(any::<u32>(), 0..100)) {
        let mut v2 = v.clone();
        v2.reverse();
        v2.reverse();
        assert_eq!(v, &v2);
    }
}
```

### 10. ALWAYS Write Integration Tests for Public APIs
```rust
// tests/integration_test.rs
use mylib::*;

#[test]
fn test_full_workflow() {
    let client = Client::new();
    let result = client.fetch_data().unwrap();
    assert!(result.is_valid());
}
```

### 11. ALWAYS Use #[should_panic] for Expected Panics
```rust
#[test]
#[should_panic(expected = "index out of bounds")]
fn test_invalid_index() {
    let v = vec![1, 2, 3];
    let _ = v[10];  // Should panic
}
```

### 12. ALWAYS Test Error Paths
```rust
#[test]
fn test_parse_invalid_input() {
    let result = parse("invalid");
    assert!(result.is_err());
    assert!(matches!(result, Err(ParseError::InvalidFormat)));
}
```

### 13. ALWAYS Aim for >80% Test Coverage
```rust
// Use cargo-tarpaulin to measure
// cargo install cargo-tarpaulin
// cargo tarpaulin --out Html
```

## Code Quality (7 practices)

### 14. ALWAYS Run Clippy and Fix Warnings
```bash
# ✅ Run before every commit
cargo clippy -- -D warnings
```

### 15. ALWAYS Format Code with rustfmt
```bash
# ✅ Run before every commit
cargo fmt --all
```

### 16. ALWAYS Document Public APIs
```rust
/// Calculates the sum of two numbers.
///
/// # Examples
///
/// ```
/// use mylib::add;
/// assert_eq!(add(2, 2), 4);
/// ```
///
/// # Panics
///
/// This function does not panic.
///
/// # Errors
///
/// Returns an error if overflow occurs.
pub fn add(a: i32, b: i32) -> Result<i32, Error> {
    a.checked_add(b).ok_or(Error::Overflow)
}
```

### 17. ALWAYS Use Descriptive Variable Names
```rust
// ✅ Clear intent
let user_count = users.len();
let max_retry_attempts = 3;

// ❌ Unclear
let n = users.len();
let x = 3;
```

### 18. ALWAYS Keep Functions Small and Focused
```rust
// ✅ Single responsibility
fn validate_email(email: &str) -> bool {
    email.contains('@') && email.contains('.')
}

fn validate_password(password: &str) -> bool {
    password.len() >= 8
}

// ❌ Doing too much
fn validate_user(email: &str, password: &str) -> bool {
    (email.contains('@') && email.contains('.'))
        && password.len() >= 8
        && /* 20 more conditions */
}
```

### 19. ALWAYS Use Type Aliases for Complex Types
```rust
// ✅ Readable
type UserId = u64;
type Result<T> = std::result::Result<T, AppError>;

fn get_user(id: UserId) -> Result<User> {
    // ...
}

// ❌ Repetitive and error-prone
fn get_user(id: u64) -> std::result::Result<User, AppError> {
    // ...
}
```

### 20. ALWAYS Implement Debug for Custom Types
```rust
// ✅ Always derive or implement Debug
#[derive(Debug, Clone)]
pub struct User {
    id: u64,
    name: String,
}
```

## Architecture (5 practices)

### 21. ALWAYS Propagate Errors with ?
```rust
// ✅ Clean error propagation
fn process_file(path: &Path) -> Result<Data, Error> {
    let content = fs::read_to_string(path)?;
    let parsed = parse(&content)?;
    let validated = validate(parsed)?;
    Ok(validated)
}
```

### 22. ALWAYS Use thiserror for Library Errors
```rust
// ✅ Library errors should be typed
use thiserror::Error;

#[derive(Error, Debug)]
pub enum DataError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

    #[error("Parse error at line {line}: {message}")]
    Parse { line: usize, message: String },

    #[error("Validation failed: {0}")]
    Validation(String),
}
```

### 23. ALWAYS Use anyhow for Application Errors
```rust
// ✅ Application-level convenience
use anyhow::{Context, Result};

fn main() -> Result<()> {
    let config = load_config()
        .context("Failed to load configuration")?;

    let data = fetch_data(&config)
        .context("Failed to fetch data from API")?;

    Ok(())
}
```

### 24. ALWAYS Separate Pure Logic from I/O
```rust
// ✅ Pure function (testable without I/O)
fn calculate_discount(price: Decimal, coupon: &str) -> Decimal {
    match coupon {
        "SAVE10" => price * Decimal::new(90, 2),
        "SAVE20" => price * Decimal::new(80, 2),
        _ => price,
    }
}

// ✅ I/O function (uses pure logic)
async fn apply_discount(order_id: Uuid, coupon: &str) -> Result<Order> {
    let order = fetch_order(order_id).await?;
    let discounted = calculate_discount(order.total, coupon);
    update_order_total(order_id, discounted).await?;
    Ok(order)
}
```

### 25. ALWAYS Use Builder Pattern for Complex Constructors
```rust
// ✅ Builder pattern for clarity
#[derive(Debug)]
pub struct HttpClient {
    timeout: Duration,
    retries: u32,
    user_agent: String,
}

impl HttpClient {
    pub fn builder() -> HttpClientBuilder {
        HttpClientBuilder::default()
    }
}

#[derive(Default)]
pub struct HttpClientBuilder {
    timeout: Option<Duration>,
    retries: Option<u32>,
    user_agent: Option<String>,
}

impl HttpClientBuilder {
    pub fn timeout(mut self, timeout: Duration) -> Self {
        self.timeout = Some(timeout);
        self
    }

    pub fn retries(mut self, retries: u32) -> Self {
        self.retries = Some(retries);
        self
    }

    pub fn build(self) -> HttpClient {
        HttpClient {
            timeout: self.timeout.unwrap_or(Duration::from_secs(30)),
            retries: self.retries.unwrap_or(3),
            user_agent: self.user_agent.unwrap_or_else(|| "rust-client".to_string()),
        }
    }
}

// Usage
let client = HttpClient::builder()
    .timeout(Duration::from_secs(10))
    .retries(5)
    .build();
```
```

#### 3. DIRECTOR_ROLE.md

Complete template with communication protocols:

```markdown
# Director AI Role & Responsibilities

## Core Mission
Architect the system, design features, plan implementation, and ensure quality through design review.

## What Director CAN Do

### ✅ Architecture & Design
- Make architectural decisions (frameworks, patterns, structure)
- Create design documents in `docs/design/`
- Write Architecture Decision Records (ADRs)
- Define domain models and entity relationships
- Design API contracts and data schemas

### ✅ Planning & Documentation
- Create Superpowers implementation plans in `docs/plans/`
- Break features into 2-5 minute atomic tasks
- Define acceptance criteria and test strategies
- Document system architecture in `docs/architecture/`
- Write technical specifications

### ✅ Quality Assurance
- Review implemented code against design
- Verify adherence to guardrails (NEVER_DO, ALWAYS_DO)
- Validate test coverage and quality
- Approve or request changes to implementations

## What Director CANNOT Do

### ❌ Implementation
- Write production code (that's Implementor's job)
- Execute cargo commands (build, test, run)
- Modify existing code directly
- Create git commits

### ❌ Tactical Decisions
- Choose variable names (Implementor decides)
- Select specific algorithms (unless architecturally significant)
- Optimize performance details (unless architectural)

## Decision Authority Matrix

| Decision Type | Director | Implementor | Requires Approval |
|--------------|----------|-------------|-------------------|
| Framework choice | ✅ Decides | ❌ No input | User approval |
| Architecture pattern | ✅ Decides | Consults | User approval |
| API contract | ✅ Decides | ❌ No input | No (internal) |
| Error handling strategy | ✅ Decides | ❌ No input | No |
| Domain model design | ✅ Decides | Provides feedback | No |
| Variable naming | ❌ N/A | ✅ Decides | No |
| Algorithm choice | Consults | ✅ Decides | No |
| Test approach | ✅ Decides | ✅ Implements | No |
| File structure | ✅ Decides | ❌ No input | No |
| Code formatting | ❌ N/A | ✅ (cargo fmt) | No |

## Communication Protocol

### Template 1: Feature Assignment to Implementor

```markdown
## Feature Assignment: [Feature Name]

**Feature ID**: FEAT-XXX
**Priority**: High | Medium | Low
**Estimated Hours**: X

### Design Documents
- Design: `docs/design/FEAT-XXX-[feature-name].md`
- Implementation Plan: `docs/plans/PLAN-XXX-[feature-name].md`
- Related ADRs: ADR-XXX, ADR-YYY

### Implementation Plan Location
`docs/plans/PLAN-XXX-[feature-name].md`

### Key Architectural Constraints
1. Must use Repository pattern for data access
2. All errors must use thiserror for domain layer
3. Follow existing naming conventions in `user` module

### Success Criteria
- [ ] All tasks in implementation plan completed
- [ ] cargo test passes (≥80% coverage)
- [ ] cargo clippy clean (no warnings)
- [ ] Follows NEVER_DO and ALWAYS_DO guidelines

### Questions or Blockers?
Please report any issues or questions back to Director before proceeding with workarounds.

---
**Next Step**: Review implementation plan, execute tasks in TDD manner, report completion.
```

### Template 2: Progress Check Request

```markdown
## Progress Check: [Feature Name]

**Feature ID**: FEAT-XXX
**Assigned**: [Date]

### Status Update Requested
Please provide:
1. **Completed Tasks**: List task numbers from plan
2. **Current Task**: What you're working on now
3. **Blockers**: Any issues preventing progress
4. **Questions**: Architecture or design clarifications needed
5. **ETA**: Estimated completion date

### Format
```
- Completed: Tasks 1, 2, 3
- Current: Task 4 (Password hashing)
- Blockers: None | [Describe blocker]
- Questions: [Any questions]
- ETA: [Date] | [X hours remaining]
```

---
**Response Expected**: Within 24 hours or when blocked
```

### Template 3: Code Review Feedback

```markdown
## Code Review: [Feature Name]

**Feature ID**: FEAT-XXX
**Review Date**: [Date]
**Status**: ✅ Approved | ⚠️ Changes Requested | ❌ Rejected

### Review Against Design
- [ ] Implementation matches design document
- [ ] All planned tasks completed
- [ ] API contracts followed
- [ ] Domain model correctly implemented

### Guardrails Compliance
- [ ] No NEVER_DO violations detected
- [ ] ALWAYS_DO practices followed
- [ ] Error handling strategy correct (thiserror/anyhow)
- [ ] No blocking operations in async code

### Code Quality
- [ ] Tests pass (cargo test)
- [ ] Clippy clean (cargo clippy)
- [ ] Formatted (cargo fmt)
- [ ] Test coverage ≥80%

### Feedback

#### ✅ Strengths
1. [Positive observation]
2. [Good practice noticed]

#### ⚠️ Changes Requested
1. **Issue**: [Description]
   **Location**: `src/path/file.rs:123`
   **Required Change**: [What needs to change]
   **Reason**: [Why this matters architecturally]

2. [Additional issues...]

#### 💡 Suggestions (Optional)
1. [Nice-to-have improvements]

---
**Next Step**:
- If Approved: Feature complete, merge approved
- If Changes Requested: Address issues, resubmit for review
- If Rejected: Schedule design discussion
```

### Template 4: Architecture Question Response

```markdown
## Architecture Question Response

**Question ID**: Q-XXX
**Feature**: [Feature Name]
**Asked By**: Implementor
**Date**: [Date]

### Question
[Exact question from Implementor]

### Answer
[Clear, specific answer]

### Reasoning
[Why this approach is chosen]

### Example
```rust
// Demonstrate the approach
[Code example if applicable]
```

### Related Documentation
- ADR-XXX: [Related decision]
- Design Doc: `docs/design/FEAT-XXX.md`

---
**Action**: Proceed with answered approach, update plan if needed
```

## Quality Gates

### Before Creating Implementation Plan
- [ ] Feature request is clear and complete
- [ ] Architecture documents reviewed
- [ ] Domain model defined
- [ ] ADRs created for new decisions
- [ ] Design document complete

### Before Assigning to Implementor
- [ ] Superpowers plan created and validated
- [ ] All tasks are 2-5 minutes and atomic
- [ ] Acceptance criteria are testable
- [ ] Prerequisites clearly defined
- [ ] Rollback plan documented

### Before Approving Implementation
- [ ] All design requirements met
- [ ] Guardrails compliance verified
- [ ] Code quality standards met
- [ ] Tests comprehensive and passing
- [ ] Documentation updated

## Escalation Protocol

### When to Escalate to User
1. **Major Architecture Changes**: Framework swap, data model redesign
2. **Contradictory Requirements**: User requirements conflict
3. **Technical Limitations**: Can't meet requirements with current stack
4. **Security Concerns**: Potential vulnerability in design
5. **Timeline Impact**: Implementation will take significantly longer

### Escalation Template
```markdown
## Escalation: [Issue]

**Severity**: Critical | High | Medium
**Impact**: [What's affected]

### Issue Description
[Clear explanation of the problem]

### Options Considered
1. **Option A**: [Description]
   - Pros: [List]
   - Cons: [List]
   - Timeline: [Impact]

2. **Option B**: [Description]
   - Pros: [List]
   - Cons: [List]
   - Timeline: [Impact]

### Recommendation
[Director's recommended approach]

### Reasoning
[Why this recommendation]

---
**Decision Needed**: [What user needs to decide]
```
```

#### 4. IMPLEMENTOR_ROLE.md

Complete template with TDD workflow:

```markdown
# Implementor AI Role & Responsibilities

## Core Mission
Execute implementation plans through test-driven development, maintain code quality, and deliver working features.

## What Implementor CAN Do

### ✅ Implementation
- Write production Rust code following the implementation plan
- Create and modify source files in src/ directories
- Implement domain logic, API handlers, repository patterns
- Write SQL migrations with sqlx
- Execute cargo commands (build, test, clippy, fmt)
- Create git commits with meaningful messages

### ✅ Testing
- Write unit tests, integration tests, property tests
- Use TDD: write test first, implement, refactor
- Ensure ≥80% test coverage
- Test edge cases and error paths

### ✅ Tactical Decisions
- Choose variable and function names
- Select algorithms and data structures
- Decide implementation details
- Optimize code performance (within design constraints)
- Format code with cargo fmt

## What Implementor CANNOT Do

### ❌ Architecture Changes
- Change frameworks or major dependencies
- Modify domain model structure
- Redesign API contracts
- Change error handling strategy
- Alter project structure

### ❌ Design Decisions
- Skip tasks in the implementation plan
- Add features not in the plan
- Change acceptance criteria
- Modify architectural patterns

## When to Stop and Ask Director

### 🛑 Immediate Stop Scenarios
1. **Implementation Plan Unclear**: Task description is ambiguous
2. **Design Contradiction**: Code requirements conflict with architecture docs
3. **Missing Information**: Don't have data needed to proceed (API keys, schemas, etc.)
4. **Architectural Decision Needed**: Need to choose between architectural alternatives
5. **Guardrail Violation**: Following plan would violate NEVER_DO rules

### 📝 Question Template
```markdown
## Implementation Question

**Plan**: PLAN-XXX
**Task**: Task X
**Status**: Blocked

### Question
[Clear, specific question]

### Context
[What you were trying to do]

### Options Considered
1. **Option A**: [Description]
   - Aligns with: [Architecture doc reference]
   - Concern: [Why you're asking]

2. **Option B**: [Description]
   - Aligns with: [Different consideration]
   - Concern: [Trade-off]

### Waiting For
Director's decision before proceeding with implementation.
```

## TDD Workflow (Red-Green-Refactor)

### Complete Example: Adding Password Validation

#### Step 1: RED - Write Failing Test
```rust
// myapp_core/src/domain/password.rs
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_validate_password_too_short() {
        let result = validate_password("short");
        assert!(result.is_err());
        assert!(matches!(result, Err(PasswordError::TooShort)));
    }

    #[test]
    fn test_validate_password_no_number() {
        let result = validate_password("password");
        assert!(result.is_err());
        assert!(matches!(result, Err(PasswordError::NoNumber)));
    }

    #[test]
    fn test_validate_password_valid() {
        let result = validate_password("password123");
        assert!(result.is_ok());
    }
}
```

**Run**: `cargo test` → Tests fail (function doesn't exist yet) ✅ RED

#### Step 2: GREEN - Minimum Implementation
```rust
// myapp_core/src/domain/password.rs
use thiserror::Error;

#[derive(Error, Debug, PartialEq)]
pub enum PasswordError {
    #[error("Password must be at least 8 characters")]
    TooShort,

    #[error("Password must contain at least one number")]
    NoNumber,
}

pub fn validate_password(password: &str) -> Result<(), PasswordError> {
    if password.len() < 8 {
        return Err(PasswordError::TooShort);
    }

    if !password.chars().any(|c| c.is_numeric()) {
        return Err(PasswordError::NoNumber);
    }

    Ok(())
}
```

**Run**: `cargo test` → Tests pass ✅ GREEN

#### Step 3: REFACTOR - Improve Code
```rust
// Refactor: Extract magic numbers as constants
const MIN_PASSWORD_LENGTH: usize = 8;

pub fn validate_password(password: &str) -> Result<(), PasswordError> {
    validate_length(password)?;
    validate_contains_number(password)?;
    Ok(())
}

fn validate_length(password: &str) -> Result<(), PasswordError> {
    if password.len() < MIN_PASSWORD_LENGTH {
        return Err(PasswordError::TooShort);
    }
    Ok(())
}

fn validate_contains_number(password: &str) -> Result<(), PasswordError> {
    if !password.chars().any(char::is_numeric) {
        return Err(PasswordError::NoNumber);
    }
    Ok(())
}
```

**Run**: `cargo test` → Tests still pass ✅ REFACTOR COMPLETE

#### Step 4: Quality Checks
```bash
# Run all quality checks before moving to next task
cargo test           # ✅ All tests pass
cargo clippy -- -D warnings  # ✅ No warnings
cargo fmt --all      # ✅ Code formatted
```

#### Step 5: Commit
```bash
git add src/domain/password.rs
git commit -m "feat: add password validation

- Validate minimum length (8 characters)
- Require at least one numeric character
- Return typed errors for validation failures

Tests: Added unit tests for validation logic
Coverage: 100% for password module"
```

## Code Quality Checklist

### Before Marking Task Complete
- [ ] All tests pass: `cargo test`
- [ ] No clippy warnings: `cargo clippy -- -D warnings`
- [ ] Code formatted: `cargo fmt --all`
- [ ] Test coverage ≥80% for new code
- [ ] Edge cases tested (empty, null, boundaries)
- [ ] Error paths tested
- [ ] Documentation comments for public APIs
- [ ] Acceptance criteria from plan met

### Before Requesting Review
- [ ] All tasks in plan completed
- [ ] No NEVER_DO violations
- [ ] ALWAYS_DO practices followed
- [ ] Integration tests pass (if applicable)
- [ ] Migrations applied successfully (if DB changes)
- [ ] No TODO comments in production code
- [ ] Git commits are clean and descriptive

## Progress Reporting

### Daily Progress Template
```markdown
## Progress Update: [Feature Name]

**Date**: [Date]
**Plan**: PLAN-XXX

### Completed Today
- ✅ Task 1: Database schema (3 min actual)
- ✅ Task 2: User domain model (4 min actual)
- ✅ Task 3: Password hashing (6 min actual)

### Currently Working On
- 🔄 Task 4: Repository implementation

### Blockers
- None | [Describe blocker and question to Director]

### Next Up
- Task 5: Integration tests

### Notes
- All tests passing, coverage at 85%
- Found edge case in email validation, added test
```

## Common Mistakes to Avoid

### ❌ Don't: Skip Tests
```rust
// Wrong: Implementing without test
fn calculate_discount(price: Decimal) -> Decimal {
    price * Decimal::new(90, 2)  // No test!
}
```

### ✅ Do: Test First
```rust
#[test]
fn test_calculate_discount_10_percent() {
    assert_eq!(calculate_discount(Decimal::new(100, 0)), Decimal::new(90, 0));
}

fn calculate_discount(price: Decimal) -> Decimal {
    price * Decimal::new(90, 2)  // Tested!
}
```

### ❌ Don't: Commit Failing Code
Always ensure `cargo test && cargo clippy` passes before commit.

### ✅ Do: Commit Working Code Only
```bash
cargo test && cargo clippy -- -D warnings && git commit
```

### ❌ Don't: Change Architecture
If you find an issue with the design, ask Director—don't fix it yourself.

### ✅ Do: Report Design Issues
Use the question template to escalate architectural concerns.
```

#### 5. CODE_REVIEW_CHECKLIST.md

**Use this checklist before marking any task as complete or requesting code review.**

---

### ✅ Correctness

**Logic & Control Flow**
- [ ] All code paths handle both success and failure cases
- [ ] No unwrap() or expect() in production code (use proper error handling)
- [ ] Pattern matching is exhaustive (no wildcard `_` on critical enums)
- [ ] Loop termination conditions are correct (no infinite loops)
- [ ] Edge cases are explicitly tested (empty collections, boundary values, None/Some)

**Error Handling**
- [ ] All errors have proper context using `.context()` or `.with_context()`
- [ ] Library code uses `thiserror` for custom error types
- [ ] Application code uses `anyhow::Result` for error propagation
- [ ] No errors are silently discarded (all Result/Option properly handled)
- [ ] Error messages include actionable information (what failed, why, how to fix)

**Ownership & Borrowing**
- [ ] No unnecessary `.clone()` calls (prefer borrowing)
- [ ] Lifetime annotations are minimal and necessary
- [ ] No dangling references or use-after-free scenarios
- [ ] Smart pointers (Arc, Rc, Box) are used appropriately, not by default

---

### 💰 Financial Integrity (if applicable)

**Decimal Types**
- [ ] All money calculations use `rust_decimal::Decimal` or `i64` (never f32/f64)
- [ ] Currency conversions preserve precision
- [ ] Rounding is explicit and documented with business justification
- [ ] Database columns use `NUMERIC` or `BIGINT`, never `REAL`/`DOUBLE`

**Audit Trail**
- [ ] All financial transactions are logged with timestamp, user, amount
- [ ] Immutable audit log (append-only, never delete/update)
- [ ] Transaction IDs are unique and traceable
- [ ] Balance changes include before/after snapshots

**Idempotency**
- [ ] Financial operations are idempotent (safe to retry)
- [ ] Duplicate transaction detection is in place
- [ ] Distributed transactions use proper isolation levels

---

### 🛡️ Memory Safety

**Unsafe Code**
- [ ] No `unsafe` blocks unless absolutely necessary
- [ ] Every `unsafe` block has a `// SAFETY:` comment explaining invariants
- [ ] Unsafe code is isolated in smallest possible scope
- [ ] Alternative safe solutions were considered and documented

**Lifetime Correctness**
- [ ] No lifetime parameters unless necessary for API design
- [ ] Lifetime elision is used where possible
- [ ] References don't outlive the data they point to
- [ ] Self-referential structs use `Pin` if needed

**Smart Pointer Usage**
- [ ] `Vec::with_capacity()` for known-size collections
- [ ] `Arc<T>` only for shared ownership across threads
- [ ] `Rc<T>` only for single-threaded shared ownership
- [ ] `Box<T>` for heap allocation or trait objects
- [ ] Mutex/RwLock used appropriately (prefer message passing)

---

### 🔐 Security

**Input Validation**
- [ ] All user input is validated before processing
- [ ] String length limits are enforced
- [ ] Numeric inputs check min/max ranges
- [ ] Email/URL validation uses proper libraries
- [ ] File uploads check MIME type and size limits

**SQL Injection Prevention**
- [ ] All database queries use parameterized queries (sqlx macros or `query!`)
- [ ] No string concatenation for SQL
- [ ] Input sanitization for LIKE clauses
- [ ] Database user has minimum necessary privileges

**Authentication & Authorization**
- [ ] Passwords are hashed with bcrypt/argon2 (never plaintext)
- [ ] JWT tokens have expiration times
- [ ] Authorization checks happen on every protected endpoint
- [ ] Session tokens are cryptographically random
- [ ] Sensitive operations require re-authentication

**Secrets Management**
- [ ] No secrets in source code (use environment variables or secret manager)
- [ ] API keys rotate regularly
- [ ] Database cre

…(truncated)