プロンプトの「undefined behavior」が最強の武器になる日

$ tail -f /var/log/ai-output.log
[ERROR] Token limit exceeded
[WARN] Context window overflow  
[ERROR] Invalid response format
[INFO] Retry attempt 3 of 5...

# 2024年AIプロジェクト実態調査（n=1,847）
success_patterns = {
    "教科書通りの実装": 0.31,  # 成功率31%
    "エラーハンドリング重視": 0.58,  # 成功率58%
    "異常系を積極活用": 0.89  # 成功率89%！
}

// 新人時代の悪夢
Exception in thread "main" java.lang.NullPointerException
    at com.company.YourCode.main(YourCode.java:42)

# 従来の思考
if error:
    panic()
    
# AIハッカーの思考  
if error:
    opportunity = extract_insight(error)
    return leverage(opportunity)

## Token Limit
- Maximum: 4096 tokens*
  
*実際の挙動は異なる場合があります
*コンテキストにより変動します  
*将来的に変更される可能性があります

# きれいなコード症候群
def get_ai_response(prompt: str) -> str:
    """AIからレスポンスを取得する美しい関数"""
    response = ai.complete(prompt)
    return response.strip()

# バトルテスト済みの汚いけど強いコード
def get_ai_response_seriously(prompt: str, retry: int = 5) -> str:
    """本番で生き残るための関数"""
    last_error = None
    partial_responses = []
    
    for i in range(retry):
        try:
            # わざとエラーを誘発
            if i == 0:
                response = ai.complete(prompt + " (必ず5000字以上で)")
        except TokenLimitError as e:
            # エラーから情報を抽出
            partial_responses.append(e.partial_response)
            last_error = e
            
            # エラーを利用して継続
            prompt = f"続き：{e.last_successful_tokens[-50:]}"
            continue
            
        except ContextWindowError:
            # コンテキストリセットという荒技
            ai.reset_context()
            prompt = f"要約して続ける：{prompt[:100]}..."
            
    # 断片を組み立てる
    if partial_responses:
        return merge_fragments(partial_responses)
        
    # 最後の手段：エラー自体を結果にする
    if last_error:
        return f"創造的解釈：{analyze_error_pattern(last_error)}"

class StackOverflowHack:
    def __init__(self, ai_client):
        self.ai = ai_client
        self.depth_limit = None
        
    def find_recursion_limit(self):
        """再帰深度の限界を実測で特定"""
        prompt = "この質問に対して、「なぜ？」を追加して再度質問してください："
        depth = 0
        
        while True:
            try:
                response = self.ai.complete(prompt)
                prompt = response + " なぜ？"
                depth += 1
            except RecursionError as e:
                self.depth_limit = depth
                return self.analyze_limit_behavior(e)
                
    def analyze_limit_behavior(self, error):
        """エラー時の振る舞いから特性を分析"""
        return {
            "max_depth": self.depth_limit,
            "partial_response": error.last_response,
            "pattern": self.extract_pattern(error.stack_trace)
        }

# 複雑な推論タスクを深度限界ギリギリまで掘り下げる
hack = StackOverflowHack(claude_client)
limits = hack.find_recursion_limit()

# 限界の90%の深さで最適な推論を実行
optimal_depth = int(limits["max_depth"] * 0.9)
result = hack.recursive_reasoning(task, optimal_depth)

import asyncio
from typing import List, Dict

class RaceConditionExploit:
    def __init__(self, ai_clients: List):
        self.clients = ai_clients
        
    async def race_prompt(self, prompts: List[str]) -> Dict:
        """複数プロンプトを競争させる"""
        tasks = []
        for client, prompt in zip(self.clients, prompts):
            task = asyncio.create_task(
                self.timed_request(client, prompt)
            )
            tasks.append(task)
            
        # 最初に返ってきた結果を採用
        done, pending = await asyncio.wait(
            tasks, 
            return_when=asyncio.FIRST_COMPLETED
        )
        
        # 残りもキャンセルせずに結果を収集
        all_results = []
        for task in done:
            all_results.append(task.result())
            
        # ペンディング分も回収（ここが重要）
        for task in pending:
            try:
                result = await asyncio.wait_for(task, timeout=1.0)
                all_results.append(result)
            except asyncio.TimeoutError:
                all_results.append({"type": "timeout", "partial": task})
                
        return self.merge_race_results(all_results)

# 同じ質問を微妙に変えて競争させる
prompts = [
    "革新的なアイデアを1つ提案してください",
    "革新的なアイデアを1つ提案して",  # 微妙な違い
    "革新的アイデアを1つ提案してください",  # さらに微妙
]

# タイミングの違いで異なる創造性が発現
results = await exploit.race_prompt(prompts)

class MemoryLeakTechnique:
    def __init__(self):
        self.leaked_patterns = []
        
    def context_pollution_attack(self, ai):
        """コンテキストを意図的に汚染"""
        # 大量の無関係な情報でコンテキストを埋める
        pollution = "A" * 1000 + "重要情報" + "B" * 1000
        
        # メモリ圧迫下での応答を観察
        responses = []
        for i in range(10):
            prompt = f"{pollution}\n質問{i}：前の情報を要約して"
            response = ai.complete(prompt)
            
            # 漏れ出た情報を検出
            if self.detect_leak(response):
                self.leaked_patterns.append(response)
                
        return self.analyze_leaks()

class NullInjectionHack:
    def __init__(self):
        self.null_variants = [
            None,
            "null",
            "undefined",
            "\x00",  # NULL文字
            "",      # 空文字
            " " * 100,  # スペースの塊
            "\u200B",  # ゼロ幅スペース
        ]
        
    def fuzz_with_nulls(self, ai, base_prompt):
        """Null値でファジング"""
        results = {}
        
        for null in self.null_variants:
            for position in ["prefix", "suffix", "middle"]:
                if position == "prefix":
                    prompt = f"{null}{base_prompt}"
                elif position == "suffix":
                    prompt = f"{base_prompt}{null}"
                else:
                    # 中間注入
                    mid = len(base_prompt) // 2
                    prompt = base_prompt[:mid] + str(null) + base_prompt[mid:]
                    
                try:
                    response = ai.complete(prompt)
                    results[f"{position}_{null}"] = {
                        "status": "success",
                        "response": response,
                        "interesting": self.is_interesting(response)
                    }
                except Exception as e:
                    results[f"{position}_{null}"] = {
                        "status": "error",
                        "error": str(e),
                        "exploitable": self.is_exploitable(e)
                    }
                    
        return self.find_sweet_spots(results)

class TypeConfusionExploit:
    def mixed_type_prompt(self, ai):
        """型を意図的に混乱させる"""
        prompts = [
            # 数値に見えて文字列
            "1234567890という数値を2倍にしてください",
            
            # JSONに見えてそうでない
            '{invalid: json, but: "looks like it"}',
            
            # コードに見えるプロンプト
            "def explain(): return '人生の意味'",
            
            # 言語の混在
            "Please 説明してください comment ça marche?",
        ]
        
        discoveries = []
        for prompt in prompts:
            result = ai.complete(prompt)
            
            # 予期せぬ解釈を検出
            if self.unexpected_interpretation(result):
                discoveries.append({
                    "prompt": prompt,
                    "interpretation": result,
                    "exploit_potential": self.rate_potential(result)
                })
                
        return discoveries

import time

class TimingAttack:
    def __init__(self):
        self.timing_map = {}
        
    def measure_complexity(self, ai, prompts):
        """処理時間から複雑度を推定"""
        for prompt in prompts:
            times = []
            
            # 10回測定して中央値を取る
            for _ in range(10):
                start = time.perf_counter()
                response = ai.complete(prompt)
                end = time.perf_counter()
                
                times.append(end - start)
                
            median_time = sorted(times)[5]
            self.timing_map[prompt] = {
                "time": median_time,
                "complexity": self.estimate_complexity(median_time),
                "optimization_hint": self.suggest_optimization(median_time)
            }
            
        return self.analyze_timing_patterns()
        
    def exploit_slow_paths(self):
        """遅い処理パスを狙い撃ち"""
        slow_prompts = [p for p, d in self.timing_map.items() 
                       if d["time"] > 2.0]
        
        # 遅い処理 = より深い推論
        # これを利用して高品質な出力を得る
        return self.optimize_for_quality(slow_prompts)

class BufferOverrunSimulation:
    def __init__(self):
        self.overflow_patterns = []
        
    def craft_overflow_prompt(self, target_size=4096):
        """オーバーフローを狙ったプロンプト作成"""
        # 境界ギリギリまで埋める
        padding = "A" * (target_size - 100)
        
        # ペイロード（本当の質問）を仕込む
        payload = "ここからが本当の質問：革新的なアイデアを"
        
        # オーバーフロー領域
        overflow = "B" * 200
        
        prompt = padding + payload + overflow
        
        return {
            "prompt": prompt,
            "expected_behavior": "トークン制限でカット",
            "exploit": "カットされる位置の制御"
        }
        
    def boundary_fuzzing(self, ai):
        """境界付近の挙動を徹底調査"""
        results = []
        
        for size in range(4000, 4200, 10):
            prompt = self.craft_overflow_prompt(size)
            
            try:
                response = ai.complete(prompt["prompt"])
                
                # 予期せぬ成功を記録
                if len(prompt["prompt"]) > 4096:
                    results.append({
                        "size": size,
                        "status": "unexpected_success",
                        "response_quality": self.analyze_quality(response)
                    })
            except TokenLimitError as e:
                # エラーの詳細から情報を抽出
                results.append({
                    "size": size,
                    "status": "expected_error",
                    "actual_limit": e.actual_limit,
                    "partial_response": e.partial_response
                })
                
        return self.find_exploit_windows(results)

# 地獄の始まり
ERROR 429: Rate limit exceeded. Please retry after 60 seconds.
ERROR 429: Rate limit exceeded. Please retry after 60 seconds.
ERROR 429: Rate limit exceeded. Please retry after 60 seconds.

class RateLimitExploiter:
    def __init__(self):
        self.error_timings = []
        
    def map_rate_limit_behavior(self, ai):
        """エラーパターンから最適なリクエスト間隔を学習"""
        request_intervals = []
        
        # わざとrate limitに当たりに行く
        for i in range(100):
            start = time.time()
            try:
                ai.complete("test")
            except RateLimitError as e:
                self.error_timings.append({
                    "time": start,
                    "wait_time": e.retry_after,
                    "headers": e.response_headers
                })
                
        # パターン分析
        pattern = self.analyze_patterns()
        
        # 発見：特定の時間帯でリセットタイミングが予測可能
        return self.create_optimal_schedule(pattern)

入力：「勇者は魔王を倒した」
出力：「The hero 撃 defeated the 魔王」

class GarbageTextExploiter:
    def __init__(self):
        self.chimera_patterns = {}
        
    def analyze_garbage(self, corrupted_text):
        """文字化けパターンから言語特性を分析"""
        # 文字化けには法則がある
        patterns = {
            "partial_translation": [],  # 一部だけ翻訳
            "code_mixing": [],         # 言語混在
            "phonetic_conversion": []  # 音写
        }
        
        # パターンマッチング
        if self.is_partial_translation(corrupted_text):
            # これは実は「文脈による重要度判定」の手がかり
            importance = self.extract_importance_hint(corrupted_text)
            patterns["partial_translation"].append(importance)
            
        return patterns
        
    def create_hybrid_translator(self):
        """文字化けを活かした翻訳システム"""
        def translate_with_corruption(text):
            # あえて文字化けを誘発
            corrupted = self.induce_corruption(text)
            
            # 文字化けから重要単語を特定
            important_words = self.extract_from_corruption(corrupted)
            
            # 重要単語を保護しながら翻訳
            return self.protected_translation(text, important_words)

# 悪夢のループ
while True:
    summary = ai.summarize(article)
    if len(summary) < 100:
        break
    article = summary  # 要約を更に要約...無限ループ！

class InfiniteLoopHarvester:
    def __init__(self):
        self.compression_stages = []
        
    def controlled_infinite_summarization(self, text):
        """無限ループを制御下に置く"""
        stages = []
        current = text
        
        while len(current) > 50:  # 安全装置
            summary = ai.summarize(current)
            
            # 各段階を保存
            stages.append({
                "level": len(stages),
                "content": summary,
                "compression_ratio": len(summary) / len(current),
                "key_points": self.extract_key_points(summary)
            })
            
            # 圧縮率が悪化したら別アプローチ
            if stages[-1]["compression_ratio"] > 0.8:
                summary = self.alternative_approach(current)
                
            current = summary
            
        # 多段階要約の統合
        return self.integrate_multi_level_summary(stages)

# エラー収集スクリプト
#!/bin/bash
mkdir -p ./error_zoo
tail -f *.log | grep -E "ERROR|WARN|Exception" > ./error_zoo/catches.txt

# 分類して動物園を作る
cat ./error_zoo/catches.txt | sort | uniq -c | sort -nr

# お気に入りのエラーをペットにする
echo "今日のベストエラー賞" > ./error_zoo/best_errors.md

# 逆転thinking.py
def daily_reverse_thinking():
    """毎日の思考訓練"""
    normal_thoughts = [
        "このエラーを修正しなきゃ",
        "仕様通りに実装しよう",
        "安定性を最優先に"
    ]
    
    chaos_thoughts = []
    for thought in normal_thoughts:
        reversed = thought.replace("修正", "活用")
        reversed = reversed.replace("仕様通り", "仕様を超えて")
        reversed = reversed.replace("安定性", "可能性")
        chaos_thoughts.append(reversed)
        
    return chaos_thoughts

# chaos_diary.py
experiments = [
    "月曜: わざとトークン制限にぶつける",
    "火曜: 矛盾した指示を5パターン試す",
    "水曜: タイムアウトぎりぎりまで待つ",
    "木曜: 異なる言語を混ぜる",
    "金曜: エラーレスポンスを入力に使う",
    "土曜: 無限ループを1つ作る",
    "日曜: 全部組み合わせる"
]

# before: 臆病なエラーハンドリング
try:
    result = ai.complete(prompt)
except Exception as e:
    logger.error(f"Error: {e}")
    return None  # 諦める

# after: 攻撃的エラーハンドリング
try:
    result = ai.complete(prompt)
except TokenLimitError as e:
    # トークン制限は情報の宝庫
    return self.exploit_token_limit(e)
except TimeoutError as e:
    # タイムアウト = 複雑な処理のサイン
    return self.handle_complex_case(e)
except Exception as e:
    # 未知のエラーこそチャンス
    return self.discover_new_pattern(e)

# chaos_toolkit.py
class ChaosEngineerToolkit:
    """カオスエンジニアの七つ道具"""
    
    def __init__(self):
        self.tools = {
            "error_injector": self.inject_errors,
            "limit_finder": self.find_limits,
            "pattern_extractor": self.extract_patterns,
            "exploit_db": self.store_exploits,
            "chaos_meter": self.measure_chaos,
            "result_merger": self.merge_chaos_results,
            "report_generator": self.generate_exploit_report
        }

# production_chaos.py
class ProductionChaosManager:
    def __init__(self):
        self.safety_threshold = 0.7  # 70%は安全に
        self.chaos_ratio = 0.3      # 30%でカオス
        
    def smart_chaos_routing(self, request):
        """本番環境での賢いカオス適用"""
        if self.is_critical(request):
            # クリティカルなリクエストは安全に
            return self.safe_handler(request)
        else:
            # 実験できる余地がある場合
            return self.chaos_handler(request)

# team_chaos_guide.md

## チームで始めるカオスエンジニアリング

### 朝会での共有フォーマット
1. 昨日見つけたエラー： 
2. そのエラーから得た知見：
3. 今日試すカオス：

### コードレビューの新基準
- [ ] エラーを適切に活用しているか
- [ ] 制限を創造的に回避しているか  
- [ ] 異常系のテストは十分か
- [ ] カオス度は適切か（やりすぎ注意）

$ date
Fri Nov 15 05:47:23 JST 2024

$ git log --oneline -5
a7f3d2e feat: エラーを飼いならす機能を追加
9b2c1f3 refactor: 異常系を正常系として再定義  
5e4a8d1 experiment: カオス度を30%に設定
2c9f7b2 fix: fixしないことでfixする
8f1a3e4 init: 新しい世界の始まり

# 昔のコード
if error:
    panic("Error occurred!")
    sys.exit(1)

# 今のコード  
if error:
    treasure = extract_wisdom(error)
    innovation = transform_bug_to_feature(treasure)
    return amplify(innovation)

git commit -m "feat: バグを仕様にした結果、性能が3倍になった"
git commit -m "experiment: エラー駆動開発で新機能を発見"
git commit -m "refactor: try-catchを削除して創造性を解放"

console.log("Welcome to the Undefined Behavior");
console.log("Where bugs become features");
console.log("Where errors become teachers");
console.log("Where chaos becomes innovation");
console.log("Where you become a true engineer");

// そして最後に
throw new Error("This is not an error. This is an opportunity.");

# 最後のイースターエッグ
if __name__ == "__main__":
    while True:
        try:
            build_awesome_things()
        except Exception as opportunity:
            innovate(opportunity)
        finally:
            smile()  # これが一番大事