agentleFS
ralfyishereralfyishere/rules-with-receipts/.claude/skills/foresight/SKILL.md

Foresight

Skill2 starsChanged 4 months agoMITView on GitHub

Project the trajectory before committing - pre-register dated, credenced predictions about what breaks, what becomes necessary, and what pays off 5/10/20 steps ahead, then resolve them when the future arrives and score your calibration. Activate when starting any build, plan, or strategy; making architecture, roadmap, scaling, or investment bets; choosing between directions; or shipping something whose problems will surface later. Trigger signals: "will this scale", "what will we regret", "where does this break at 10x", "what will we need by then", a plan whose risk section only covers the present, or a direction justified only by today's constraints.

1 other project uses a version of this.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

4 rules. About 0 are common, 4 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈4

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Commit points: a plan approved, an architecture chosen, a build started, a direction picked over alternatives.

    line 23
  2. Distinctive:

    Resolve on arrival: When a resolve-by date passes, score the prediction (right / wrong / unresolvable-as-written) BEFORE writing new ones.

    line 56
  3. Distinctive:

    Every entry has all four parts: claim, credence, resolve-by, observable.

    line 66
  4. Distinctive:

    Pessimism-only: all predictions are failures.

    line 80

≈ “Common” is an estimate: at least 1 in 5 of the 350,495 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Foresight

Purpose

Plans reason about the present; failures and windfalls arrive from the future. The pack already attacks present-tense blind spots (failure-mode-awareness enumerates what could go wrong with the design as it stands) — but nothing owned the trajectory: by step 10 X becomes the bottleneck, by step 20 Y is cheap and we will wish we had started it now. Worse, anticipation kept in the head is unfalsifiable: hindsight rewrites "I knew it" over every outcome. Pre-registration fixes both — a prediction with a date, a credence, and an observable resolution is an asset: it can steer today's decision, and when it resolves it measures how far ahead we can actually see. Origin (operator, 2026-07-11): "I kept having to give you the ideas — you should see what's coming 5, 10, 20 steps from now."

When to use this skill

  • Commit points: a plan approved, an architecture chosen, a build started, a direction picked over alternatives.
  • Scaling-shaped decisions: growth targets, hiring, infra, pricing, market entry.
  • Shipping anything whose failure modes surface on a delay (integrations, data models, public APIs, contracts, content).
  • Reviewing a plan whose risks are all present-tense.

When NOT to use

  • Trivial or fully reversible work — a projection pass on a one-line fix is theater.
  • As a substitute for failure-mode-awareness (present-design risks) or plan-gate (the plan itself) — this runs WITH them, on the time axis.
  • To manufacture certainty: a 0.6 prediction is not a roadmap commitment, and foresight entries are not promises.

The procedure

  1. Walk the trajectory, not the snapshot. At the commit point, project along the axis that matters (steps, scale, time): what does this look like at 5, 10, 20 steps ahead? At each horizon ask four questions: what breaks? what becomes necessary? what becomes cheap or possible? what will we wish we had started now?
  2. Pre-register 3–7 predictions. Each carries: the claim, a credence (0–1), a resolve-by date, and the OBSERVABLE that resolves it. Vague predictions ("things will get complex") are inadmissible — if no observation could score it, rewrite it or drop it. Log them where the project's hypotheses live (the hypothesis queue, class foresight, or the plan doc).
  3. Keep the horizons distinct. Near entries (≈5 steps) protect the current build; far entries (≈20) are allowed to be weird — they are where the value is, because a high-credence far prediction with a cheap present-day hedge is a TASK, not a note (start the data collection now; reserve the name now; design the schema for the split now).
  4. Include positive foresight. Opportunities, compounding assets, and options-worth-buying — not only failures. Foresight is not pessimism with dates.
  5. Resolve on arrival. When a resolve-by date passes, score the prediction (right / wrong / unresolvable-as-written) BEFORE writing new ones. Unresolved predictions past their date are debt; calibration only accrues from resolved ones.
  6. Feed the result back. Resolved predictions are evidence: wrong ones go to self-improvement-loop (what did the projection miss?); patterns across resolutions become extract-approach notes; systematically over- or under-confident horizons recalibrate the next round's credences.

Quality bar

  • Every entry has all four parts: claim, credence, resolve-by, observable.
  • At least one horizon is genuinely far (the uncomfortable-to-write kind).
  • At least one entry is an opportunity, not a failure.
  • At least one prediction changed a present-day decision — otherwise this was journaling, not foresight.
  • Past-due predictions are resolved or explicitly marked unresolvable; none silently rot.

Common failure modes

  • Journaling theater: predictions written, never resolved — the loop's value is in the resolution, and skipping it also hides miscalibration.
  • Horizon collapse: everything "foresight" is next week; the far horizon — where cheap hedges have the highest payoff — goes unexamined.
  • Pessimism-only: all predictions are failures; the missed-opportunity class of regret is invisible.
  • Unfalsifiable-by-design: predictions vague enough to always be right; the observable requirement exists to kill these at write time.
  • Hindsight rewrite: scoring from memory instead of the dated entry — the pre-registration IS the defense; never edit an entry after the fact.
  • Foresight-as-commitment: treating a credenced projection as a promised deliverable; the credence is the honesty mechanism, keep it visible.

Works with sibling skills

  • failure-mode-awareness owns present-design risks; this skill owns the time axis. Run both at commit points — they catch different regret classes.
  • plan-gate plans gain a foresight section (step 2's entries).
  • discovery-loop owns the standing queue the entries live in and the cadence that resolves them; empirical-validation is how a resolution gets measured when the observable needs a test.
  • extract-approach and self-improvement-loop consume step 6's output.
  • verification-discipline keeps credences stated as credences — a 0.6 is never presented as a fact.

Provenance and maintenance

Drafted 2026-07-11 from an operator correction during hypothesis-tooling design: the recurring failure was the operator having to supply ideas and direction the agent should have projected itself — a standing investigation only refilled its own hypothesis queue after external push, and an untracked forward assumption (an unmeasured latency guess) nearly killed a live lead. Re-verify by auditing shipped projects: if a problem landed that a projection pass would have named, or foresight entries sit unresolved past their dates, the skill is failing — name which step broke.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.