# ❌ AI's code: Catch-all policy defeats the deny rule
PolicyDocument:
  Statement:
    - Sid: DenyDangerousActions
      Effect: Deny
      Action: 
        - iam:*
        - organizations:*
      Resource: "*"
    
    - Sid: AllowOtherActions  # DEFEATS THE PURPOSE!
      Effect: Allow
      Action: "*"
      Resource: "*"

// ❌ AI's code: Direct AWS SDK call bypassing tenant isolation
async fn get_item(table: &str, key: HashMap<String, AttributeValue>) 
    -> Result<GetItemOutput> {
    dynamodb_client
        .get_item()
        .table_name(table)
        .set_key(Some(key))
        .send()
        .await
}

// ✅ Enforces tenant isolation
async fn get_item(
    tenant_id: &str,
    table: &str, 
    key: HashMap<String, AttributeValue>
) -> Result<GetItemOutput> {
    let config = get_tenant_config(tenant_id).await?;
    config.dynamodb_client  // Tenant-scoped client
        .get_item()
        .table_name(&config.prefix_table(table))
        .set_key(Some(key))
        .send()
        .await
}

// ❌ AI's code: No caching, 200-500ms per call
async fn assume_role(role_arn: &str) -> Result<Credentials> {
    sts_client
        .assume_role()
        .role_arn(role_arn)
        .role_session_name("session")
        .send()
        .await?
        .credentials
}

// ✅ Cache credentials with TTL
lazy_static! {
    static ref CRED_CACHE: Mutex<LruCache<String, (Credentials, Instant)>> 
        = Mutex::new(LruCache::new(100));
}

async fn assume_role(role_arn: &str) -> Result<Credentials> {
    let mut cache = CRED_CACHE.lock().unwrap();
    
    if let Some((creds, timestamp)) = cache.get(role_arn) {
        if timestamp.elapsed() < Duration::from_secs(3000) {  // 50min
            return Ok(creds.clone());
        }
    }
    
    let creds = sts_client.assume_role()...  // Make call
    cache.put(role_arn.to_string(), (creds.clone(), Instant::now()));
    Ok(creds)
}

// ❌ AI's code: Logical order, wrong execution
App::new()
    .wrap(AuthMiddleware)      // Expects tenant_id in request
    .wrap(TenantMiddleware)    // Sets tenant_id
    .wrap(LoggingMiddleware)

// ✅ Reverse order for Actix-web's execution model
App::new()
    .wrap(LoggingMiddleware)
    .wrap(TenantMiddleware)    // Runs second
    .wrap(AuthMiddleware)      // Runs first

# ❌ AI's pre-commit hook
#!/bin/bash
cargo fmt --check
if [ $? -ne 0 ]; then
    exit 0  # Exit here if formatting fails
fi

cargo clippy -- -D warnings  # NEVER RUNS!

Commit 1: Fix 12 errors → Introduce 8 new errors (4 net)
Commit 2: Fix 4 errors → Introduce 3 new errors (1 net)
Commit 3: Fix 1 error → Introduce 1 new error (0 net)

// Step 1: Understand the pattern change
// Old: config_value!(key)
// New: config_value!(config, key)

// Step 2: Batch replace with regex
// Found 47 instances, replaced all at once

// Step 3: Handle special cases (3 instances)

AI for proactive design (Weeks 6-7): 5-7x faster
AI for reactive debugging (Week 5): 16x slower

Strategic implication: Prevention via design is 
80-100x more efficient than reactive debugging

// Entity A
#[derive(Entity)]
struct Organization {
    #[primary_key]
    id: Uuid,  // UUID type
}

// Entity B (generated later)
#[derive(Entity)]
struct User {
    org_id: String,  // ❌ Should be Uuid
}

// ❌ AI's code: Works for simple queries
GlobalSecondaryIndex::builder()
    .index_name("tenant-index")
    .key_schema(key_schema)
    .build()  // Missing projection!

// ✅ Explicit projection
GlobalSecondaryIndex::builder()
    .index_name("tenant-index")
    .key_schema(key_schema)
    .projection(
        Projection::builder()
            .projection_type(ProjectionType::All)
            .build()
    )
    .build()

// ❌ AI's code: Applies PII to numbers
#[derive(Entity)]
struct User {
    #[pii]
    age: i32,  // Can't encrypt numbers!
}

// ❌ AI's retry logic: No circuit breaker
async fn call_service(url: &str) -> Result<Response> {
    let mut retries = 0;
    loop {
        match http_client.get(url).send().await {
            Ok(resp) => return Ok(resp),
            Err(_) if retries < 5 => {
                retries += 1;
                tokio::time::sleep(Duration::from_secs(1)).await;
            }
            Err(e) => return Err(e),
        }
    }
}

// ✅ Circuit breaker pattern
lazy_static! {
    static ref CIRCUIT: Mutex<CircuitBreaker> = 
        Mutex::new(CircuitBreaker::new(5, Duration::from_secs(60)));
}

async fn call_service(url: &str) -> Result<Response> {
    let mut circuit = CIRCUIT.lock().unwrap();
    
    if circuit.is_open() {
        return Err(Error::CircuitOpen);
    }
    
    match http_client.get(url).send().await {
        Ok(resp) => {
            circuit.record_success();
            Ok(resp)
        }
        Err(e) => {
            circuit.record_failure();
            Err(e)
        }
    }
}

Intervene manually when:

Error count > 10 and related to single change
→ Manual batch fix (16x faster than AI iteration)

Errors per commit < 3 for 3 consecutive commits
→ AI is stuck in diminishing returns, stop immediately

Security-critical code paths
→ Threat model first, AI implements after review

Performance optimization needed
→ Human profiles with tools, AI optimizes identified hotspots

Framework quirks (middleware, hooks, config)
→ AI implements, human reviews execution behavior

Novel problems (no established pattern)
→ Human designs solution, AI implements from spec

Prevention efficiency: 5-7x faster than manual
Reactive debugging: 16x slower than manual
Prevention vs. Reactive: 80-112x efficiency difference