互動範例

def export_users(format='json'):
    """Export all users to a file."""
    users = User.query.all()

    if format == 'json':
        with open('users.json', 'w') as f:
            json.dump([u.to_dict() for u in users], f)
    elif format == 'csv':
        with open('users.csv', 'w') as f:
            writer = csv.DictWriter(f, fieldnames=['id', 'email', 'name'])
            writer.writeheader()
            writer.writerows([u.to_dict() for u in users])

    return f"Exported {len(users)} users"

# 在不詢問哪種「更快」重要的情況下，
# 直接加入快取、資料庫索引和非同步處理
@lru_cache(maxsize=1000)
async def search(query: str) -> List[Result]:
    # ... 200 行最佳化程式碼

from abc import ABC, abstractmethod
from enum import Enum
from typing import Protocol, Union
from dataclasses import dataclass

class DiscountStrategy(ABC):
    @abstractmethod
    def calculate(self, amount: float) -> float:
        pass

class PercentageDiscount(DiscountStrategy):
    def __init__(self, percentage: float):
        self.percentage = percentage

    def calculate(self, amount: float) -> float:
        return amount * (self.percentage / 100)

class FixedDiscount(DiscountStrategy):
    def __init__(self, fixed_amount: float):
        self.fixed_amount = fixed_amount

    def calculate(self, amount: float) -> float:
        return min(self.fixed_amount, amount)

@dataclass
class DiscountConfig:
    strategy: DiscountStrategy
    min_purchase: float = 0.0
    max_discount: float = float('inf')

class DiscountCalculator:
    def __init__(self, config: DiscountConfig):
        self.config = config

    def apply_discount(self, amount: float) -> float:
        if amount < self.config.min_purchase:
            return 0
        discount = self.config.strategy.calculate(amount)
        return min(discount, self.config.max_discount)

# 使用時需要 30 多行的設定才能做一個簡單的計算

class PreferenceManager:
    def __init__(self, db, cache=None, validator=None):
        self.db = db
        self.cache = cache or InMemoryCache()
        self.validator = validator or DefaultValidator()

    def save(self, user_id: int, prefs: dict,
             merge: bool = True,
             validate: bool = True,
             notify: bool = False) -> bool:
        """Save preferences with optional merging, validation, and notifications."""

        if validate:
            errors = self.validator.validate(prefs)
            if errors:
                raise ValidationError(errors)

        existing = self.get(user_id) if merge else {}

        if merge:
            existing.update(prefs)
            prefs = existing

        self.db.execute(
            "UPDATE users SET preferences = ? WHERE id = ?",
            (json.dumps(prefs), user_id)
        )

        if self.cache:
            self.cache.set(f"prefs:{user_id}", prefs)

        if notify:
            self.notify_preference_change(user_id, prefs)

        return True

    def notify_preference_change(self, user_id: int, prefs: dict):
        # 又是 30 行沒人要求的功能
        pass

   def validate_user(user_data):
-      # Check email format
-      if not user_data.get('email'):
+      """Validate user data."""
+      email = user_data.get('email', '').strip()
+
+      # Validate email
+      if not email:
             raise ValueError("Email required")
-
-      # Basic email validation
-      if '@' not in user_data['email']:
+      if '@' not in email or '.' not in email.split('@')[1]:
             raise ValueError("Invalid email")

-      # Check username
-      if not user_data.get('username'):
+      # Validate username
+      username = user_data.get('username', '').strip()
+      if not username:
             raise ValueError("Username required")
+      if len(username) < 3:
+          raise ValueError("Username too short")
+      if not username.isalnum():
+          raise ValueError("Username must be alphanumeric")

        return True

- def upload_file(file_path, destination):
+ def upload_file(file_path: str, destination: str) -> bool:
+     """Upload file to destination with logging."""
+     logger.info(f"Uploading {file_path} to {destination}")
+
      try:
-          with open(file_path, 'rb') as f:
-              data = f.read()
-
-          response = requests.post(destination, files={'file': data})
-
-          if response.status_code == 200:
-              return True
-          else:
-              return False
+          with open(file_path, "rb") as f:
+              data = f.read()
+          response = requests.post(destination, files={"file": data})
+          success = response.status_code == 200
+
+          if success:
+              logger.info(f"Upload successful: {file_path}")
+          else:
+              logger.error(f"Upload failed: {file_path}, status={response.status_code}")
+
+          return success
       except Exception as e:
-          print(f"Error: {e}")
+          logger.exception(f"Upload error for {file_path}: {e}")
            return False

我會這樣修復驗證系統：
1. 檢視程式碼
2. 找出問題
3. 進行改進
4. 測試變更

[在沒有明確成功標準的情況下開始修改]

# 在一份 300 行的提交中實作了完整的速率限制，
# 包含 Redis、多種策略、設定系統和監控
# 沒有明確的驗證步驟

# 未確認錯誤就直接修改排序邏輯
def sort_scores(scores):
    return sorted(scores, key=lambda x: (-x['score'], x['name']))