[
  {
    "id": 1,
    "name": "Sun Tzu Doctrine Extractor",
    "category": "strategy_analysis",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that takes a military conflict description (JSON with: conflict_name, date_range, participants, terrain, force_ratios, outcome) and maps it against Sun Tzu's core principles. For each principle (know your enemy, deception, terrain advantage, avoid prolonged war, win without fighting), score how well each side applied it (0-1) with evidence from the input. Detect which violated principles led to defeat. Output: a structured JSON with principle_scores per side, critical_violations, and a plain-text analysis of what Sun Tzu would have advised differently. The tool should work on ANY conflict — ancient or modern."
  },
  {
    "id": 2,
    "name": "Tribalism Bias Detector",
    "category": "human_patterns",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that analyzes war justification texts for tribalism bias. Given a JSON array of war_speeches (each with: speaker, date, nation, text, audience), detect: (1) in-group/out-group language — words that dehumanize the enemy or elevate the speaker's group, (2) false dichotomy patterns — 'us vs them' framing with no middle ground, (3) historical revisionism — claims about the past that omit inconvenient facts, (4) appeals to divine authority — using religion or destiny to justify violence, (5) economic misdirection — blaming outsiders for internal problems. Score each speech on a tribalism index (0-100). Output a structured JSON report with detected patterns, specific quotes, tribalism score, and a comparison showing how BOTH sides of any conflict use identical rhetorical devices against each other."
  },
  {
    "id": 3,
    "name": "Escalation Ladder Simulator",
    "category": "conflict_dynamics",
    "difficulty": 5,
    "language": "python",
    "description": "Write a Python simulation that models conflict escalation using Herman Kahn's escalation ladder. Given an initial conflict state (JSON with: parties, grievances, current_level, military_capabilities, alliances, economic_ties), simulate escalation/de-escalation steps. Each step: evaluate rational incentives vs emotional drivers for each party, compute probability of escalation given the current rung, model the effect of third-party intervention, track civilian impact at each level. Run Monte Carlo simulation (N configurable runs) to produce probability distributions for outcomes: diplomatic resolution, limited war, total war, nuclear threshold. Output: escalation probability chart data (JSON), most likely path, critical decision points where intervention would have maximum effect, and a plain-text briefing."
  },
  {
    "id": 4,
    "name": "Common Humanity Pattern Miner",
    "category": "human_patterns",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that analyzes conflict datasets to find universal human patterns across all wars. Given a JSON file of conflicts (each with: name, era, region, religion_involved, ethnic_groups, stated_cause, actual_cause, duration_years, casualties, outcome, peace_terms), compute: (1) frequency of stated vs actual causes — how often is the real reason different from the propaganda, (2) cross-cultural constants — patterns that appear in EVERY era regardless of culture/religion/region, (3) the 'mirror test' — for each conflict, show how both sides used identical justifications against each other, (4) civilian impact ratio over time. Output a JSON report proving that human conflict follows the same patterns regardless of color, creed, or geography. Include a function that takes any new conflict description and predicts which universal patterns it will follow."
  },
  {
    "id": 5,
    "name": "Strategic Blunder Classifier",
    "category": "strategy_analysis",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that classifies military strategic blunders by type. Given a JSON description of a military decision (decision_maker, date, context, decision, outcome, casualties), classify it against known blunder archetypes: (1) hubris — underestimating the enemy (Napoleon in Russia, US in Vietnam, Israel Oct 7), (2) sunk cost — continuing because too much is already invested (WWI trench warfare), (3) groupthink — no one challenged the plan (Bay of Pigs), (4) mirror imaging — assuming the enemy thinks like you do, (5) escalation commitment — small intervention that keeps growing (mission creep), (6) technology worship — believing superior weapons guarantee victory. Score each archetype (0-1), identify the primary blunder type, and generate a 'lessons learned' summary. Include a function that takes a PROPOSED military action and flags which blunder risks it carries."
  },
  {
    "id": 6,
    "name": "Peace Agreement Structural Analyzer",
    "category": "resolution",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that analyzes peace agreements for structural weaknesses that predict future conflict. Given a JSON peace_agreement (parties, date, terms, territorial_changes, power_sharing, enforcement_mechanism, guarantors), check for known failure patterns: (1) humiliation clauses — terms that leave one side with grievances (Versailles), (2) no enforcement mechanism — who enforces it and with what, (3) excluded parties — groups affected but not at the table, (4) resource imbalance — one side gets disproportionate resources, (5) no reconciliation process — no path for former enemies to coexist. Score durability (0-1) and predict time-to-breakdown. Output a structural analysis JSON with specific flags and historical parallels. Include a 'fix suggestions' function that proposes amendments to address each weakness."
  },
  {
    "id": 7,
    "name": "Propaganda Symmetry Analyzer",
    "category": "human_patterns",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that proves propaganda is symmetric — every technique one side uses, the other uses too. Given two JSON arrays of media_items from opposing sides of a conflict (each with: source, date, headline, text, images_described, target_audience), run pairwise analysis: (1) find matching propaganda techniques (demonization, victimhood narrative, selective history, atrocity emphasis, civilian shield claims), (2) compute a symmetry score — how similar are the two sides' messaging strategies, (3) identify the IDENTICAL claims made by both sides ('they started it', 'they target civilians', 'God is on our side', 'we had no choice'), (4) extract the underlying human needs being exploited on both sides (fear, pride, revenge, belonging). Output a mirror report showing matching pairs side by side, proving both sides are running the same playbook."
  },
  {
    "id": 8,
    "name": "Clausewitz Fog of War Modeler",
    "category": "strategy_analysis",
    "difficulty": 5,
    "language": "python",
    "description": "Write a Python simulation that models Clausewitz's 'fog of war' — the uncertainty, friction, and chaos that makes real warfare nothing like the plan. Given a battle scenario (JSON with: forces, terrain, objectives, plan, communication_capability, weather), simulate N iterations where each iteration introduces random friction events: (1) communication delays/failures, (2) intelligence errors (enemy position wrong by X km), (3) supply chain disruptions, (4) units arriving late or at wrong positions, (5) commander decisions based on incomplete information. Track how far each iteration diverges from the original plan. Output: plan vs reality divergence scores, a friction impact ranking showing which types of friction cause the most damage, and a 'robustness score' for the original plan — how well does it survive contact with reality. Include analysis of why simple plans outperform complex ones under fog."
  },
  {
    "id": 9,
    "name": "Cycle of Violence Tracker",
    "category": "conflict_dynamics",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that tracks cycles of violence in a conflict and identifies escalation triggers. Given a chronological JSON array of events (date, actor, action_type, casualties, stated_justification, target), detect: (1) retaliation chains — A attacks B, B retaliates, A retaliates for the retaliation, (2) escalation patterns — each cycle's severity compared to the previous, (3) trigger events — which specific actions caused the biggest jumps in violence, (4) cooling periods — gaps between cycles and what caused them, (5) the point of no return — where de-escalation became structurally impossible. Output a cycle analysis JSON with each identified cycle, its trigger, escalation factor, and a timeline visualization data structure. Include a function that predicts the next cycle's probable timing and severity based on the pattern."
  },
  {
    "id": 10,
    "name": "War Cost Truthifier",
    "category": "human_patterns",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that computes the TRUE cost of a war — not the sanitized version. Given a conflict (JSON with: name, duration, direct_military_cost, casualties_military, casualties_civilian, refugees, infrastructure_destroyed, pre_war_gdp_per_capita), compute the full cost: (1) direct military spending, (2) opportunity cost — what that money could have built (schools, hospitals, infrastructure — compute specific numbers), (3) human capital loss — lifetime economic output of casualties by age distribution, (4) refugee cost — hosting nations' burden and refugees' lost productivity, (5) generational trauma — estimated mental health impact on children in the conflict zone affecting next 2 generations' productivity. Output a structured report in both JSON and plain text that makes the REAL cost viscerally clear. Include a comparison: 'for the cost of this war, you could have built X schools and Y hospitals'."
  },
  {
    "id": 11,
    "name": "David vs Goliath Strategy Detector",
    "category": "strategy_analysis",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that identifies asymmetric warfare strategies — when the smaller force wins through superior situational awareness, not superior force. Given a conflict dataset (JSON with: force_ratios, technology_gap, terrain, strategy_used, outcome, key_decisions), classify the winning strategy: (1) terrain exploitation — using geography to negate force advantage, (2) time as a weapon — outlasting the larger force's political will, (3) information advantage — knowing the enemy better than they know you, (4) cost imposition — making the war too expensive to continue, (5) legitimacy capture — winning the narrative while losing battles. Identify which conflicts were won by the 'David' and what specific situational intelligence they applied. Output a strategy taxonomy JSON and a 'field manual' of asymmetric principles that work across all eras, proving that understanding the situation beats having more weapons."
  },
  {
    "id": 12,
    "name": "Dehumanization Language Tracker",
    "category": "human_patterns",
    "difficulty": 4,
    "language": "python",
    "description": "Write a Python tool that tracks dehumanization language as a leading indicator of conflict. Given a time-series JSON of public communications (speeches, media, social posts — each with: date, source, text, audience_size), detect the evolution of language about a target group: (1) subtle othering — 'those people', 'they don't share our values', (2) threat framing — portraying the group as dangerous, (3) vermin/disease metaphors — comparing humans to animals or parasites, (4) numbers rhetoric — reducing people to statistics, (5) elimination language — explicit calls for removal. Track the progression over time and compute a 'danger index' that historically correlates with mass violence onset. Output a timeline JSON showing language escalation stages and a warning system: green → yellow → orange → red. The core insight: this pattern is IDENTICAL regardless of which group is being targeted — it's the human playbook for justifying the unjustifiable."
  },
  {
    "id": 13,
    "name": "Failed Deterrence Autopsy",
    "category": "strategy_analysis",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that performs an autopsy on failed deterrence — why did the war happen when both sides should have known the cost? Given a pre-war situation (JSON with: military_balance, economic_interdependence, nuclear_capability, alliance_commitments, diplomatic_channels, leader_psychology, domestic_pressure), analyze: (1) miscalculation — did the aggressor wrongly believe it would be cheap/quick, (2) audience cost trap — was the leader trapped by their own rhetoric, (3) commitment credibility — did the defender fail to make their red lines believable, (4) rationality failure — did emotional/ideological factors override rational cost-benefit, (5) information failure — was critical intelligence ignored or suppressed. Score each factor and identify the primary failure mode. Output a JSON autopsy report with root cause, contributing factors, and a 'what would have prevented this' section."
  },
  {
    "id": 14,
    "name": "Universal Soldier Experience Mapper",
    "category": "human_patterns",
    "difficulty": 3,
    "language": "python",
    "description": "Write a Python tool that maps the universal experience of soldiers across all wars to prove that combatants on all sides share the same humanity. Given a JSON array of soldier_accounts (each with: conflict, side, era, nationality, religion, account_text), extract common themes: (1) fear before battle, (2) bonds with fellow soldiers, (3) moral injury — guilt over what they did or saw, (4) disillusionment — the gap between propaganda and reality, (5) longing for home, (6) recognition of the enemy's humanity — 'they're just like us' moments. Compute theme prevalence across all wars, eras, and sides. Output a JSON analysis proving these experiences are universal — a Roman legionnaire, a WWI Tommy, a Vietnam draftee, an Afghan fighter all describe the same human experience. Include a 'mirror pairs' function that finds matching quotes from opposing sides of the same conflict."
  },
  {
    "id": 15,
    "name": "Stupidity-to-Casualties Calculator",
    "category": "conflict_dynamics",
    "difficulty": 5,
    "language": "python",
    "description": "Write a Python tool that quantifies how many people died because of demonstrably stupid beliefs. Given a dataset of conflicts (JSON with: name, era, stated_cause, actual_cause, belief_system_invoked, casualties, could_have_been_avoided, avoidance_mechanism), categorize the underlying stupid belief: (1) racial superiority — we're better because of skin color, (2) religious mandate — God told us to kill them, (3) nationalist myth — our borders are sacred/our people are special, (4) ideological purity — our economic system justifies murder, (5) strongman syndrome — one leader's ego costs thousands of lives, (6) revenge cycle — they killed ours so we kill theirs forever. Compute total casualties per category across all of human history. Output a brutally honest JSON report with: total dead per stupid belief, the average war duration caused by each, and a 'sanity check' — for each belief, show how people on BOTH sides of the same conflict held the SAME belief about themselves. Include the final metric: total humans killed over things that were provably wrong."
  }
]