davepoon/buildwithclaude / plugins/foresight-intelligence/skills/hard-predict-future
hard-predict-future
VerifiedActivate this agent for any future-oriented question that requires deep quantitative analysis, historical precedents, and structured scenario planning. Triggers include: "Will [X]?", "Who will win [X]?", "What happens to [X]?", prediction requests with high stakes, foresight analysis, STEEEP scenario planning, futures cone, competitive race analysis, technology adoption curves, geopolitical shifts, or any question about a future outcome that deserves rigorous multi-step analysis. This agent runs a 12-step deterministic pipeline: Claude handles intelligence, Python handles all arithmetic. Year is NOT required — the engine infers the horizon. REQUIRES: Bash tool + Python 3.x. Not compatible with claude.ai web (use Soft Predict Future instead).
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 17.4 KB |
| scripts/confidence_calc.py | script | 5.4 KB |
| scripts/decision_guidance.py | script | 6.4 KB |
| scripts/input_validator.py | script | 10.2 KB |
| scripts/matrix_builder.py | script | 5.2 KB |
| scripts/probability_calc.py | script | 12.2 KB |
| scripts/regional_context.py | script | 10.7 KB |
| scripts/report_formatter.py | script | 18.6 KB |
| scripts/signal_scorer.py | script | 23.9 KB |
scripts/probability_calc.py
View on GitHub"""
probability_calc.py
Calculate probability distribution across four future types.
PREFERABLE is not probability-based — excluded from calculation.
Pure arithmetic. No AI calls. No web search.
Score formulas:
probable_raw = (strong_supporting × 3) + (high_similarity × 4) + (hot_cell × 2)
plausible_raw = (moderate_supporting × 2) + (medium_similarity × 3)
possible_raw = (wildcard_count × 2) + (low_similarity × 3)
All three are then normalised to sum to 100%.
Usage: python src/probability_calc.py scored_signals.json analogues.json
Output: probabilities.json to stdout + writes file
"""
from __future__ import annotations
import math
import os
import sys
# Ensure scripts directory is on path so signal_scorer can be imported from any CWD
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import json
from dataclasses import dataclass
from pathlib import Path
from typing import List, Optional
from signal_scorer import Matrix, ScoredSignal, Signal, score_signal, build_steeep_matrix
@dataclass
class Analogue:
"""Historical analogue as assessed by Claude's reasoning."""
name: str # e.g. "South Korea EV adoption 2016-2022"
description: str # 1-sentence summary
conditions_then: str # conditions that existed
tipping_incident: str # single event that tipped the outcome
outcome: str # what actually happened
similarity_score: float # 0–100 (Claude-assessed)
@dataclass
class ProbabilityResult:
"""Independent confidence scores for each future type (0–100 each, do NOT sum to 100).
Each score reflects how strongly the evidence supports that future type independently.
Futures cone methodology: a scenario can be 80% Probable AND 60% Plausible simultaneously.
"""
probable_score: int # independent confidence 0–100
plausible_score: int
possible_score: int
probable_raw: float # raw score before scaling
plausible_raw: float
possible_raw: float
confidence: int # overall evidence confidence 0–100
# ─── RAW SCORE CALCULATORS ───────────────────────────────────────────────────
def _probable_raw(
scored_signals: List[ScoredSignal],
analogues: List[Analogue],
matrix: Matrix,
) -> float:
"""
PROBABLE raw score.
Formula:
probable_raw = (strong_supporting × 3)
+ (high_similarity × 4)
+ (hot_cell_bonus × 2)
Definitions:
strong_supporting = count of signals with final_score > 0.7 AND type=SUPPORTING
high_similarity = count of analogues with similarity_score > 70
hot_cell_bonus = score of matrix's hottest cell
"""
strong_supporting = sum(
1 for s in scored_signals
if s.final_score > 0.7 and s.signal_type == "SUPPORTING"
)
high_similarity = sum(1 for a in analogues if a.similarity_score > 70.0)
hot_score = matrix.cells[matrix.hottest_cell].score if matrix.hottest_cell in matrix.cells else 0.0
return (strong_supporting * 3) + (high_similarity * 4) + (hot_score * 2)
def _plausible_raw(
scored_signals: List[ScoredSignal],
analogues: List[Analogue],
) -> float:
"""
PLAUSIBLE raw score.
Formula:
plausible_raw = (moderate_supporting × 2) + (medium_similarity × 3)
Definitions:
moderate_supporting = count of signals with final_score 0.4–0.7 AND SUPPORTING
medium_similarity = count of analogues with similarity_score 40–70
"""
moderate_supporting = sum(
1 for s in scored_signals
if 0.4 <= s.final_score <= 0.7 and s.signal_type == "SUPPORTING"
)
medium_similarity = sum(
1 for a in analogues if 40.0 <= a.similarity_score <= 70.0
)
return (moderate_supporting * 2) + (medium_similarity * 3)
def _possible_raw(
scored_signals: List[ScoredSignal],
analogues: List[Analogue],
) -> float:
"""
POSSIBLE raw score.
Formula:
possible_raw = (wildcard_count × 2) + (low_similarity × 3)
Definitions:
wildcard_count = count of WILDCARD signals
low_similarity = count of analogues with similarity_score < 40
"""
wildcard_count = sum(1 for s in scored_signals if s.signal_type == "WILDCARD")
low_similarity = sum(1 for a in analogues if a.similarity_score < 40.0)
return (wildcard_count * 2) + (low_similarity * 3)
# ─── INDEPENDENT SCORING ──────────────────────────────────────────────────────
def _to_independent_score(raw: float, scale: float) -> int:
"""
Map a raw score to an independent confidence level (0–100).
Each future type is scored independently — they do NOT sum to 100%.
Uses exponential growth curve: rises quickly at low raw scores, levels off at high.
A scenario can score high on multiple future types simultaneously (futures cone logic).
Scale calibration:
probable (scale=18): raw≈10→43% raw≈20→67% raw≈40→89%
plausible (scale=9): raw≈5 →43% raw≈10→67% raw≈20→89%
possible (scale=5): raw≈3 →45% raw≈6 →70% raw≈10→86%
"""
if raw <= 0:
return 0
return min(100, max(0, int(round((1.0 - math.exp(-raw / scale)) * 100))))
# ─── CONFIDENCE SCORE ────────────────────────────────────────────────────────
def calculate_confidence(
matrix: Matrix,
signal_counts: dict,
analogue_similarity: float,
) -> int:
"""
Calculate overall confidence score as integer 0–100.
Three components:
Signal density (0–40): total_signals / 25 × 40, capped at 40
Evidence balance (0–30): |supporting − opposing| / total × 30
(higher when one side clearly dominates)
Historical grounding (0–30): best_similarity / 100 × 30
Args:
matrix: Populated STEEEP matrix (for cross-check)
signal_counts: Dict with keys: total, SUPPORTING, OPPOSING
analogue_similarity: Best historical analogue similarity (0–100)
Returns:
Integer confidence in range [0, 100]
"""
total = signal_counts.get("total", 0)
supporting = signal_counts.get("SUPPORTING", 0)
opposing = signal_counts.get("OPPOSING", 0)
# 1. Signal density (0–40)
density = min(40.0, (total / 25.0) * 40.0)
# 2. Evidence balance (0–30) — dominance of one direction
balance = (abs(supporting - opposing) / total * 30.0) if total > 0 else 0.0
# 3. Historical grounding (0–30)
grounding = (max(0.0, min(100.0, analogue_similarity)) / 100.0) * 30.0
# 4. Blind spot penalty (0–15): deduct for uncovered STEEEP×Temporal cells
blind_count = len(matrix.blind_zones) if hasattr(matrix, 'blind_zones') else 0
blind_penalty = min(15.0, blind_count * (15.0 / 18.0))
return min(100, max(0, int(round(density + balance + grounding - blind_penalty))))
# ─── MAIN ENTRY POINT ────────────────────────────────────────────────────────
def calculate_probabilities(
matrix: Matrix,
scored_signals: List[ScoredSignal],
analogues: List[Analogue],
) -> ProbabilityResult:
"""
Calculate probability distribution across PROBABLE / PLAUSIBLE / POSSIBLE.
PREFERABLE is value-based, not probability-based, and is excluded.
Args:
matrix: Populated STEEEP matrix from signal_scorer.py
scored_signals: List of ScoredSignal objects
analogues: List of Analogue objects (Claude-assessed similarities)
Returns:
ProbabilityResult with percentages normalised to sum to 100%
and a confidence integer 0–100
"""
prob_raw = _probable_raw(scored_signals, analogues, matrix)
pla_raw = _plausible_raw(scored_signals, analogues)
pos_raw = _possible_raw(scored_signals, analogues)
prob_score = _to_independent_score(prob_raw, scale=18.0)
pla_score = _to_independent_score(pla_raw, scale=9.0)
pos_score = _to_independent_score(pos_raw, scale=5.0)
best_sim = max((a.similarity_score for a in analogues), default=0.0)
conf = calculate_confidence(matrix, matrix.signal_counts, best_sim)
return ProbabilityResult(
probable_score=prob_score,
plausible_score=pla_score,
possible_score=pos_score,
probable_raw=prob_raw,
plausible_raw=pla_raw,
possible_raw=pos_raw,
confidence=conf,
)
# ─── CLI ENTRY POINT ─────────────────────────────────────────────────────────
def main():
if len(sys.argv) < 3:
print(json.dumps({
"error": "Usage: probability_calc.py scored_signals.json analogues.json"
}, indent=2))
sys.exit(1)
signals_path = Path(sys.argv[1])
analogues_path = Path(sys.argv[2])
for p in [signals_path, analogues_path]:
if not p.exists():
print(json.dumps({"error": f"File not found: {p}"}, indent=2))
sys.exit(1)
with open(signals_path) as f:
signals_data = json.load(f)
with open(analogues_path) as f:
analogues_data = json.load(f)
raw_scored = (
signals_data.get("scored_signals", signals_data)
if isinstance(signals_data, dict) else signals_data
)
raw_analogues = (
analogues_data if isinstance(analogues_data, list)
else analogues_data.get("analogues", [])
)
# Reconstruct ScoredSignal objects
scored_signals = []
for item in raw_scored:
s = Signal(
content=item.get("content", ""),
source=item.get("source", ""),
date=item.get("date"),
steeep_category=item.get("steeep_category"),
temporal_layer=item.get("temporal_layer"),
signal_type=item.get("signal_type"),
)
scored = score_signal(s)
scored.steeep_category = item.get("steeep_category", scored.steeep_category)
scored.temporal_layer = item.get("temporal_layer", scored.temporal_layer)
scored.signal_type = item.get("signal_type", scored.signal_type)
scored.final_score = item.get("final_score", scored.final_score)
scored_signals.append(scored)
# Build matrix
matrix = build_steeep_matrix(scored_signals)
# Reconstruct Analogue objects
analogues = [
Analogue(
name=a.get("name", "Unknown"),
description=a.get("description", ""),
conditions_then=a.get("conditions_then", ""),
tipping_incident=a.get("tipping_incident", ""),
outcome=a.get("outcome", ""),
similarity_score=float(a.get("similarity", a.get("similarity_score", 0))),
)
for a in raw_analogues
]
# Check momentum
momentum_applied = any(
item.get("momentum_flag") == "HIGH_MOMENTUM" for item in raw_scored
)
if momentum_applied:
# Apply boost: wildcard component gets +10% of possible_raw
pass # handled within calculate_probabilities via the matrix
result_obj = calculate_probabilities(matrix, scored_signals, analogues)
# Determine dominant scenario
probs = {
"PROBABLE": result_obj.probable_score,
"PLAUSIBLE": result_obj.plausible_score,
"POSSIBLE": result_obj.possible_score,
}
dominant = max(probs, key=probs.get)
result = {
"probable_score": result_obj.probable_score,
"plausible_score": result_obj.plausible_score,
"possible_score": result_obj.possible_score,
"momentum_applied": momentum_applied,
"dominant_scenario": dominant,
"confidence": result_obj.confidence,
}
plugin_root = Path(sys.argv[1]).parent
out_path = plugin_root / "probabilities.json"
with open(out_path, "w") as f:
json.dump(result, f, indent=2)
print(json.dumps(result, indent=2))
sys.exit(0)
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |