Pockit
Back

AI生成コードが本番で壊れる理由と対策 - 現場で使えるデバッグ完全ガイド

AI生成コードが本番で壊れる理由と対策

こんな経験ありませんか？AIアシスタントが完璧に見えるコードを出してくれる。シンタックスも綺麗だし、ロジックも通ってるし、コメントまで丁寧についてる。コピペしてローカルでテストすると問題なく動く。でも本番にデプロイした途端、数時間でアラートが鳴り止まなくなる。

あなただけじゃないです。 最近のアンケートによると、84%の開発者がAIコーディングツールを使っています。でもそのうち46%が「AIの出力を完全には信用できない」と答えている。一番多い不満は何か？「惜しいけど微妙に違う」コード——これのデバッグが、ゼロから書くより辛いという現実。

AIコーディングツールを否定したいわけじゃありません。本当に便利なツールです。でも大事な知識が抜けている：なぜAI生成コードが本番で壊れるのか、そしてどうやって事前に防ぐのか。この記事でそこをカバーします。

なぜAIコードは本番で壊れるのか

デバッグの話に入る前に、まずなぜAIコードがローカルでは動くのに本番では壊れるのかを理解しましょう。ランダムなバグじゃないです。LLMの仕組みから来る予測可能なパターンがあります。

1. コンテキストウィンドウの限界

AIモデルにはコンテキストウィンドウの制限があります。コードを生成するとき、あなたのコードベース全体を見てるわけじゃない。一部しか見えてません。だからこういう問題が起きます：

存在しないimportを使う: AIが学習データのパターンから「あるはず」と推測した関数やライブラリを使うけど、実際にはあなたのプロジェクトにない。

// 「正しそうに見える」AIコード
import { validateUserInput } from '@/utils/validation';
import { sanitizeHTML } from '@/lib/security';

async function processUserData(data) {
  const validated = validateUserInput(data);
  const safe = sanitizeHTML(validated.content);
  // ...
}

問題は？あなたのプロジェクトでは @/utils/validation じゃなくて @/helpers/validation かもしれないし、sanitizeHTML 関数自体がないかもしれない。こういうエラーはランタイムまで分かりません。

命名規則がバラバラ: AIは学習した複数のコードベースのスタイルを混ぜて使いがち：

# 命名規則が混在したAIコード
def getUserData(user_id):  # キャメルケース
    user_info = fetch_user_info(user_id)  # スネークケース
    return user_info.getData()  # またキャメルケース

# あなたのコードベースはスネークケースで統一
def get_user_data(user_id):
    user_info = fetch_user_info(user_id)
    return user_info.get_data()

2. 学習データが古い

これが一番厄介な問題。AIは特定の時点のコードで学習してますが、APIやライブラリやベストプラクティスは常に変わっています。

deprecatedなAPIを使う: AIが学習カットオフ以降にdeprecatedになったAPIを平気で使う：

// deprecatedパターンを使うAI Reactコード
class UserProfile extends React.Component {
  componentWillMount() {  // React 16.3からdeprecated
    this.fetchUserData();
  }
  
  componentWillReceiveProps(nextProps) {  // これもdeprecated
    if (nextProps.userId !== this.props.userId) {
      this.fetchUserData(nextProps.userId);
    }
  }
}

// 今のスタイル
function UserProfile({ userId }) {
  useEffect(() => {
    fetchUserData(userId);
  }, [userId]);
}

古いセキュリティパターン: ここからが危ない。セキュリティのベストプラクティスは速く変わるのに、AIが今では脆弱だと分かっているパターンを使うことがある：

# セキュリティ的にNGなAIコード
import hashlib

def hash_password(password):
    return hashlib.md5(password.encode()).hexdigest()  # 絶対ダメ

# 正しいやり方
import bcrypt

def hash_password(password):
    return bcrypt.hashpw(password.encode(), bcrypt.gensalt())

3. ハッピーパスしか知らない

AIは主にサンプルコードやチュートリアルで学習しています。これらはほぼ「うまくいくケース」しか見せない。でも本番コードは「うまくいかないケース」を全部カバーしないといけない：ネットワーク障害、変なデータ、同時リクエスト、メモリ不足、あらゆるエッジケース。

エラーハンドリングがない:

// AIコード：ハッピーパスでは完璧
async function fetchAndProcessData(url: string) {
  const response = await fetch(url);
  const data = await response.json();
  return data.items.map(item => item.name.toUpperCase());
}

// 本番の現実：全部壊れる可能性がある
async function fetchAndProcessData(url: string) {
  let response;
  try {
    response = await fetch(url, { 
      timeout: 5000,
      signal: AbortSignal.timeout(5000)
    });
  } catch (error) {
    if (error.name === 'TimeoutError') {
      throw new DataFetchError('タイムアウト', { url, cause: error });
    }
    throw new DataFetchError('ネットワークエラー', { url, cause: error });
  }
  
  if (!response.ok) {
    throw new DataFetchError(`HTTP ${response.status}`, { 
      url, 
      status: response.status 
    });
  }
  
  let data;
  try {
    data = await response.json();
  } catch (error) {
    throw new DataFetchError('JSONパース失敗', { url, cause: error });
  }
  
  if (!data?.items || !Array.isArray(data.items)) {
    throw new DataFetchError('レスポンス構造がおかしい', { url, data });
  }
  
  return data.items
    .filter(item => item?.name != null)
    .map(item => String(item.name).toUpperCase());
}

nullチェックがない:

// AIコード：データが常に完全だと仮定
function getUserDisplayName(user) {
  return `${user.firstName} ${user.lastName}`;
}

// 本番：不完全なデータも処理
function getUserDisplayName(user) {
  if (!user) return 'Unknown User';
  const parts = [user.firstName, user.lastName].filter(Boolean);
  return parts.length > 0 ? parts.join(' ') : user.email || 'Unknown User';
}

4. 並行処理を知らない

AIが学習するコードのほとんどはシングルスレッドの同期コード。だからAIコードには本番のトラフィックで壊れるレースコンディションが潜んでいることが多い。

# AIコード：良さそうだけどレースコンディションあり
class Counter:
    def __init__(self):
        self.count = 0
    
    def increment(self):
        self.count += 1  # アトミックじゃない！
        return self.count

# 同時アクセスで壊れる
# 2つのスレッドが同時にcount=5を読んで、両方が6を書く

# 正しいバージョン
import threading

class Counter:
    def __init__(self):
        self.count = 0
        self._lock = threading.Lock()
    
    def increment(self):
        with self._lock:
            self.count += 1
            return self.count

JavaScriptのasyncレースコンディション:

// AIコード：微妙なレースコンディション
let cachedUser = null;

async function getUser(id) {
  if (!cachedUser || cachedUser.id !== id) {
    cachedUser = await fetchUser(id);
  }
  return cachedUser;
}

// 違うidで連続呼び出しすると：
// 呼び出し1: id=1、fetch開始
// 呼び出し2: id=2、fetch開始（cachedUserまだnull）
// 呼び出し2が先に完了、cachedUser = user2
// 呼び出し1が完了、user1で上書き
// 呼び出し2側がuser1を受け取ってしまう！

// 修正版
const pendingRequests = new Map();

async function getUser(id) {
  if (cachedUser?.id === id) {
    return cachedUser;
  }
  
  if (pendingRequests.has(id)) {
    return pendingRequests.get(id);
  }
  
  const promise = fetchUser(id).then(user => {
    cachedUser = user;
    pendingRequests.delete(id);
    return user;
  });
  
  pendingRequests.set(id, promise);
  return promise;
}

AIコードのデバッグ戦略

壊れるパターンが分かったところで、どう対処するか見ていきましょう。

戦略1: マージ前チェックリスト

AIコードがmainブランチに入る前にこれをチェック：

import検証:

# JS/TSプロジェクト
npx tsc --noEmit 2>&1 | grep "Cannot find module"

# Pythonプロジェクト
python -c "import ast; ast.parse(open('file.py').read())"
python -m py_compile file.py

deprecated APIチェック:

// package-audit.js
const fs = require('fs');
const content = fs.readFileSync(process.argv[2], 'utf8');

const deprecatedPatterns = [
  { pattern: /componentWillMount/g, message: 'React deprecated ライフサイクル' },
  { pattern: /componentWillReceiveProps/g, message: 'React deprecated ライフサイクル' },
  { pattern: /findDOMNode/g, message: 'React deprecated API' },
  { pattern: /substr\(/g, message: 'deprecated、substring()を使って' },
];

deprecatedPatterns.forEach(({ pattern, message }) => {
  const matches = content.match(pattern);
  if (matches) {
    console.warn(`⚠️ ${message}: ${matches.length}件`);
  }
});

エラーハンドリングチェック:

# bare except探し
import ast
import sys

class ErrorHandlingChecker(ast.NodeVisitor):
    def __init__(self):
        self.issues = []
    
    def visit_ExceptHandler(self, node):
        if node.type is None:
            self.issues.append(f"{node.lineno}行目: bare except")
        elif isinstance(node.type, ast.Name) and node.type.id == 'Exception':
            if not any(isinstance(n, ast.Raise) for n in ast.walk(node)):
                self.issues.append(f"{node.lineno}行目: Exceptionキャッチして再throwしてない")
        self.generic_visit(node)

tree = ast.parse(open(sys.argv[1]).read())
checker = ErrorHandlingChecker()
checker.visit(tree)
for issue in checker.issues:
    print(issue)

戦略2: 本番環境シミュレーション

AIがほぼカバーしない本番シナリオをテスト：

// stress-test.js

class ProductionSimulator {
  // ネットワークエラーをシミュレート
  async withNetworkFailure(fn, failureRate = 0.3) {
    const original = global.fetch;
    global.fetch = async (...args) => {
      if (Math.random() < failureRate) {
        throw new TypeError('Failed to fetch');
      }
      return original(...args);
    };
    
    try {
      return await fn();
    } finally {
      global.fetch = original;
    }
  }
  
  // 遅いレスポンスをシミュレート
  async withLatency(fn, minMs = 100, maxMs = 5000) {
    const original = global.fetch;
    global.fetch = async (...args) => {
      const delay = minMs + Math.random() * (maxMs - minMs);
      await new Promise(resolve => setTimeout(resolve, delay));
      return original(...args);
    };
    
    try {
      return await fn();
    } finally {
      global.fetch = original;
    }
  }
  
  // おかしなデータをシミュレート
  async withMalformedData(fn) {
    const original = global.fetch;
    global.fetch = async (...args) => {
      const response = await original(...args);
      return {
        ...response,
        json: async () => {
          const data = await response.json();
          return this.corruptData(data);
        }
      };
    };
    
    try {
      return await fn();
    } finally {
      global.fetch = original;
    }
  }
  
  corruptData(data) {
    if (Array.isArray(data)) {
      return data.map((item, i) => 
        i % 3 === 0 ? null : this.corruptData(item)
      );
    }
    if (typeof data === 'object' && data !== null) {
      const keys = Object.keys(data);
      const corrupted = { ...data };
      keys.forEach(key => {
        if (Math.random() < 0.2) delete corrupted[key];
      });
      return corrupted;
    }
    return data;
  }
  
  // 同時リクエストをシミュレート
  async withConcurrency(fn, concurrencyLevel = 100) {
    const promises = Array(concurrencyLevel)
      .fill(null)
      .map(() => fn());
    
    const results = await Promise.allSettled(promises);
    const failures = results.filter(r => r.status === 'rejected');
    
    if (failures.length > 0) {
      console.error(`${failures.length}/${concurrencyLevel}件失敗`);
      failures.forEach(f => console.error(f.reason));
    }
    
    return results;
  }
}

戦略3: 既存コードとの比較テスト

AIが既存機能を置き換えるコードを書いたら、動作が同じか確認：

# differential_test.py
import json
import random
from typing import Any, Callable

def differential_test(
    original_fn: Callable,
    ai_generated_fn: Callable,
    input_generator: Callable,
    num_tests: int = 1000
) -> list[dict]:
    """AIコードの動作が違う入力を探す"""
    
    differences = []
    
    for i in range(num_tests):
        test_input = input_generator()
        
        try:
            original_result = original_fn(test_input)
            original_error = None
        except Exception as e:
            original_result = None
            original_error = type(e).__name__
        
        try:
            ai_result = ai_generated_fn(test_input)
            ai_error = None
        except Exception as e:
            ai_result = None
            ai_error = type(e).__name__
        
        if original_result != ai_result or original_error != ai_error:
            differences.append({
                'input': test_input,
                'original': {'result': original_result, 'error': original_error},
                'ai_generated': {'result': ai_result, 'error': ai_error}
            })
    
    return differences

# 使い方
def generate_random_user_input():
    """エッジケース込みのランダム入力"""
    edge_cases = [
        None,
        {},
        {'name': None},
        {'name': ''},
        {'name': 'a' * 10000},
        {'name': '<script>alert("xss")</script>'},
        {'name': '👨‍👩‍👧‍👦'},
        {'name': 'O\'Brien'},
        {'id': float('nan')},
        {'id': float('inf')},
    ]
    
    if random.random() < 0.2:
        return random.choice(edge_cases)
    
    return {
        'name': ''.join(random.choices('abcdefghijklmnop', k=random.randint(1, 50))),
        'id': random.randint(-1000, 1000)
    }

differences = differential_test(
    original_process_user,
    ai_generated_process_user,
    generate_random_user_input
)

if differences:
    print(f"{len(differences)}件の差分が見つかりました！")
    print(json.dumps(differences[:5], indent=2))

戦略4: ロギングを最初からちゃんとやる

本番で壊れてからローカルで再現しようとしても、だいたい失敗します。同じ条件を作れないから。だから最初からログをしっかり仕込む：

// observability.ts

interface CodeExecutionContext {
  functionName: string;
  aiGenerated: boolean;
  inputs: Record<string, any>;
  startTime: number;
}

class ObservableWrapper {
  private context: CodeExecutionContext;
  
  constructor(functionName: string, aiGenerated: boolean = true) {
    this.context = {
      functionName,
      aiGenerated,
      inputs: {},
      startTime: Date.now()
    };
  }
  
  recordInput(name: string, value: any) {
    this.context.inputs[name] = this.sanitize(structuredClone(value));
  }
  
  recordCheckpoint(name: string, data?: any) {
    console.log(JSON.stringify({
      type: 'checkpoint',
      ...this.context,
      checkpoint: name,
      data: this.sanitize(data),
      elapsed: Date.now() - this.context.startTime
    }));
  }
  
  recordSuccess(result: any) {
    console.log(JSON.stringify({
      type: 'success',
      ...this.context,
      result: this.sanitize(result),
      duration: Date.now() - this.context.startTime
    }));
  }
  
  recordError(error: Error, additionalContext?: any) {
    console.error(JSON.stringify({
      type: 'error',
      ...this.context,
      error: {
        message: error.message,
        name: error.name,
        stack: error.stack
      },
      additionalContext,
      duration: Date.now() - this.context.startTime
    }));
  }
  
  private sanitize(obj: any): any {
    if (obj === null || obj === undefined) return obj;
    if (typeof obj !== 'object') return obj;
    
    const sensitiveKeys = ['password', 'token', 'secret', 'apiKey', 'authorization'];
    const result: any = Array.isArray(obj) ? [] : {};
    
    for (const [key, value] of Object.entries(obj)) {
      if (sensitiveKeys.some(k => key.toLowerCase().includes(k))) {
        result[key] = '[REDACTED]';
      } else if (typeof value === 'object') {
        result[key] = this.sanitize(value);
      } else {
        result[key] = value;
      }
    }
    
    return result;
  }
}

// 使い方
async function aiGeneratedProcessOrder(order: Order) {
  const obs = new ObservableWrapper('processOrder', true);
  obs.recordInput('order', order);
  
  try {
    obs.recordCheckpoint('validation_start');
    const validated = validateOrder(order);
    obs.recordCheckpoint('validation_complete', { isValid: true });
    
    obs.recordCheckpoint('payment_start');
    const payment = await processPayment(validated);
    obs.recordCheckpoint('payment_complete', { paymentId: payment.id });
    
    obs.recordCheckpoint('fulfillment_start');
    const result = await fulfillOrder(validated, payment);
    obs.recordCheckpoint('fulfillment_complete');
    
    obs.recordSuccess(result);
    return result;
  } catch (error) {
    obs.recordError(error as Error, { 
      orderState: order.status,
      retryable: isRetryableError(error)
    });
    throw error;
  }
}

予防が一番：AIに強い開発パイプライン

デバッグしなくて済むのが一番いい。そもそも問題を防ぐ方法を見ていきましょう。

1. AIへの指示をちゃんとする

## 本番用AIプロンプトテンプレート

[関数の説明]を以下の要件で書いて：

**状況:**
- このコードは[想定トラフィック]を受ける本番で動く
- [既存システム]と連携する
- うちのコードベースは[命名規則]と[コードスタイル]を使ってる

**必須:**
1. エラーハンドリング入れて：
   - ネットワークエラー、タイムアウト
   - 不正な入力
   - null/undefined
   - 同時リクエスト

2. 入力バリデーション入れて

3. 重要なポイントにログ入れて

4. エッジケース全部カバーして

5. この依存関係だけ使って（ないものは使わないで）：
   [使える依存関係リスト]

**やらないで:**
- deprecated API使わないで
- 例外握りつぶさないで
- 外部サービスが常に動くと仮定しないで
- データが常に完全だと仮定しないで

**スタイル:**
- [snake_case/camelCase]使って
- asyncならタイムアウト処理必須
- 関数は50行以内

2. CIで自動チェック

# .github/workflows/ai-code-review.yml
name: AI Code Review

on:
  pull_request:
    paths:
      - '**.js'
      - '**.ts'
      - '**.py'

jobs:
  ai-code-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: AIコードパターン検出
        run: |
          # asyncにtry/catchあるか
          grep -rn "async.*{$" --include="*.ts" --include="*.js" | \
            xargs -I {} sh -c 'file="{}"; grep -L "try\|catch" "$file" && echo "$fileにtry/catchなし"'
          
          # Python bare except
          grep -rn "except:$" --include="*.py" && echo "bare except見つかった"
          
          # deprecated React
          grep -rn "componentWillMount\|componentWillReceiveProps" --include="*.tsx" --include="*.jsx" && \
            echo "deprecated Reactライフサイクル見つかった"
          
      - name: 複雑度チェック
        run: |
          npx complexity-report --format json src/ | \
            jq '.functions[] | select(.complexity > 15) | {name, complexity}'
          
      - name: セキュリティパターンチェック
        run: |
          grep -rn "md5\|sha1" --include="*.py" --include="*.js" | grep -i password && \
            echo "脆弱なハッシュ関数見つかった"

3. AIコード隔離パターン

AIコードは信頼できない入力と同じ扱い。隔離して、検証して、徐々に信頼を築く：

// ai-code-quarantine.ts

interface QuarantinedFunction<TInput, TOutput> {
  implementation: (input: TInput) => TOutput | Promise<TOutput>;
  validator: (input: TInput) => boolean;
  sanitizer: (input: TInput) => TInput;
  fallback: (input: TInput, error: Error) => TOutput;
}

function createQuarantinedFunction<TInput, TOutput>(
  config: QuarantinedFunction<TInput, TOutput>
) {
  return async function quarantined(input: TInput): Promise<TOutput> {
    if (!config.validator(input)) {
      throw new Error('入力バリデーション失敗');
    }
    
    const sanitizedInput = config.sanitizer(input);
    
    try {
      const result = await Promise.race([
        config.implementation(sanitizedInput),
        new Promise<never>((_, reject) => 
          setTimeout(() => reject(new Error('タイムアウト')), 5000)
        )
      ]);
      
      return result;
    } catch (error) {
      console.error('隔離関数失敗:', error);
      return config.fallback(sanitizedInput, error as Error);
    }
  };
}

// 使い方
const processUserData = createQuarantinedFunction({
  implementation: aiGeneratedProcessUserData,
  validator: (input) => input != null && typeof input.id === 'number',
  sanitizer: (input) => ({ ...input, name: String(input.name || '').slice(0, 100) }),
  fallback: (input, error) => {
    return originalProcessUserData(input);
  }
});

人間とAIのコラボレーション

目標はAIを使わないことじゃない。AIがスピードを出して、人間が安定性を担保する協業モデルを作ること。

レビューチェックリスト

AIコードをマージする前の確認事項：

## AIコードレビューチェックリスト

### 必須（全部パスすること）
- [ ] import全部ある
- [ ] deprecated API使ってない
- [ ] エラーハンドリングある（ネットワーク、タイムアウト、null）
- [ ] 入力バリデーションある
- [ ] 機密情報ログに出してない
- [ ] ハードコードされたシークレットない

### 本番ready
- [ ] 並行処理対応できてる
- [ ] リトライロジックある
- [ ] サーキットブレーカーある
- [ ] デバッグ用ログある
- [ ] リソースクリーンアップ保証されてる

### スタイル
- [ ] 命名規則合ってる
- [ ] 複雑度適切
- [ ] エッジケーステストある

信頼レベルシステム

AIコードへの信頼を段階的に上げる：

レベル1 - 隔離（0-10回使用）: フォールバック必須、ログ多め、シャドウテスト
レベル2 - 監視（10-100回）: フォールバック準備、ログ強化
レベル3 - 信頼（100回以上無事故）: 通常ログ、フォールバック不要

まとめ

AIコードが本番で壊れるのは予測可能：コンテキスト制限、古い学習データ、ハッピーパスだけ、並行処理知らない。このパターンを知っていればデプロイ前に防げるし、壊れても素早く直せる。

ポイント：

  1. AIはあなたのコードベースを知らない — パターンから推測してるだけ。import、命名、依存関係は必ず確認。

  2. AIはサンプルで学んだ、本番で学んでない — エラーハンドリング、エッジケース、並行処理は自分でテスト。

  3. AI学習データは過去のもの — deprecated API、古いセキュリティパターンをチェック。

  4. ログは最初からちゃんと — AIコードマークつけとくとデバッグが早い。

  5. 信頼しつつ検証 — 隔離パターンで安全に統合しながら本番の安定性を維持。

2026年に活躍する開発者は、AIを使わない人でも、AIを盲信する人でもない。壊れるパターンを理解して、検証パイプラインを作って、人間-AIコラボレーションをうまくやる人たち。

AIコードはなくならない。なぜ壊れるか、どう直すかを知るのが今や必須スキルです。

aidebuggingproductioncode-qualitybest-practicesllm