🧭 Helm

Where ideas become bets, and results become decisions. Part of the Forge suite.

Created by Mohammed Nasher · Open source (MIT) · Free for anyone to use

---

Helm is a self-contained product-loop engine for AI coding assistants. Before the build, you hand it an idea — "should I build provider subscriptions?", «يستاهل نبنيه؟» — and it returns a bet: a falsifiable hypothesis with a success target, a measurement window, guardrails, and a signed kill criterion, ranked against your other ideas by evidence rather than enthusiasm. After the launch, it reads the real numbers against those pre-set terms and renders a verdict — worked, didn't, inconclusive — with the learning that steers the next bet, recorded in a running ledger.

A helm is the wheel you take twice: at the harbor to set the course, and at sea — reading the stars — to correct it. The rest of the Forge suite builds features; Helm decides which features deserve building, and tells you the truth about the ones that shipped. It closes the suite's line into a loop.

Who built this? Helm is designed and authored by Mohammed Nasher (@mhd-nasher). Released open source under MIT — use it, fork it, ship with it. If it helps you, a ⭐ and a mention go a long way.

Why Helm is different

Most product-decision tooling fails in one of two ways: it lets the roadmap run on vibes (features ship and are never judged, bets sail without exit criteria, the newest idea always wins), or it drowns small teams in measurement theater (A/B significance demanded from 50 users, OKR ceremonies, verdicts re-litigated weekly). Helm refuses both:

1. The Steady-Helm Law. Terms before the sail: every bet carries its metric, target, window, guardrails, and kill line before the build starts — a bet without a kill criterion is a wish. No verdict before the window closes, no steering on noise, no moving the target because the early numbers look bad. One reading, one verdict, one decision — then the helm is still.
2. It routes, it doesn't adjudicate. Helm owns the loop only. The feature's definition → Loom (F-). Structure → Cairn (R-). Tests → Anvil (T-). Quality → Lens (Q-). Security → Bastion (B-). Ops → Relay (D-). Blocking findings dispatch as sealed subagent missions with the suite's strict return contract; the rest park in the ledger.
3. Relay says the ship is sound; Helm says whether the voyage was worth it. Uptime, error rates, and alerts are Relay's operational lane — Helm reads adoption, funnels, and the bet's own metric. Two different questions, never confused.
4. It's stack-aware — down to what your numbers can prove. Firebase Analytics/Crashlytics flagship, web analytics, machine-consumer service metrics, and the plain-logs tier for internal tools — with the sample bar set at framing time: a 50-user app reads direction and words, honestly labeled, and nobody cosplays statistics.
5. It's an advisor at the wheel; the human owns the ship. Kill, pivot, double-down, and anything touching pricing or money are proposed with evidence and approved by the human — with a funeral plan routed to the owning siblings when a kill is signed.
6. It's verifiable. Helm ships with evals that prove it activates correctly, forces terms and surfaces unread windows, and refuses premature verdicts, moved goalposts, and significance theater.

The two failure modes it's built to avoid

Failure mode	What it looks like	How Helm avoids it
The drift	Features ship and are never judged; bets have no exit; closed windows go unread; the roadmap is vibes.	Mandatory kill lines (H-004), the ledger with reading-due dates surfaced every run (H-061), verdicts that never shrug (H-050).
Verdict theater	A/B demands on 50 users; verdicts at day 3; targets lowered mid-window; three decisions per reading.	The Steady-Helm Law + the sample bar set at framing (H-036) + frozen terms (H-030) + one-reading-one-decision (H-062).

The modes

Mode	For	What it does
Mode 0 — Guided First Bet (Beginner)	"I have an idea and no clue if it's worth building."	Plain-language interview in the user's own language (Arabic first-class); ends with a framed, signed bet.
Mode A — Frame a Bet	An idea → a bet with terms, ready for Loom.	Hypothesis, dated evidence, the probe option, five signed terms, the ledger entry.
Mode B — Read the Results	A bet's window closed.	The disciplined reading: card → window → target-vs-actual → guardrails → funnel → words → ONE verdict + ONE decision.
Mode C — Rank the Backlog	Competing ideas.	Evidence-scored ranking with the ledger's lessons voting; ends with ONE named next bet.

Every run starts at Step 0: detect the stack's signal sources, open (or found) the bet ledger — overdue readings surface first — gauge the sample honestly, and gauge the user's level.

Metadata

• Version: 1.0.0
• Name: helm
• Author: Mohammed Nasher (@mhd-nasher)
• Tagline: where ideas become bets, and results become decisions
• Modes: Guided First Bet (beginner) · Frame a Bet · Read the Results · Rank the Backlog
• Owns: the product loop — bet framing, evidence ranking, post-launch verdicts, the bet ledger
• Routes: feature definition → Loom · structure → Cairn · tests → Anvil · quality → Lens · security → Bastion · operational monitoring → Relay
• Stack-aware: Firebase Analytics/Crashlytics flagship · web analytics · service metrics · plain-logs honesty tier
• Citable: every check maps to a stable H-### id
• Category: Product decisions, prioritization & outcome measurement
• Risk: Low (advisory — frames and judges; kill/pivot/pricing proposed, human approves; writes no code, touches no data)
• License: MIT

What's inside

helm/
├── SKILL.md          # Entry point: identity, Honesty Contract, Step 0, modes, core checks, the Steady-Helm Law
├── README.md
├── FORGE_DNA.md      # The shared suite contract + boundary table (read first)
├── LICENSE  CHANGELOG.md  CITATION.cff  CONTRIBUTING.md  .gitignore
├── reference/        # checks.md (the H-### catalogue) + plain-language mirror + stack-signal-profiles.md
│                     #   + bet-terms.md + reading-results.md + verdict-craft.md + bet-ledger.md
│                     #   + handoff-protocol.md + glossary.md
├── workflows/        # guided-first-bet-for-beginners.md (Mode 0) + frame-a-bet.md (A)
│                     #   + read-the-results.md (B) + rank-the-backlog.md (C)
├── checklists/       # bet-review.md (deep) + pre-build-bet-gate.md (the H-GATE gate before Loom)
├── templates/        # bet-template.md · verdict-template.md · bet-ledger-template.md
├── examples/         # frame-subscriptions-bet.md (with the probe that replaced a month of building)
│                     #   · read-results-offers-verdict.md · rank-backlog-five-ideas.md
├── scripts/          # bet_lint.py (drift finder: missing kill lines, overdue readings; self-tested)
├── evals/            # trigger-eval.json + evals.json + README.md (skill-TDD)
└── assets/           # brand assets + generation prompts (matched to the sibling set)

Install

Claude Code (recommended):

git clone https://github.com/mhd-nasher/helm.git ~/.claude/skills/helm

Then start a new session. Helm auto-activates when you discuss whether an idea is worth building, what to build next, or whether a shipped feature worked — in English or Arabic.

Any other AI assistant: open SKILL.md and paste its content (plus the files it references as needed) into your assistant's context, or attach the repo as a knowledge source.

How to use it

Say what you're weighing, naturally:

• "Should I build this subscriptions feature, or is it a waste of time?" → Mode A (or 0), a signed bet
• "I have five ideas and one developer — which first?" → Mode C, the evidence ranking
• "The feature's been live six weeks — did it work?" → Mode B, the verdict
• «يستاهل نبنيه؟» / «هل الميزة نجحت؟» / «وش أبني الجاي؟» — the same three, in Arabic

Helm settles one bet per run — and when the decision is proposed, it stops.

Verify it works

From the repo root:

python3 scripts/bet_lint.py --self-test

cd evals && python3 -c "import json; json.load(open('trigger-eval.json')); json.load(open('evals.json')); print('evals OK')"

python3 scripts/bet_lint.py templates/bet-ledger-template.md

The first proves the linter catches every drift class (9/9). The second validates the eval files. The third runs the linter against the intentionally-unfilled ledger template — expect leads: that's the tool refusing silent drift, which is the whole point.

Scope & honesty

Helm produces framed bets and evidence-cited verdicts, not business guarantees. A "worked" verdict means the pre-set target was met in its window — never "this product will succeed"; an "inconclusive" names what would settle it. Verdict confidence is capped by what your user count can actually prove, and that cap is chosen before the data arrives. Kill, pivot, and pricing decisions are proposed with their evidence and consequences — the wheel is always the human's.

The Forge suite & the boundary contract

Skill	Owns	Helm's relationship
🧭 Helm	The product loop — bets, priorities, verdicts	This repo.
🧵 Loom	Feature definition & completeness	Helm's winning bet is Loom's ask; Loom's instrumentation (F-120s) makes Helm's metric measurable.
💎 Facet	The interface	A redesign is a bet — Helm frames it with a metric and a kill line; Facet executes once it sails.
🗿 Cairn	Architecture & structure	Structural causes and kill-removal design route to Cairn (R-###).
🔨 Anvil	Testing	Helm never writes tests; a kill's regression cover of what remains is Anvil's (T-###).
🔍 Lens	Code quality & review	Quality smells noticed mid-reading park to Lens (Q-###).
🛡️ Bastion	Security & resilience	Exploit-shaped anomalies in the data route to Bastion (B-###).
🚀 Relay	Ship & operate	Relay watches health continuously; Helm reads outcomes per window. Ops fires route to Relay (D-###).

The natural flow: Helm sets the course → Loom defines → Facet gives it a face → Cairn designs → Anvil tests → Lens cleans → Bastion guards → Relay ships → Helm reads the results — and the loop turns. Non-linear by design — enter at any skill, or invoke forge and let the conductor run the chain.

Contributing

Contributions welcome — new signal profiles, sharper Steady-Helm guardrails, more evals (especially must_not cases), new checks with their evals, worked examples, and plain-language/translation improvements. See CONTRIBUTING.md. A check without an eval doesn't ship.

Author & Credits

Mohammed Nasher (@mhd-nasher) — design, authorship, and the Forge suite. If Helm saved you from building the wrong thing — or from keeping it — a ⭐ helps others find it.

License

MIT — free for anyone to use, fork, and build on.