Pulling the board

import pandas as pd
from sitelib.kalshi import KalshiClient

client = KalshiClient()
markets = client.get_markets(series_ticker="KXNCAAF", status="open")

df = pd.DataFrame(
    {
        "team": m["yes_sub_title"],
        "bid": float(m["yes_bid_dollars"]),
        "ask": float(m["yes_ask_dollars"]),
        "last": float(m["last_price_dollars"]),
        "volume": float(m["volume_fp"]),
        "open_interest": float(m["open_interest_fp"]),
    }
    for m in markets
).sort_values("ask", ascending=False).reset_index(drop=True)

print(f"{len(df)} teams still have a contract on the board")

50 teams still have a contract on the board

Each row is a bid and an ask, same as any order book: the ask is what it costs to bet yes on that team right now, the bid is what someone will pay you to bet yes right now. The gap between them is the cost of trading immediately rather than waiting for a better price — call it the market’s estimate, plus a small tax for wanting an answer this second.

The favorites

Code

import matplotlib.pyplot as plt

top = df.head(10).iloc[::-1]

fig, ax = plt.subplots(figsize=(8, 5))
ax.barh(top["team"], top["ask"] * 100, color="#1f4e79")
ax.set_xlabel("Implied win probability (%)")
ax.spines[["top", "right"]].set_visible(False)
plt.show()

Figure 1 is the market’s answer to “who’s going to win,” priced in real dollars rather than a preseason poll. It’ll be a different bar chart by January — that’s the point of pulling it from a live order book instead of writing down an opinion.

Where the probability story breaks down

Two things in this board don’t behave the way “price equals probability” would suggest.

The price floor. Kalshi won’t quote a contract below 1¢. Look at the bottom of the board:

bottom = df.tail(8)[["team", "bid", "ask", "volume"]]
bottom

Every team here is asking 1¢ with a 0¢ bid and little or no volume — not because the market has priced each of them at exactly a 1-in-100 shot, but because a cent is the smallest unit Kalshi trades in and nobody has bothered to trade these at all. A true probability estimate would let a hundred different longshots be a hundred different sizes of unlikely. This board can’t tell you if a team is a 1% shot or a 0.01% shot; both round to the same 1¢ floor.

The book doesn’t sum to 100%. Exactly one of these fifty teams will win, so a coherent set of probabilities should add up to 1.0.

implied_total = df["ask"].sum()
print(f"sum of ask-price implied probabilities: {implied_total:.2f}")

sum of ask-price implied probabilities: 1.43

It doesn’t — it adds up to noticeably more than one. That gap is the same thing as the vig on a sportsbook line: paying the ask on every team simultaneously would cost more than $1 total, guaranteeing a loss no matter who wins. The overround is spread unevenly, too — thin, 1¢-floored longshots contribute more excess probability per team than liquid favorites do, because the floor stops their price from ever reading as low as their real chances.

What I’d check next

Whether the favorites list actually tracks something real — lining this up against a win-total or power-rating source partway through the season, to see whether the market or the model moves first when a team starts losing. And whether the overround shrinks as the season progresses and the field of fifty collapses to a handful of live contenders with real volume behind them.

A post is a directory

Every post lives in its own folder under posts/:

posts/
  2026-08-18-how-this-site-works/
    index.qmd
  2026-08-25-something-else/
    index.qmd
    data.csv

The URL comes from the folder name, so index.qmd is always the file I edit. Data, images and scratch files for a post sit next to it instead of in a shared data/ pile that nobody can untangle six months later. A post is self-contained enough to delete in one move.

The date prefix in the folder name is for my benefit when sorting files; the date the site actually uses is the date: field in the YAML header.

Old posts never re-run

The setting doing the most work on this site is one line in _quarto.yml:

execute:
  freeze: auto

Without it, every rebuild re-executes every post. That means last year’s analysis re-hits an API that may have changed its schema, or needs a credential I’ve since rotated, or quietly produces different numbers because the upstream data was revised — and the published post silently changes underneath a conclusion I wrote about the old numbers.

With freeze: auto, a post executes once. Its outputs get written to _freeze/ and are reused forever after, until I edit that post’s source. Rebuilding the site becomes a pure markdown-to-HTML operation for everything except the post I’m actually working on.

The consequence worth remembering: _freeze/ is committed to git. It is not a cache to gitignore, it is the record of what the code returned on the day it ran.

Code is present but out of the way

Code blocks are collapsed behind a toggle by default, set once in posts/_metadata.yml. The prose reads first; the method is one click away. Here is a real one — a check on whether a coin-flip streak of 7 is actually unusual over a season’s worth of flips, which is the kind of “that seems surprising” claim that is usually just sample size.

import numpy as np

rng = np.random.default_rng(seed=42)

def longest_streak(flips):
    best = current = 1
    for i in range(1, len(flips)):
        current = current + 1 if flips[i] == flips[i - 1] else 1
        best = max(best, current)
    return best

trials = 10_000
n_flips = 162
streaks = np.array([
    longest_streak(rng.integers(0, 2, size=n_flips))
    for _ in range(trials)
])

print(f"median longest streak: {np.median(streaks):.0f}")
print(f"share of seasons with a streak of 7 or more: {(streaks >= 7).mean():.1%}")

median longest streak: 7
share of seasons with a streak of 7 or more: 73.4%

A run of seven is the typical outcome, not the surprising one. That is the whole genre of post I want to write here.

Code

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 4.5))
values, counts = np.unique(streaks, return_counts=True)
ax.bar(values, counts / trials, color="#1f4e79", width=0.7)
ax.axvline(7, color="#c0392b", linestyle="--", linewidth=1.5)
ax.text(7.15, ax.get_ylim()[1] * 0.9, "a streak of 7", color="#c0392b", fontsize=10)
ax.set_xlabel("Longest streak in a season")
ax.set_ylabel("Share of simulated seasons")
ax.spines[["top", "right"]].set_visible(False)
plt.show()

Referring to it as Figure 1 gives a numbered cross-reference that works in every output format, which matters for the next section.

Interactive where it helps

Plotly figures work on the web version of a post:

import plotly.express as px

fig = px.bar(
    x=values,
    y=counts / trials,
    labels={"x": "Longest streak in a season", "y": "Share of seasons"},
    template="plotly_white",
)
fig.update_traces(marker_color="#1f4e79")
fig.update_layout(height=400, margin=dict(l=40, r=20, t=20, b=40))
fig

The tradeoff: an interactive figure cannot render into a PDF or a PowerPoint slide — it is JavaScript, and there is nothing for a static page to show. So any post I also want as a document uses matplotlib. The next post is about exactly that.

Publishing

quarto preview while writing, then commit and push. A GitHub Actions workflow renders the site and deploys it. Because _freeze/ is in the repo, that build does not need my API keys or my local data — it only executes posts whose source actually changed.

That is the entire loop: make a folder, write, push.

Rule 1: Headings are slide boundaries

In the article formats a ## heading starts a section. In reveal.js and PowerPoint the same heading starts a slide, and its content has to fit on one.

That is a real writing constraint, not a formatting detail. It means a few tight paragraphs and one figure per heading. The upside is that prose written this way is better prose — if a section does not fit on a slide, it was probably doing two things at once.

Rule 2: Static figures only

An interactive Plotly chart is JavaScript. There is no sensible way to put it on a PDF page or a PowerPoint slide, so a multi-format document uses matplotlib.

Code

import numpy as np
import matplotlib.pyplot as plt

years = np.arange(0, 31)
fig, ax = plt.subplots(figsize=(8, 4.2))

for rate, color in [(0.04, "#95a5a6"), (0.07, "#1f4e79"), (0.10, "#c0392b")]:
    ax.plot(years, 10_000 * (1 + rate) ** years,
            color=color, linewidth=2, label=f"{rate:.0%} annual return")

ax.set_xlabel("Years")
ax.set_ylabel("Value of $10,000")
ax.yaxis.set_major_formatter(lambda x, _: f"${x/1000:,.0f}k")
ax.legend(frameon=False, loc="upper left")
ax.spines[["top", "right"]].set_visible(False)
plt.show()

Three percentage points of annual return is a factor of two and a half over thirty years, which is Figure 1’s entire point.

Rule 3: Content that only belongs in one place gets fenced

Some material is web-only — a long appendix, a data dictionary, an interactive widget. Some is slide-only, like a punchline with no supporting text. Quarto’s conditional divs handle both.

This paragraph appears only in the HTML version. It is the natural home for the caveats and the methodology notes that would ruin a slide.

The mechanism is ::: {.content-visible when-format="html"}. There is also content-hidden, and when-format accepts pdf, revealjs and pptx.

What the formats cost

Each extra format is a line of YAML and a slower render. The honest accounting:

I default to HTML only, and add formats to a specific post when there is an actual reason. format-links in the HTML sidebar generates the download links automatically, so readers get them for free whenever a post declares extra formats.

The takeaway

Write the analysis once, in the format that keeps the code next to the claim. Decide later who needs it as a document.