DEV Community: connerlambden

How to improve your IQ (without lying to yourself)

connerlambden — Mon, 20 Jul 2026 16:54:42 +0000

Search demand for "how to improve your IQ" and "how to improve your intelligence" usually wants one of three different things, and sellers often blur them.

Three claims people mix up

Test score movement. Practice effects, item familiarity, sleep, and anxiety can move an IQ score without proving a durable jump in general intelligence (g).
Competence growth. Crystallized skill and domain expertise keep rising for years with hard study. That is real improvement even when Raven-like fluid scores barely budge.
Far transfer from brain games to broad Gf. Near transfer to trained tasks is common. Large lasting Gf gains are not the default finding once active controls enter the picture.

If an article promises a free upgrade to general intelligence from puzzles alone, shrink the claim until it matches the evidence.

A boring adult plan that survives contact with research

Sleep and aerobic exercise first.
Deliberate practice in a hard domain (math, language, code, music).
Optional adaptive reasoning practice if you enjoy it.
Treat any practice estimate as training feedback, not a clinical IQ diagnosis.

Sources I maintain

Claim-size map: intelligencemax.ai/guide
Evidence pack: osf.io/kja9b

Disclosure: I build IntelligenceMax, an adaptive reasoning gym. Practice software is not a promise that apps raise trait IQ.

Lumosity, Elevate, Peak: same aisle, different drills

connerlambden — Thu, 16 Jul 2026 21:06:32 +0000

Search demand lumps Lumosity, Elevate, Peak, BrainHQ, and NeuroNation into one bucket: "brain training apps." Product design does not.

Three different product jobs

Language / productivity drills (Elevate-shaped): reading, writing, listening, math fluency. Progress charts track those drills.
Cognitive mini-games (Lumosity / Peak-shaped): memory, attention, flexibility, speed under time pressure.
Reasoning practice (what I ship): adaptive multiple-choice distinctions at your edge, with an honest practice score that is not a clinical IQ claim.

If you evaluate all three with the same KPI ("raises IQ"), you will misread the literature and mis-buy the subscription.

What the evidence usually supports

Independent reviews of commercial brain training typically find:

Near transfer: you get better at the trained tasks and close cousins.
Far transfer: weak under careful controls for everyday reasoning / general intelligence.

Useful anchors: Simons et al. 2016; Melby-Lervåg, Redick & Hulme 2016 on working-memory training. Pick the app whose drills match the skill you actually want to practice.

I keep a public claim-size map here: intelligencemax.ai/guide (OSF: osf.io/kja9b).

Why this matters for builders

If you are shipping adaptive difficulty, do not market "adaptive" as "clinically validated IQ gains." Adaptive means the item bank tracks an ability estimate for your task family. That is useful. It is still not an IQ test.

Disclosure: I build IntelligenceMax, an iOS reasoning gym. Practice estimate ≠ clinical IQ.

Quick chooser

Want…	Prefer…
Grammar / reading fluency games	Elevate-like
Short attention/memory mini-games	Lumosity/Peak-like
Hard MCQ reasoning under adaptive difficulty	Reasoning gym

Same aisle. Different drills. Claim size is the product.

What "adaptive" should mean in a reasoning practice app

connerlambden — Thu, 16 Jul 2026 20:58:45 +0000

Most apps that say adaptive just mean a streak counter and a harder level after three greens.

I shipped IntelligenceMax on the App Store with a narrower definition.

Adaptive as serving, not as a vibe

After each answer, the app updates a practice estimate and uses that to choose later item difficulty. Explanations appear after submit, not before. That is the loop: miss → see why → get something near that edge again.

What the score is not

The estimate uses an IRT-shaped update and can be shown on an IQ-looking scale for readability. It is still an in-app practice metric. It is not a normed clinical IQ battery, and shipping to the App Store does not change that.

Why builders should care about the claim size

App Store categories reward big cognitive verbs. Independent reviews of commercial brain training are usually clearer about near transfer than about far transfer. If your product only proves "people get better at your items," say that. Do not let the marketing department invent adult g.

Try / read

App Store: https://apps.apple.com/us/app/intelligencemax/id6786447264
Methods: https://intelligencemax.ai/science

I build IntelligenceMax. Feedback on explanation quality beats applause for IQ theater.

I graded my own ML option forecasts. Here's the Brier score.

connerlambden — Tue, 14 Jul 2026 22:24:55 +0000

In May I promised — out loud, on the internet, where people can screenshot you — that I'd grade Helium's published prob_itm forecasts when the June 2026 AAPL contracts expired.

June 26 came. The contracts died. So I graded them.

This is not a victory lap. Mean Brier loss on n=2 is 0.3846. A coin flip that always says 0.5 scores 0.25 when the world resolves to 0 or 1. We did worse than a coin flip. That is information.

What we froze in May

Contract	Helium `prob_itm`	Market-ish implied
AAPL $310C 2026-06-26	0.42	~0.50
AAPL $295P 2026-06-26	0.23	~0.24

What the stock actually did

AAPL NASDAQ close on 2026-06-26: $283.78

$310 call → OTM → realized ITM = 0 → Brier = (0.42 − 0)² = 0.1764
$295 put → ITM → realized ITM = 1 → Brier = (0.23 − 1)² = 0.5929

Honest read (short)

The call forecast was closer to reality than the market's ~0.50 shrug — but "closer" is not "good." Any non-zero probability on an OTM finish still costs you.
The put is the bruise. Probabilities looked aligned pre-expiry; then the underlying fell hard enough that both market and model had understated the ITM risk. Helium's number was far from 1, so the Brier loss is ugly.
n=2. This is a promise kept, not a calibration paper. If you want to treat it as science, wait for more expiries on the honesty board.

Reproduce

git clone https://github.com/connerlambden/helium-mcp-cookbook
cd helium-mcp-cookbook
python calibration/grade_june_expiry.py

Frozen inputs live in calibration/june_2026_forecasts.json.

Why bother publishing a bad score

Because the alternative is the usual ML options blog post: a backtest, a vibe, a screenshot of a green P&L. Publishing prob_itm with a fixed expiry is a tiny discipline. Grading it after the fact is the second half of that discipline.

If you log your own forecasts with recipe 02, you can run the same scorer when your contracts expire. I'll keep adding rows.

—

Also adjacent, if you're here for news rather than options: we published a free 212×37 news-outlet framing corpus with an explorer. Different animal. Same "put numbers where people can grade them" instinct.

An IRT-shaped practice score is not an IQ test

connerlambden — Tue, 14 Jul 2026 22:10:27 +0000

IntelligenceMax updates a learner estimate after every answer and displays it on the familiar IQ scale. The arithmetic resembles item response theory. That resemblance is useful, but it is easy to ask the formula to carry more meaning than it can bear.

A formula can be internally consistent while its inputs remain uncertain. Here, the distinction begins with the item parameters.

The update rule

For ability θ, item difficulty b, and discrimination a, the model assumes a logistic P(correct). The first estimate has a normal prior centred at 100 with SD 15. After an answer, the implementation takes one capped local update using score and Fisher information. Per-answer change is capped at 1.5 points.

The calculation is the easy part. The inputs are where the uncertainty lives.

Model-assigned is not empirically calibrated

The AI that generates each question also assigns difficulty and discrimination. Those values are checked for shape and range, but they are not fitted from a norming sample. Calling the update IRT-style describes the logistic form. It does not establish that 115 means the same thing as a score of 115 on a validated instrument.

What this number can support

Within those limits, the estimate can support an adaptive practice loop. It cannot establish a clinical Full Scale IQ, a permanent change in general intelligence, transfer to school or work, or treatment of a cognitive condition.

Reviews of commercial brain training find the strongest evidence on trained tasks and close relatives. Broad gains are less convincing against active controls (Simons et al., 2016; Melby-Lervåg et al., 2016).

Until empirical calibration exists:

This is a logistic, IRT-shaped practice estimate that uses model-assigned item parameters. It is not a normed IQ score.

Public notes: https://intelligencemax.ai/science
Evidence map: https://intelligencemax.ai/guide
OSF: https://osf.io/kja9b/

Disclosure: I built IntelligenceMax. The technical question I most want readers to challenge is whether useful empirical calibration is possible for generated, mostly one-off items without quietly turning the system into a fixed bank.

How to improve your IQ without lying to yourself

connerlambden — Tue, 14 Jul 2026 21:02:57 +0000

People type “how to improve IQ” into Google the way thirsty people type “how to hydrate instantly.” Fair. Also: the internet will sell you a miracle before it sells you sleep.

What IQ is (and is not)

IQ is a test score. Useful. Incomplete. Noisy day to day. It is not a moral ranking, a destiny, or a personality.

If your plan is “raise my number by Friday,” you are shopping for fog. Scores move with sleep, anxiety, practice effects, and which test you took.

What actually tends to help

Schooling and hard domain practice still look better than most commercial brain-training promises. Exercise and sleep help cognition more reliably than another puzzle leaderboard. Reading hard books and taking feedback that can embarrass you remains undefeated.

Near transfer vs far transfer

Near transfer is real: practice a skill, get better at that skill and nearby ones.

Far transfer — train a game, raise general intelligence forever — is where ads get loud and meta-analyses get quiet. Simons et al. (2016) on commercial brain training. Melby-Lervåg and colleagues on working-memory training. Treat “this app raised my IQ 15 points” with the same skepticism you would bring to a late-night fitness infomercial.

A plan that is kinder than chasing points

Pick one hard skill you will actually use.
Force weekly output that can be graded or rejected.
Sleep like it is part of the training.
Revisit IQ only if you need it for something concrete. Do not let it narrate your identity.

Disclosure

I build IntelligenceMax: adaptive reasoning practice. We do not claim it raises IQ. We care about transfer honesty.

Longer map: intelligencemax.ai/guide

OSF notes: osf.io/kja9b

Canonical essay: How to improve your IQ (without lying to yourself)

Getting sharper is allowed. Lying to yourself about what transferred is optional, and expensive.

An IRT-shaped practice score is not an IQ test

connerlambden — Tue, 14 Jul 2026 16:39:53 +0000

A formula can be internally consistent while its inputs remain uncertain. Here, the distinction begins with the item parameters.

The update rule

For ability θ, item difficulty b, and discrimination a, the model assumes:

P(correct) = sigmoid(a × (θ - b) / 15)

The first estimate has a normal prior centred at 100 with a standard deviation of 15. After an answer u, where correct is 1 and incorrect is 0, the implementation takes one capped local update using the score and Fisher information:

information = (a / 15)² × p × (1 - p)
posterior precision = prior precision + information
delta = (u - p) × (a / 15) / posterior precision

The per-answer change is capped at 1.5 points. Displayed uncertainty also has a floor, including a 15 / √n evidence floor based on the number of answers.

Suppose the current estimate is 100 with a standard error of 5. A question has b = 115 and a = 1.2. The assumed probability of a correct answer is about 0.23. A correct response moves the estimate up by about 1.5 points after the cap; an incorrect response moves it down by about 0.45.

The calculation is the easy part to show. The inputs are where the uncertainty lives.

Model-assigned is not empirically calibrated

The AI that generates each question also assigns its difficulty and discrimination. Those values are checked for shape and range, but they are not fitted from a norming sample. Calling the update "IRT-style" describes the logistic form. It does not establish that 115 means the same thing as a score of 115 on a validated instrument.

The current system can calculate the answer probability implied by the learner estimate and the assumed item parameters. It does not yet establish that questions labelled 115 are answered at the predicted rate across an appropriate population. That would require empirical item calibration, stable items, enough responses per item, and checks for differential item functioning.

The product also reports a separate confidence-calibration score. That score is a Brier-style measure comparing a user's stated confidence with correctness. It does not validate item difficulty or the ability estimate.

What this number can support

Within those limits, the estimate can support an adaptive practice loop. It gives the system a consistent way to react to surprising answers and prefer questions near the current estimate.

It cannot establish a clinical Full Scale IQ, a permanent change in general intelligence, transfer to school or work, or treatment of a cognitive condition. Those conclusions require validated instruments and, for change claims, a study that separates training from expectation, retesting, selection, and ordinary fluctuation.

The transfer literature matters here. Reviews of commercial brain training and working-memory training find the strongest evidence on trained tasks and close relatives. Broad gains are less convincing, especially against active control groups. A rising practice estimate may represent learning within the task family. It is not evidence by itself that a distant ability changed.

What I would test next

An empirical calibration report should group responses by predicted probability and compare prediction with observed accuracy. A simple first diagnostic would publish reliability bins, sample counts, and a Brier score or log loss for the model's P(correct). Stable reusable items would permit item-level residuals. Generated one-off items make that harder and may require hierarchical evaluation by prompt version, domain, and assigned difficulty band.

Until that work exists, the precise statement is:

This is a logistic, IRT-shaped practice estimate that uses model-assigned item parameters. It is not a normed IQ score.

The current measurement notes are public at https://intelligencemax.ai/science.

Sources:

Simons et al. (2016): https://doi.org/10.1177/1529100616661983
Melby-Lervåg, Redick, and Hulme (2016): https://doi.org/10.1177/1745691616635612

App Store update

IntelligenceMax is now on the App Store. The practice-score limits in this article still apply on iPhone.

Open evidence matrix for "get smarter" claims (OSF)

connerlambden — Tue, 14 Jul 2026 05:00:00 +0000

Commercial brain training often sells far transfer: practice this game, get smarter in life. Cognitive psychology usually finds something narrower: people get better at what they practice, and generalization is the hard part.

A usable filter for get-smarter claims:

Name the outcome (acute state, skill/knowledge, aging trajectory, measured IQ, or trained-task score).
Ask what transferred (same task family vs a broader battery with real controls).
Prefer active controls and pre-registration over testimonials.
Remove real constraints first (sleep debt, clinical issues, true deficiencies), then build hard skills for competence goals.

I published a small open companion for this filter: an evidence-ranked CSV of interventions related to intelligence / cognitive performance outcomes, plus a citation pack. It is not a systematic review of everything, and it does not claim that any product raises IQ.

OSF project: https://osf.io/kja9b/
Narrative companion: https://intelligencemax.ai/guide

Disclosure: I maintain the matrix and also build educational software in the space (IntelligenceMax). Use the OSF files on their own if you only want the CSV.

Claim Roulette: 12 “get smarter” ads, graded in 12 seconds each

connerlambden — Tue, 14 Jul 2026 03:28:59 +0000

Claim Roulette: 12 “get smarter” ads, graded in 12 seconds each

A silly format that makes a serious distinction. Each claim gets a letter grade and one verdict. Steal freely.

Grading scale

A — Strong, boring, replicable pathway for a named outcome
B — Real effect, wrong marketing
C — Near transfer / training dressed as magic
D — Hypothesis cosplaying as product science
F — Soup marketed as a g vaccine

“Train 10 minutes a day and raise your IQ.”

Grade: F. IQ batteries are not app streaks. Trained-task gains ≠ general ability.
“Sleep debt destroys cognitive performance.”

Grade: A for acute sharpness. Not a lasting rewire of g. Fix this before you buy anything.
“Dual n-back will permanently boost fluid intelligence.”

Grade: D historically loud, now mostly sour. Treat as WM workout, not inoculation.
“This nootropic stack raises intelligence in healthy adults.”

Grade: F unless they name molecule, dose, deficit, and a design that would embarrass them.
“Learning a hard skill (code / language / instrument) makes you smarter.”

Grade: A/B. It thickens knowledge and often competence. Saying it “raises IQ” is optional theater.
“Brain games prevent Alzheimer’s.”

Grade: F as a product claim. Disease prevention is a clinical claim with receipts or silence.
“Processing-speed training helped older adults on trained and some near outcomes.”

Grade: B. Population and DV matter. Not a youth IQ potion.
“Chess makes kids smarter.”

Grade: C. Chess kids are selected and practiced. Far transfer metas are unkind to the slogan.
“Exercise helps cognition.”

Grade: B for many acute/health pathways. Still not “bought 15 IQ points.”
“Adaptive reasoning practice with honest difficulty is useful deliberate practice.”

Grade: B as practice. F if sold as clinically proven g boost. (This is where we live — disclosure: IntelligenceMax is that gym.)
“Iodine deficiency correction can matter a lot where deficiency exists.”

Grade: A for that population. Marketing to already-nourished Instagram is cargo cult.
“Our scoreboard went up, therefore intelligence rose.”

Grade: F. The scoreboard is the thing that learned.

The honest punchline

Want fewer F grades in your life? Separate dials (g vs knowledge vs acute state vs long-horizon health), demand active controls, and treat “raises intelligence” like a claim that owes you a design.

Public map: https://intelligencemax.ai/guide

Transfer / measurement notes: https://intelligencemax.ai/science

CSV / citation pack: https://gist.github.com/connerlambden/f0ba06e1c98379250b1015f3ed14b867

Pocket litmus tests: https://dev.to/connerlambden/five-litmus-tests-for-this-will-raise-your-intelligence-claims-7g

I built the live reasoning gym. Steal the grading scale without linking anything. Accuracy > vibes.

Five litmus tests for “this will raise your intelligence” claims

connerlambden — Tue, 14 Jul 2026 03:24:51 +0000

Five litmus tests for “this will raise your intelligence” claims

A pocket BS detector for brain-training ads, LinkedIn gurus, and your own wishful thinking.

1. Which dial moved?

Intelligence talk smuggles four dials into one word:

Dial	Rough meaning
g / fluid ability	Harder to move; overclaimed constantly
Knowledge & skill	Moves with practice and education
Acute sharpness	Sleep, illness, mood, substances
Long-horizon brain health	Aging, disease risk, lifestyle

If the claim does not say which dial, it is marketing soup.

2. What was the control?

“People got better” is almost worthless. Better than last week of the same game is practice. Better than an active control that also gets attention, novelty, and expectation is interesting. Lumosity-style lawsuits exist because companies sold soup as medicine.

3. Near or far?

Near transfer: you got better at this and close cousins.

Far transfer: the effect jumped to something distant (school grades, matrix reasoning, life outcomes).

Far transfer is scarce. Second-order metas on cognitive training keep finding near yes, far ≈ no once bias is handled. That is not cynicism. It is how human learning usually works.

4. Who was the sample?

A processing-speed protocol that helps older adults does not automatically mint IQ points for a 24-year-old optimization bro. Deficient populations respond differently than well-nourished ones. Age and baseline matter more than branding.

5. Is the score flattering the seller?

If the outcome is “our app score,” the app got better at measuring app use. Prefer outcomes that hurt to fake: standardized batteries against active controls, academic scores, carefully logged real-world performance.

What I built instead of another vanity mini-game

IntelligenceMax is a live reasoning gym: frontier models write fresh distinction-style items at your edge, and scoring is transparent / IRT-style. That is deliberate practice under honest difficulty, not a clinical IQ battery and not a promise that general intelligence permanently rose.

The part that should travel even if you never open the app: an evidence-ranked public map of the claim zoo.

Guide: https://intelligencemax.ai/guide
Science / transfer notes: https://intelligencemax.ai/science
Companion matrix files: https://gist.github.com/connerlambden/f0ba06e1c98379250b1015f3ed14b867

Disclosure: I built it. Skeptical writers are welcome to steal the litmus tests without linking anything. Accuracy > vibes.

One sentence takeaway

Want to get “smarter”? Fix sleep and constraints, learn hard things that matter, practice reasoning where you are wrong, and treat “raises IQ” like a claim that owes you a study design.

I graded my own ML option forecasts. Here's the Brier score.

connerlambden — Mon, 06 Jul 2026 17:47:14 +0000

In May I published a 40-line recipe that logs Helium's prob_itm on listed options and grades them at expiration with the Brier loss:

brier_loss = (prob_itm - realized_itm) ** 2

I also committed publicly to grading two June 2026 AAPL contracts when they expired. June 26 has passed. This is the grade.

The frozen forecasts (2026-05-26 API)

Contract	Helium prob_itm	Market-implied
AAPL $310C 2026-06-26	0.42	~0.50
AAPL $295P 2026-06-26	0.23	~0.24

Resolution

AAPL NASDAQ close on 2026-06-26: $283.78

$310 call → OTM → realized ITM = 0 → Brier = (0.42 − 0)² = 0.1764
$295 put → ITM → realized ITM = 1 → Brier = (0.23 − 1)² = 0.5929

Mean Brier loss: 0.3846 (n=2)

Lower is better. Perfect = 0.

Honest read

Call: Helium's 0.42 was closer to the realized 0 than the market's ~0.50, but any non-zero probability on an OTM finish still costs Brier points.
Put: Probabilities looked aligned pre-expiry, but the put finished ITM after a sharp drawdown. Both market and model underestimated tail risk.
n=2 is transparency, not proof. More expiries on the honesty board.

Reproduce

git clone https://github.com/connerlambden/helium-mcp-cookbook
cd helium-mcp-cookbook
python calibration/grade_june_expiry.py

Frozen inputs: calibration/june_2026_forecasts.json

A 260-line vanilla-JS dashboard for ML stock forecasts (one CORS-open MCP endpoint, zero dependencies)

connerlambden — Wed, 27 May 2026 16:07:32 +0000

I'm a fan of "smallest thing that could possibly work" demos for APIs. If a tool needs Node + Webpack + a build step + 800 KB of node_modules before I can see what it does, I quietly close the tab.

So when I wanted to make a visual surface for Helium MCP's top-10 volatility candidate ticker stream, I went the other way: a single HTML file, one fetch call, no dependencies, no build, ~260 lines of JS. It is live at:

connerlambden.github.io/helium-news-explorer/tickers.html

Here is the architecture and the small handful of choices that made it work.

The endpoint

GET https://heliumtrades.com/mcp_top_strategies/

Returns a JSON object:

{
  "sort": "expected_vol_30d",
  "short_volatility": [ ... 5 tickers ... ],
  "long_volatility":  [ ... 5 tickers ... ]
}

Each ticker entry packs everything I need into one object:

{
  "ticker": "NVDA",
  "name": "NVIDIA Corporation",
  "latest_price": 138.45,
  "price_forecast_days": 37,
  "price_forecast_percent": 8.2,
  "price_forecast_lower_bound_percent": -12.6,
  "price_forecast_upper_bound_percent": 29.8,
  "bullish_case": "<p>Blackwell ramp ahead of plan; ...</p>",
  "bearish_case": "<p>Hyperscaler capex digestion risk; ...</p>",
  "analysis_date": "2026-05-27",
  "page_url": "..."
}

That's huge: the central forecast number AND the bull/bear narrative AND the uncertainty bounds come from the same model, so the chart you draw and the words you display agree on the same view of the world. No reconciliation step. No data joining. Just fetch, then render.

Crucially, Helium's MCP REST endpoints set Access-Control-Allow-Origin: *, so the page can fetch directly from the browser — no proxy, no server, no CORS tax.

The whole render path

<div id="content" class="loading">…</div>

<script>
const ENDPOINT = "https://heliumtrades.com/mcp_top_strategies/";

async function load() {
  const resp = await fetch(ENDPOINT, { cache: "no-store" });
  const data = await resp.json();
  document.getElementById("content").innerHTML = `
    <div class="columns">
      <div class="column short">
        ${data.short_volatility.map(t => cardHTML(t, "short")).join("")}
      </div>
      <div class="column long">
        ${data.long_volatility.map(t => cardHTML(t, "long")).join("")}
      </div>
    </div>`;
}
load();
</script>

Two columns. Five cards each. Template literals as a render engine. That's it. No virtual DOM, no reactivity, no router. The page is static the moment the fetch resolves.

The uncertainty cone in 18 lines of SVG

The interesting visual is the per-card uncertainty cone — a small wedge that gets wider with time, shaded green or red based on the forecast direction, with a line through the center showing the central forecast and a label at the endpoint:

function renderCone(forecastPct, lowerPct, upperPct, days) {
  const W = 260, H = 80, PAD = 6;
  const maxAbs = Math.max(Math.abs(lowerPct), Math.abs(upperPct),
                          Math.abs(forecastPct), 1);
  const yZero = PAD + (H - 2*PAD) / 2;
  const pctToY = p => yZero - (p / maxAbs) * ((H - 2*PAD) / 2);
  const xStart = PAD, xEnd = W - PAD;
  const yUp = pctToY(upperPct);
  const yDn = pctToY(lowerPct);
  const yFc = pctToY(forecastPct);
  const stroke = forecastPct > 0.1 ? "#6bff9c"
               : forecastPct < -0.1 ? "#ff6b8a"
               : "#8a93b8";
  const fill   = stroke.replace(")", ",0.18)").replace("#", "rgba(");
  return `<svg viewBox="0 0 ${W} ${H}" preserveAspectRatio="none">
    <polygon points="${xStart},${yZero} ${xEnd},${yUp} ${xEnd},${yDn}"
             fill="${fill}" stroke="${stroke}"/>
    <line x1="${xStart}" y1="${yZero}" x2="${xEnd}" y2="${yFc}"
          stroke="${stroke}" stroke-width="1.6"/>
    <circle cx="${xEnd}" cy="${yFc}" r="3" fill="${stroke}"/>
  </svg>`;
}

The cone is just a polygon with three points: (start, 0), (end, upper), (end, lower). The forecast line is a single segment from (start, 0) to (end, forecast). The whole shape collapses to a point at the left edge ("today") and fans out on the right ("today + 37 days").

I went back and forth on whether to plot the cone in absolute price terms vs. percent terms. Percent won: it makes a $69 KO card and a $1842 MSTR card visually comparable, since both cones are scaled to their own max-abs bound. You see the shape of uncertainty, not the units.

Why no chart library?

Because for 10 small charts with one polygon and one line each, a chart library is more code than the chart itself.

D3: 270 KB. Sets up d3.scaleLinear(), d3.area(), axes you don't need.
Chart.js: 200 KB. Needs a canvas, animation loop, plugin system.
ECharts: 1 MB+.

Hand-rolled SVG: 18 lines. The browser already has a SVG renderer. The math is one division per coordinate. The styling lives in the same CSS file as the rest of the page. Less is more.

The bull/bear narratives are HTML

Helium returns the cases as <p>...</p> strings. Easiest possible strip:

function stripHTML(s) {
  const tmp = document.createElement("div");
  tmp.innerHTML = s;
  return (tmp.textContent || tmp.innerText || "")
    .replace(/\s+/g, " ").trim();
}

Then truncate to ~280 chars with a word-boundary check so you don't cut mid-word:

function truncate(s, n) {
  if (s.length <= n) return s;
  const cut = s.slice(0, n);
  const lastSp = cut.lastIndexOf(" ");
  return (lastSp > n * 0.6 ? cut.slice(0, lastSp) : cut) + "…";
}

The card links to the full Helium analysis page for the long-form version.

Failure handling

The one real failure mode is a per-IP daily quota on the free tier (Helium returns HTTP 402 with no CORS headers, which the browser surfaces as a generic TypeError: Failed to fetch). I handle it the boring honest way:

try {
  const resp = await fetch(ENDPOINT, { cache: "no-store" });
  if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
  // ... render ...
} catch (e) {
  root.innerHTML = `Could not load forecasts: ${e.message}.
    The Helium REST API enforces a per-IP daily quota for unauthenticated calls.
    Reload tomorrow, or browse the
    <a href="https://github.com/connerlambden/helium-mcp-cookbook">cookbook</a>.`;
}

A casual visitor will not hit this — each page load is one GET, and the free quota is ~50/day.

Companion explorer

The same repo also hosts a News Bias Explorer at the root, built on the same pattern: one fetch to mcp_all_source_biases/, vanilla-JS render of 216 sources × 37 bias dimensions, ranked bars and scatter plots with a live Pearson correlation. Same architecture, different data surface. connerlambden.github.io/helium-news-explorer.

Why this matters for the MCP ecosystem

Most MCP server demos are dense Python notebooks or CLI tools. They demonstrate the protocol but not the data. A casual visitor — a journalist evaluating bias-scoring tools, a retail trader curious about an options model, a researcher looking for a teaching corpus — won't install Python to find out.

A 21 KB HTML file on GitHub Pages, with no signup and no key, is the lowest-friction path from "I just heard about this server" to "oh, here's what it can do."

If you're building an MCP server, consider shipping a small zero-dep web surface next to your CLI examples. The marginal cost is one HTML file. The marginal benefit is every browser becoming a demo client.

DEV Community: connerlambden

How to improve your IQ (without lying to yourself)

Three claims people mix up

A boring adult plan that survives contact with research

Sources I maintain

Lumosity, Elevate, Peak: same aisle, different drills

Three different product jobs

What the evidence usually supports

Why this matters for builders

Quick chooser

What "adaptive" should mean in a reasoning practice app

Adaptive as serving, not as a vibe

What the score is not

Why builders should care about the claim size

Try / read

I graded my own ML option forecasts. Here's the Brier score.

What we froze in May

What the stock actually did

Honest read (short)

Reproduce

Why bother publishing a bad score

An IRT-shaped practice score is not an IQ test

The update rule

Model-assigned is not empirically calibrated

What this number can support

How to improve your IQ without lying to yourself

What IQ is (and is not)

What actually tends to help

Near transfer vs far transfer

A plan that is kinder than chasing points

Disclosure

An IRT-shaped practice score is not an IQ test

The update rule

Model-assigned is not empirically calibrated

What this number can support

What I would test next

App Store update

Open evidence matrix for "get smarter" claims (OSF)

Claim Roulette: 12 “get smarter” ads, graded in 12 seconds each

Claim Roulette: 12 “get smarter” ads, graded in 12 seconds each

The honest punchline

Five litmus tests for “this will raise your intelligence” claims

Five litmus tests for “this will raise your intelligence” claims

1. Which dial moved?

2. What was the control?

3. Near or far?

4. Who was the sample?

5. Is the score flattering the seller?

What I built instead of another vanity mini-game

One sentence takeaway

I graded my own ML option forecasts. Here's the Brier score.

The frozen forecasts (2026-05-26 API)

Resolution

Honest read

Reproduce

Links

A 260-line vanilla-JS dashboard for ML stock forecasts (one CORS-open MCP endpoint, zero dependencies)

The endpoint

The whole render path

The uncertainty cone in 18 lines of SVG

Why no chart library?

The bull/bear narratives are HTML

Failure handling

Companion explorer

Why this matters for the MCP ecosystem

Links