# ===== 従来型: コードをゼロから書く =====
# 開発者が全てのロジックを手動で実装
import csv
from datetime import datetime
 
def parse_sales_report(filepath: str) -> dict:
    """売上レポートを解析する（手動実装: 約30分）"""
    results = {'total': 0, 'by_category': {}, 'by_month': {}}
    with open(filepath, 'r') as f:
        reader = csv.DictReader(f)
        for row in reader:
            amount = float(row['amount'])
            category = row['category']
            month = datetime.strptime(row['date'], '%Y-%m-%d').strftime('%Y-%m')
 
            results['total'] += amount
            results['by_category'].setdefault(category, 0)
            results['by_category'][category] += amount
            results['by_month'].setdefault(month, 0)
            results['by_month'][month] += amount
    return results
 
# ===== AI時代: 意図を伝えてAIに実装させる =====
# プロンプト: "CSVの売上レポートを解析して、合計・カテゴリ別・月別に集計する関数を作って。
#             pandasを使い、型ヒント付き、エラーハンドリングも入れて"
# → AIが完全な実装を生成 → 人間がレビュー（約5分）

# AI時代の中核スキル: 的確なプロンプト設計
 
# BAD: 曖昧なプロンプト
prompt_bad = "APIを作って"
 
# GOOD: 構造化されたプロンプト
prompt_good = """
以下の仕様でREST APIエンドポイントを実装してください。
 
## 要件
- フレームワーク: FastAPI
- エンドポイント: POST /api/v1/orders
- 認証: Bearer Token (JWT)
- バリデーション: Pydanticモデル
 
## データモデル
- order_id: UUID (自動生成)
- user_id: int (必須)
- items: list[OrderItem] (1個以上)
- total: Decimal (自動計算)
 
## エラーハンドリング
- 401: 認証エラー
- 422: バリデーションエラー
- 500: サーバーエラー
 
## テスト
- 正常系1件、異常系2件のテストも含めてください
"""

# Step 1: AIに初期設計を依頼
"""
プロンプト: "ECサイトの在庫管理システムのドメインモデルを設計して。
DDDのパターンを使って、集約ルートはInventoryItem"
"""
 
# Step 2: AIの出力をレビューし、フィードバック
"""
プロンプト: "良い設計だが、以下を修正して:
1. 在庫引当(reservation)の概念が抜けている
2. 楽観ロックのバージョン管理を追加して
3. ドメインイベントを発行するようにして"
"""
 
# Step 3: 段階的に品質を高める
"""
プロンプト: "このドメインモデルに対して:
1. 不変条件(invariant)を明示的にassertで表現して
2. Property-based testingのテストを追加して
3. 並行性のテストシナリオも作って"
"""

# AIが生成したコードを評価するチェックリスト
 
class AIOutputReviewer:
    """AIの出力をレビューするための思考フレームワーク"""
 
    CHECKLIST = {
        "正確性": [
            "ビジネスロジックは要件を正しく反映しているか？",
            "エッジケースは考慮されているか？",
            "型の整合性は取れているか？",
        ],
        "セキュリティ": [
            "入力のバリデーションは適切か？",
            "SQLインジェクション等の脆弱性はないか？",
            "秘密情報がハードコードされていないか？",
        ],
        "保守性": [
            "命名は明確で一貫しているか？",
            "単一責任の原則を守っているか？",
            "テスタブルな構造になっているか？",
        ],
        "性能": [
            "N+1クエリは発生しないか？",
            "不要なメモリ確保はないか？",
            "適切なインデックスを前提としているか？",
        ],
    }
 
    @staticmethod
    def review(code: str, context: str) -> list[str]:
        """レビュー観点に基づいてチェック項目を返す"""
        findings = []
        for category, checks in AIOutputReviewer.CHECKLIST.items():
            for check in checks:
                # 人間が各項目を確認
                findings.append(f"[{category}] {check}")
        return findings

// 開発者のAI活用成熟度を段階的に表現
 
enum AIMaturityLevel {
  LEVEL_1 = "コード補完の受け入れ",      // Tab補完を使う程度
  LEVEL_2 = "チャットでの質問",          // エラー解決を聞く
  LEVEL_3 = "プロンプト駆動開発",        // 仕様からコード生成
  LEVEL_4 = "AIペアプログラミング",      // 対話的に設計・実装
  LEVEL_5 = "AIオーケストレーション",    // 複数AIエージェントを統括
}
 
interface DeveloperProfile {
  maturityLevel: AIMaturityLevel;
  coreSkills: string[];
  aiSkills: string[];
}
 
// レベル5の開発者プロファイル例
const seniorAIDev: DeveloperProfile = {
  maturityLevel: AIMaturityLevel.LEVEL_5,
  coreSkills: [
    "アーキテクチャ設計",
    "ドメインモデリング",
    "技術選定と評価",
    "チームリーディング",
  ],
  aiSkills: [
    "プロンプトエンジニアリング",
    "AIエージェントの設計",
    "MCP/Tool Useの構築",
    "AI出力の品質保証",
  ],
};

# AI協業のタスク分類と最適な協業パターン
 
from enum import Enum
from dataclasses import dataclass
 
class TaskComplexity(Enum):
    LOW = "低"       # ボイラープレート、定型変換
    MEDIUM = "中"    # 機能実装、テスト作成
    HIGH = "高"      # アーキテクチャ設計、最適化
    CRITICAL = "最重要"  # セキュリティ、決済
 
class AIContribution(Enum):
    GENERATE = "生成"      # AIが初稿を作る
    ASSIST = "支援"        # AIが提案、人間が判断
    VERIFY = "検証"        # 人間が作り、AIがチェック
    NONE = "不使用"        # 人間のみで対応
 
@dataclass
class TaskClassification:
    task_type: str
    complexity: TaskComplexity
    ai_contribution: AIContribution
    human_time_without_ai: str
    human_time_with_ai: str
    risk_level: str
 
# タスク分類の具体例
TASK_CLASSIFICATIONS = [
    TaskClassification(
        task_type="CRUD API実装",
        complexity=TaskComplexity.LOW,
        ai_contribution=AIContribution.GENERATE,
        human_time_without_ai="2-4時間",
        human_time_with_ai="15-30分",
        risk_level="低"
    ),
    TaskClassification(
        task_type="ビジネスロジック実装",
        complexity=TaskComplexity.MEDIUM,
        ai_contribution=AIContribution.ASSIST,
        human_time_without_ai="4-8時間",
        human_time_with_ai="1-2時間",
        risk_level="中"
    ),
    TaskClassification(
        task_type="マイクロサービス設計",
        complexity=TaskComplexity.HIGH,
        ai_contribution=AIContribution.ASSIST,
        human_time_without_ai="数日",
        human_time_with_ai="数時間+レビュー",
        risk_level="高"
    ),
    TaskClassification(
        task_type="認証・暗号化実装",
        complexity=TaskComplexity.CRITICAL,
        ai_contribution=AIContribution.VERIFY,
        human_time_without_ai="数日",
        human_time_with_ai="数日（AIはレビュー役）",
        risk_level="最高"
    ),
    TaskClassification(
        task_type="テストコード生成",
        complexity=TaskComplexity.LOW,
        ai_contribution=AIContribution.GENERATE,
        human_time_without_ai="1-3時間",
        human_time_with_ai="10-20分",
        risk_level="低"
    ),
    TaskClassification(
        task_type="パフォーマンスチューニング",
        complexity=TaskComplexity.HIGH,
        ai_contribution=AIContribution.ASSIST,
        human_time_without_ai="数日",
        human_time_with_ai="数時間",
        risk_level="中"
    ),
]

# AI時代のスキル投資ROI分析
 
from dataclasses import dataclass
 
@dataclass
class SkillInvestment:
    skill: str
    category: str
    time_to_learn: str
    ai_replacement_risk: str  # AIに代替されるリスク
    career_impact: str        # キャリアへの影響度
    roi_score: int            # 1-10 (投資対効果)
 
SKILL_INVESTMENTS = [
    # 高ROI: AI時代に価値が上がるスキル
    SkillInvestment("問題構造化・仕様設計", "コア", "3-6ヶ月", "低", "非常に高い", 10),
    SkillInvestment("アーキテクチャ設計", "コア", "1-2年", "低", "非常に高い", 9),
    SkillInvestment("プロンプトエンジニアリング", "AI", "1-3ヶ月", "中", "高い", 9),
    SkillInvestment("ドメイン知識（業界専門）", "ビジネス", "1-3年", "非常に低", "高い", 9),
    SkillInvestment("コードレビュー・品質判断", "コア", "6ヶ月", "低", "高い", 8),
    SkillInvestment("システム思考・全体設計", "コア", "1-2年", "低", "非常に高い", 8),
 
    # 中ROI: 依然として重要だが変化するスキル
    SkillInvestment("テスト戦略設計", "エンジニアリング", "3-6ヶ月", "中", "高い", 7),
    SkillInvestment("デバッグ・トラブルシューティング", "コア", "6ヶ月", "中", "中程度", 6),
    SkillInvestment("特定フレームワーク熟練", "技術", "3-6ヶ月", "高", "中程度", 5),
 
    # 低ROI: AIに代替されやすいスキル（投資優先度低）
    SkillInvestment("ボイラープレート記述", "技術", "1ヶ月", "非常に高", "低い", 2),
    SkillInvestment("API仕様暗記", "技術", "1-3ヶ月", "非常に高", "低い", 2),
    SkillInvestment("定型コード変換", "技術", "1ヶ月", "非常に高", "低い", 1),
]
 
def prioritize_learning(skills: list[SkillInvestment]) -> list[SkillInvestment]:
    """ROIスコア順に学習優先度をソート"""
    return sorted(skills, key=lambda s: s.roi_score, reverse=True)

# AI時代の開発者学習計画（12ヶ月プラン）
 
## Q1: 基礎固め（月1-3）
### AI活用の基本
- [ ] AIコーディングツール（Copilot/Cursor/Claude Code）の操作習得
- [ ] プロンプト設計の基本パターン（CRISP/CLEAR）の習得
- [ ] AI出力のレビュースキル（5層モデル）の練習
 
### コアスキル強化
- [ ] 問題構造化能力: 曖昧な要件を明確な仕様に変換する練習
- [ ] アーキテクチャパターン: Clean Architecture/Hexagonal の理解
 
## Q2: 実践応用（月4-6）
### AI協業の深化
- [ ] エージェントモードの活用（Claude Code/Cursor Agent）
- [ ] MCPサーバーの構築と社内ツール連携
- [ ] CI/CDパイプラインへのAI統合
 
### 専門領域の強化
- [ ] ドメイン知識の深掘り（業界固有の知識体系化）
- [ ] セキュリティレビュースキルの強化
 
## Q3: リーダーシップ（月7-9）
### チーム展開
- [ ] チーム向けAI活用研修の設計と実施
- [ ] プロンプトライブラリの構築と共有
- [ ] AI活用ガイドラインの策定
 
### 高度な活用
- [ ] マルチエージェント設計（並列Agent運用）
- [ ] AI品質メトリクスの設計と計測
 
## Q4: 組織的展開（月10-12）
### 戦略的活用
- [ ] AI活用のROI測定と経営レポート
- [ ] 次世代ツールの評価と導入計画
- [ ] AI倫理ガイドラインの策定
 
### 継続的改善
- [ ] ベストプラクティスの文書化
- [ ] メンタリングプログラムの確立

# スタートアップでのAI活用実例
 
# 従来アプローチ: 3名のエンジニアで3ヶ月
# AI活用アプローチ: 2名のエンジニアで6週間
 
"""
AI活用の具体的内訳:
 
Week 1-2: 設計フェーズ
  人間の作業:
    - ユーザーインタビューの分析と要件整理
    - ビジネスモデルの検証
    - 技術選定の最終判断
  AIの作業:
    - ワイヤーフレームからコンポーネント構造の提案
    - データベーススキーマの初案生成
    - API設計書のドラフト作成
 
Week 3-4: バックエンド実装
  人間の作業:
    - 決済フローの設計とレビュー
    - サードパーティAPI統合の設計
    - セキュリティ要件の確認
  AIの作業:
    - CRUD APIの自動生成（全20エンドポイント）
    - バリデーションロジックの実装
    - テストコードの自動生成（カバレッジ85%）
 
Week 5-6: フロントエンド + デプロイ
  人間の作業:
    - UXの微調整と最終確認
    - デプロイ戦略の決定
    - セキュリティ監査
  AIの作業:
    - Reactコンポーネントの生成
    - Tailwind CSSでのスタイリング
    - E2Eテストのシナリオ生成
    - Terraform設定ファイルの生成
"""

# チーム生産性ダッシュボードの指標設計
 
from dataclasses import dataclass
from enum import Enum
 
class MetricCategory(Enum):
    SPEED = "速度"
    QUALITY = "品質"
    SATISFACTION = "満足度"
    COST = "コスト"
 
@dataclass
class AIEffectivenessMetric:
    name: str
    category: MetricCategory
    measurement: str
    target: str
    frequency: str
 
METRICS = [
    # 速度指標
    AIEffectivenessMetric(
        "PR作成〜マージ時間", MetricCategory.SPEED,
        "GitHub API で自動計測", "50% 短縮", "週次"
    ),
    AIEffectivenessMetric(
        "1人あたりデプロイ頻度", MetricCategory.SPEED,
        "CI/CD ログから計測", "2倍に増加", "週次"
    ),
    AIEffectivenessMetric(
        "バグ修正リードタイム", MetricCategory.SPEED,
        "Issue クローズまでの時間", "40% 短縮", "月次"
    ),
 
    # 品質指標
    AIEffectivenessMetric(
        "本番バグ密度", MetricCategory.QUALITY,
        "バグ数 / 1000行コード", "30% 減少", "月次"
    ),
    AIEffectivenessMetric(
        "テストカバレッジ", MetricCategory.QUALITY,
        "CI計測", "80% 以上維持", "PR ごと"
    ),
    AIEffectivenessMetric(
        "セキュリティ脆弱性検出数", MetricCategory.QUALITY,
        "SAST / DAST ツール", "増加（早期発見）", "月次"
    ),
 
    # 満足度指標
    AIEffectivenessMetric(
        "開発者満足度", MetricCategory.SATISFACTION,
        "月次アンケート（1-5）", "4.0 以上", "月次"
    ),
    AIEffectivenessMetric(
        "AI活用自信度", MetricCategory.SATISFACTION,
        "自己評価（1-5）", "全員3.0以上", "四半期"
    ),
 
    # コスト指標
    AIEffectivenessMetric(
        "AIツール月額費用", MetricCategory.COST,
        "請求額集計", "ROI 3倍以上", "月次"
    ),
    AIEffectivenessMetric(
        "人件費あたり生産量", MetricCategory.COST,
        "機能ポイント / 人月", "25% 向上", "四半期"
    ),
]

# BAD: AIの出力を検証せずにプロダクションにデプロイ
# AIが「正しそう」に見えるコードを生成しても、
# ドメイン固有のバグが潜んでいる可能性がある
 
def calculate_shipping_fee(weight_kg: float, zone: str) -> int:
    """AIが生成した送料計算"""
    # AIは一般的なロジックを生成するが、
    # 自社固有の送料テーブル、割引ルール、
    # 離島料金などは知らない
    base = weight_kg * 100  # ← 自社の料金体系と異なる可能性
    return int(base)
 
# GOOD: AIの出力をドメイン知識で検証
def calculate_shipping_fee(weight_kg: float, zone: str) -> int:
    """送料計算 - 自社料金テーブルに基づく"""
    # 自社固有のビジネスルールを適用
    rate = SHIPPING_RATE_TABLE[zone]  # 実際の料金テーブルを参照
    base = weight_kg * rate.per_kg
    if zone in REMOTE_ISLAND_ZONES:
        base += rate.remote_surcharge
    return max(int(base), rate.minimum_fee)

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]