The job that eats our weeks

If you build behavioral risk models, you know the drill. The signal lives in history tables — millions of payment events, monthly card balances, bureau records — and the only way to feed that to a scorecard or GBM is to collapse it into aggregates: mean days past due in the last 6 months, max utilization ever, count of late payments in 12.

The pain is combinatorial. Every variable × every window (3/6/12/24 months) × every statistic (mean, max, count, trend) × every condition you can dream up. Thousands of candidates. Weeks of analyst time. And when you ship, a quiet doubt remains: what did we not think of?

So I ran an experiment around a simple inversion: what if the model does the searching, and the analyst only does the reading?

The idea: the network is the search engine, not the product

The plan had three stages, each with a hard, falsifiable criterion:

1. Train a sequential neural network on near-raw history — no hand-crafted aggregates anywhere in its inputs — and require it to beat a meaningful bar: validation AUC > 0.78. The data: a private competition dataset modeled on the well-known Home Credit Kaggle data — an application table plus six history tables; 246K applications, 8.1% bad (default) rate, 13.6M payment events plus card, point-of-sale and credit bureau tables. (The raw data can’t be redistributed, but the public Kaggle Home Credit dataset has the same shape if you want to reproduce the method.)

2. Interrogate the frozen model with explainability tooling and write down, in plain language, what it learned.

3. Rebuild the findings as ordinary tabular features, hand them to a plain LightGBM, and measure how much of the network’s edge they keep — on a holdout set touched exactly once.

The crucial design decision: the neural network was never the deliverable. The deliverable was the feature list. The deployable model at the end is a boring, governance-friendly GBM over named columns — the network exists only to search a hypothesis space no analyst can cover by hand.

One constraint made the whole thing meaningful: the network’s inputs were raw event streams (due date, paid date, amounts, statuses…), with only “unit fixes” added — paid minus due = delay, paid over due = ratio. No windows, no decays, no counts-over-time. If we had fed it engineered aggregates, interrogating it would just have echoed our own assumptions back at us.

What actually happened (including the failures)

A disclosure that matters for everything that follows: I directed an AI coding agent (Claude Code) through the entire build — it wrote the pipeline, ran the experiments, and drafted the analyses; my own keyboard time across the two days went into design decisions at the start, a long stream of “explain this to me” challenges in the middle, and reading findings and approving feature names at the end. The honest log matters more than the highlight reel:

The first model failed the gate. It stalled at 0.767 validation AUC — barely above the applications-only baseline of 0.763 (validation). Before burning more GPU time, I had a set of independent AI reviewer agents audit the data pipeline, each instructed to try to refute the others’ bug reports so only solid findings survived. Three silent scaling bugs were confirmed. The worst: a clipping step had collapsed every applicant’s age to the same constant. Age — one of the strongest variables in retail credit — had been deleted from the model, and nothing crashed; the model trained merrily at a plausible-looking AUC. If you take one engineering lesson from this post: scaling bugs don’t announce themselves. Audit the transformed arrays — nunique(), clip-saturation — not just the raw data.

Then the neural fusion head hit a ceiling. With the bugs fixed and standard tricks applied (an auxiliary head forcing the behavioral embedding to be predictive on its own; randomly hiding the application features during training so the model can’t lean on them), the network’s own head still topped out around 0.769 (validation). Neural nets are simply mediocre at flat tabular data, where GBMs shine. The fix was architectural honesty: keep the network as the sequence reader, freeze its 128-number behavioral embedding, and let a LightGBM do the fusion — raw application columns and embedding columns side by side. That, plus a small ensemble of encoder variants, passed the gate at 0.7816 (validation).

The interrogation: making the black box talk

This is the part I’d never done before, and it’s where the experiment earns its keep. Three tools plus one final probe, deliberately different in mechanism, all run on the frozen model:

1. Attribution (Integrated Gradients) decomposes the behavioral score into per-event, per-channel contributions — a points table for a model that has no points table. It told us where the model looks: payment amounts and delays dominate, concentrated in the most recent ~10–15 installments; the monthly view is read as a current portfolio snapshot (the top channel was scheduled future installments — forward commitment burden, not delinquency); bureau signal concentrates in how recently accounts were opened. Best of all, plotting attribution against time produced a forgetting curve per data source — payments decay fast, applications and bureau records slowly. The model had learned different memory lengths for different data, something a uniform “last 12 months” window would have flattened.

2. Counterfactual perturbation is stress-testing aimed at the model: edit real histories surgically, re-score, measure. Injecting a fresh 3-payment late streak: +14.8 percentage points of predicted default probability in the top-risk decile. The same streak placed 18 months back: +0.9. That ratio is a feature specification — recency-discounted delinquency with a half-life around five to six payments, which became a literal column (Σ late × 0.89^k, k = payments back from today). Deleting the older half of someone’s history — mostly clean events — raised their risk: tenure itself is protective. And the null results mattered just as much: chronic mild underpayment, days-past-due (DPD) on monthly statements, utilization trend — all moved the model barely at all. Each null is strong evidence (not proof — the network can miss things too) that a feature family isn’t worth building for this portfolio, with a measured justification attached.

3. Embedding analysis treats the model’s internal customer summary (the encoders’ 128-number embeddings, concatenated) as a map of “behavior space”. Clustering it produced six archetypes whose real default rates ran 2.4% to 25.3% — and here’s the insight I keep retelling: median DPD was ~zero in every archetype. 92% of eventual defaulters had no statement delinquency at all in the prior year. The 10× risk separation came from soft gradients — how early people pay (10 days early vs 5), how deep their history runs, their refusal history. The model invented a segmentation no DPD-based rule could see.

The embedding gave us one final probe, the strangest of the lot: take the model’s main internal risk axis (the combination of embedding numbers that best tracks its score) and regress it on ~23 statistics we could name. They explained 39% of its variance (linear R²). The other 61% was the model knowing something we had no words for — so we pulled the customers at the extremes of that unexplained direction and read their raw files like underwriters. Two patterns emerged that none of our standard vocabulary captured: same-day bursts of refused applications (8–14 refusals, specific rejection codes) and heavy external debt sitting on a thin internal file. Both became features. Both are the kind of thing you find in year three of working a portfolio, not week one.

The verdict

Each finding became one or more named features — 52 in total, every one with a provenance note linking it to the finding that motivated it, implemented in plain pandas with no neural network anywhere at inference. Then the only test that matters, on the untouched holdout (holdout numbers run a little below the validation figures quoted above — expected, and exactly why the holdout exists):

Gap closure: 102% on the point estimates — read that as a statistical tie: the 0.0006 AUC by which the features “beat” the network is well within noise on a single holdout, and I make nothing of it. The claim that matters is that the interpretable features kept essentially everything the network found (a second check agrees: the features-alone model matches the network’s behavior-only score head almost exactly). And no, that doesn’t make the network redundant: it found the features. Without it, the same list would have required exactly the manual search this experiment set out to replace.

Why I think this changes the feature-development workflow

Time. Two calendar days end-to-end, and most of that was compute, not human attention. The human’s job is compressed into: design decisions at the start, reading findings in the middle, naming features at the end.

Features arrive with evidence, not hunches. Every feature came with a measured functional form (the decay constant was fitted by the model and read off a dose-response curve, not guessed), a confirmed direction (useful for monotonicity constraints and model documentation), and — the underrated half — licensed omissions: measured evidence that the network, which saw everything, found no use for certain feature families, so nobody burns a sprint building them “just in case”.

Insights are a first-class output, not a by-product. The defaulters-look-clean finding, the archetype segmentation, the credit-appetite signal in bureau account openings — those are portfolio knowledge with uses far beyond one model: strategy, monitoring, collections prioritization. Manual feature engineering produces features; this produces features and an explanation of the portfolio.

The deployable artifact stays boring. Nothing about production changes: a GBM, named columns, documented provenance. For anyone working under model governance, that’s the difference between “interesting research” and “something I can actually ship”.

What this is not

Honesty section. The method is not human-free: someone chooses the raw representation, reads the extreme cases, and names the features — that’s the point, not a flaw (translation into human language requires a human). The perturbation effects are within-model sensitivities, not causal claims about customers. The probe is linear, so “61% unexplained” is an upper bound on mystery — some of it is interactions of known quantities. This is one dataset, one domain; the playbook needs adapting for very rare outcomes, drifting populations (use out-of-time holdouts!), or domains where the risk signal is what stopped happening. And it needs label volume — supervised embeddings want thousands of positives.

Also: I ran the interrogation as a single pass because that was the experiment’s design. In practice you’d loop — generate features, measure the remaining gap to the network, re-interrogate targeted at the cases where the features and the network disagree most, and repeat until converged. The disagreement cases are exactly where the unextracted signal hides.

Try it

The code and analysis are public: the full pipeline, the interrogation scripts, the findings documents with per-feature provenance, a tutorial written for risk professionals with no neural-network background, and a generalized, self-contained playbook for applying the method to other domains (churn, fraud, claims). The raw dataset itself can’t be redistributed — but the public Kaggle Home Credit data has the same shape if you want to run the method end to end:

https://github.com/kychanbp/auto-feature-gen-with-nn-interogation

My takeaway after two days: feature engineering didn’t disappear. It moved up a level — from writing thousands of candidate aggregates to reading what a model that saw everything chose to care about. I suspect that inversion is where the interesting work is moving.

Exchange rates and interest rates shape our everyday lives. The exchange rate affects our purchasing power; the interest rate affects borrowing costs and asset prices. If you earn Singapore dollars, a trip to Japan looks attractive. If you buy a house in Singapore, you’ll notice the mortgage rate moves in line with rates in the United States. Yet most of us don’t know the mechanism underneath — how these variables move and interact.

The Impossible Trilemma

The impossible trilemma states that a country can have only two of three things: control of its interest rate, control of its exchange rate, and free movement of capital.

When capital flows freely, the no-arbitrage relationship between interest rates and the exchange rate is:

where S is the spot rate (domestic currency per unit of foreign), F the forward rate, i_d the domestic interest rate, and i_f the foreign rate.

The formula says: holding one unit of domestic currency (which grows to 1+i_d​) must equal converting it to foreign currency at the spot (1/S), earning the foreign rate (1+i_f), and converting it back through a forward contract (F).

The equation is just a constraint — it doesn't say which variable drives the others. That's a choice. A country pins one lever, and the formula then determines the rest.

Take Singapore. The MAS uses the exchange rate, not the interest rate, as its main policy tool — managing the Singapore dollar against a trade-weighted basket (the S$NEER) within a band, usually on a gently appreciating path. When the market expects the Singapore dollar to strengthen, the formula does the rest: F < S , so F/S<1, which pushes SGD interest rates below foreign rates. The MAS never sets the domestic rate directly — it falls out of the currency policy.

But here’s the crucial limit: this formula pins down the forward rate, not the future spot rate. The forward is locked in by covered arbitrage; where the spot actually goes depends on expectations, risk premia, capital flows, and policy credibility.

Japan makes the point. Its interest rate is far below the United States’. The formula puts the yen at a forward premium — so you might expect it to strengthen. In reality, the yen depreciates.

Covered and Uncovered Interest Parity

The formula above is covered interest parity — “covered” because you hedge the currency risk with a forward. It’s a no-arbitrage benchmark, and in deep, liquid markets it holds very closely. (It can drift only when funding stress or balance-sheet constraints open a “cross-currency basis,” as they have at times since 2008.) But notice what it does and doesn’t say: it pins the forward price to the interest-rate gap. It says nothing about where the spot rate will actually go.

That second question belongs to uncovered interest parity — the unhedged version. In theory, a low-yielding currency should appreciate just enough to offset its lower interest rate. In practice this often fails, because investors demand risk premia, chase carry, or react to safe-haven and policy shifts.

Japan is the clearest case. Its low rate puts the yen at a forward premium, but in the spot market traders borrow cheap yen to buy higher-yielding foreign assets, creating selling pressure that pushes the yen down. Switzerland shows the other side: despite equally low rates, the franc tends to appreciate, because it enjoys safe-haven demand.

Notice the pattern: the same low interest rate sends the yen down and the franc up. The interest rate alone never tells you which way a currency moves — what matters is which lever the country chose to control, and what it leaves to the market.

Around the World

China has restricted the free flow of capital, which lets it steer both the interest rate and the exchange rate more independently — because the arbitrage channel that would otherwise link them is constrained. The link isn’t fully severed (trade flows, approved investment channels, and the offshore CNH market still matter), but it’s loose enough that domestic rates and the yuan can diverge from what open-market arbitrage would dictate.

Taiwan faces recurring appreciation pressure from its strong external position and capital inflows. To lean against excessive TWD appreciation and protect export competitiveness, its central bank buys foreign currency and accumulates reserves (now over US$600 billion), while using monetary and prudential tools to manage domestic liquidity.

Brazil, as of 2026, shows the opposite of Japan. With a high policy rate, the real’s forwards imply depreciation under interest parity — yet the spot real has appreciated, because high carry, improved sentiment, and capital inflows more than offset the forward-implied decline.

Closing

Three levers — interest rate, exchange rate, free capital — and you can pin only two. The third is whatever the market makes of it. So the next time your Singapore mortgage tracks the Fed, or your yen holiday gets cheaper, you’re watching the same equation at work — quietly linking interest rates, exchange rates, and the flow of capital across the world.

To understand it, we can simplify as many components as possible. First, let’s restrict connections to local neighbors only — for example, the Mesh Neural Net. Second, let’s make everything discrete instead of continuous. The simplest discrete analog is a rule array — a cellular-automaton-like grid in which each cell independently picks which rule to apply from a small fixed panel (see Appendix for an introduction to cellular automata). The value of a cell is discrete: either 1 or 0. The value of the cell depends on the left, center, and right cells preceding it by a rule set. Analogously, each cell in the grid is a neuron in NN. The row in the grid is the layers. The computation graph is constructed as a mesh network that depends on local neighbors. Random mutation is analogous to a training/optimization procedure, but unlike gradient descent, it does not use gradients. It is closer to stochastic hill climbing or evolutionary search. The value of the cell is similar to activation, the value the neuron produces after the forward pass computation.

Implementation

First, we defined the grid size to be where is the number of time steps and is the width of the grid.

Second, we define a function to generate the rule set, converting decimal to binary (see Appendix for details).

def rule_to_lut(n):
    """Convert rule number to a lookup table."""
    return [ (n // 2**i) % 2 for i in range(8) ]

We will mainly use rule 4 and rule 146. The lookup tables are:

Third, we construct a rule array that indicates whether to apply rule 4 or rule 146 to each cell, and initialize it to zeros.

rule_array = [[0] * W for _ in range(T)]

Fourth, we define a function to evolve the row one by one in the grid, starting with the initial configuration [0000...010...0000]. Then, we loop through the cell from top to bottom and left to right, and apply the corresponding rule set (Rule 4 or Rule 146) based on the value in the rule array (0 or 1).

def evolve(rule_array, initial_row):
    T = len(rule_array)
    W = len(initial_row)
    pat = [list(initial_row)]  # start with the initial row
    for t in range(T):  # loop through time steps
        new_row = []
        for w in range(W):  # loop through cell width
            left = pat[t][w-1] if w-1 >= 0 else pat[t][W-1]  # if hitting left wall, treat as the rightmost cell
            center = pat[t][w]
            right = pat[t][w+1] if w+1 < W else pat[t][0]  # if hitting right wall, treat as the leftmost cell
            idx = left * 4 + center * 2 + right  # convert binary to decimal index

            if rule_array[t][w] == 0:
                new_row.extend([rule_4_lut[idx]])  # apply rule 4
            else:
                new_row.extend([rule_146_lut[idx]])  # apply rule 146
        pat.append(new_row)

    return pat

Fifth, we have to define our loss function. Our goal is to have a Cellular Automata that stops at a certain lifetime, say 30. The definition of lifetime is the index of the last nonzero row. The loss is just the absolute difference between our target and our lifetime.

def lifetime(pat):
    """Calculate the lifetime of the pattern."""

    for t in range(len(pat) - 1, -1, -1):  # start from the last time step; -1 means go backwards; -1 means stop at the first time step
        if any(pat[t]):
            return t
    return 0

def loss(rule_array, target):
    pat = evolve(rule_array, initial_row)
    return abs(lifetime(pat) - target)

Finally, we have to write our training loop that mutates the rule array, similar to how we find the weights in the NN. We start by initializing the rule_array randomly, then flip the bit in the array if the loss is less than or equal to the current loss. The reason to use <= instead of < is that by including the run with the same loss, we avoid getting stuck in the same mutation (weights).

def train(target, max_steps=10000):

    random_rule_array = [[random.choice([0, 1]) for _ in range(W)] for _ in range(T)]  # Initialize a random rule array
    current_loss = loss(random_rule_array, target)
    loss_history = [current_loss]

    for step in range(max_steps):
        # Randomly flip a bit in the rule array
        t = random.randint(0, T-1)
        w = random.randint(0, W-1)
        random_rule_array[t][w] = 1 - random_rule_array[t][w]  # 1-0 = 1 and 1-1 = 0, so this effectively flips the bit

        new_loss = loss(random_rule_array, target)

        if new_loss == 0:
            current_loss = new_loss
            loss_history.append(current_loss)
            break
        elif new_loss <= current_loss:
            current_loss = new_loss
            loss_history.append(current_loss)
        else:  # Revert the change if it doesn't improve the loss
            random_rule_array[t][w] = 1 - random_rule_array[t][w]
            loss_history.append(current_loss)

    return random_rule_array, loss_history

Results and Implications

We can observe that the simplified NN construction did “learn.” However, the solutions seem to have no pattern. Somehow, some rules did minimize the loss function. In fact, the simplest solution is to apply only one rule-146 in row 30.

The main messages from the book by Stephen are:

• Many trained systems do not work by discovering clean, human-readable mechanisms. Training is an adaptive process that searches an enormous computational space and retains any behavior that happens to align with the constraints.

• ML works because of computational irreducibility (the concept introduced by Stephen Wolfram in A New Kind of Science). You cannot shortcut their behavior with a closed-form theory. ML exploits this by exploring the vast, irreducible computational space, which almost always finds one whose dynamics satisfy the need.

• There is a trade-off between explainability (for example, a closed-form solution) and performance, because if we require explainability, we restrict the search in computational irreducible space.

Appendix: Cellular Automata

A one-dimensional Cellular Automata (CA) of two states starts with an array of ones and zeros. The next generation (the next row) is generated by a set of rules that take two adjacent cells and itself as inputs, and output the next cell.

Since there are combinations of inputs, the rule set can be expressed in 8 digits. For example, binary 00011110 = decimal 30; this is called Rule 30 (see Appendix: Base Conversion for more information). Therefore, there are, in total, possible rule sets.

For example, the following is the space-time pattern^[2] of Rule 30:

Appendix: Base Conversion

In Python, the conversion can be achieved in one line by answering whether is in the sum. is in the sum, while is not, as we saw above. It is easier to see in base-10 first. To answer whether is in the sum of () — in other words, what is the tens digit of — we can first chop off the last digit (mathematically, ^[4]) and look at the rightmost digit of what’s left (mathematically, ^[5]). Applying the same logic to base-2 of number , it becomes .

Appendix: Code

Polish by Claude:

"""
Wolfram §5 replication — train a rule array to a target lifetime.

Replicates the lifetime-training experiment from Stephen Wolfram,
*What's Really Going On in Machine Learning? Some Minimal Models* (2025),
Section 5 ("Machine Learning in Discrete Rule Arrays").

Each cell of a T x W rule array selects between two elementary cellular
automata (rule 4, decay; rule 146, chaotic) to apply at that (time, space)
position. From a single black cell in row 0, the pattern evolves forward T
steps. Training searches for a rule array whose pattern survives EXACTLY
`target` steps, using single-point mutation hill-climbing with the rule
"accept iff new loss <= old loss". The equality is what lets the search
drift across plateaus until it stumbles into a downhill move.

Phenomena reproduced:
  1. Random mutation actually trains.
  2. Trained rule arrays look like noise (no obvious mechanism).
  3. Different runs find different solutions.
  4. Plateau-and-breakthrough learning curves.
  5. Engineered solutions exist but training does not discover them.

Outputs (under --out-dir, default = script directory):
  - learning_curves.png        loss vs. mutation step, all runs overlaid
  - trained_runs.png           trained rule arrays + spacetime patterns
  - trained_spacetime.gif      animated row-by-row evolution

Usage:
    python wolfram_lifetime.py
    python wolfram_lifetime.py --t 30 --w 30 --target 15 --max-steps 10000
    python wolfram_lifetime.py --no-gif
"""

from __future__ import annotations

import argparse
import random
from pathlib import Path

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation, PillowWriter


# -----------------------------------------------------------------------------
# Elementary cellular automata
# -----------------------------------------------------------------------------

def rule_to_lut(n: int) -> list[int]:
    """8-entry lookup table for an elementary (k=2, r=1) CA.
    Indexed by (left << 2) | (center << 1) | right."""
    return [(n >> i) & 1 for i in range(8)]


RULE_4_LUT = rule_to_lut(4)      # class 2 -- decay
RULE_146_LUT = rule_to_lut(146)  # class 3 -- chaotic


def evolve(rule_array: list[list[int]], initial_row: list[int]) -> list[list[int]]:
    """Run the 1D CA forward, selecting rule 4 or rule 146 per cell.

    `rule_array[t][w]` selects which rule applies at time t, column w
    (0 -> rule 4, 1 -> rule 146). Width is cyclic.

    Returns the spacetime pattern: a (T+1) x W list of lists.
    """
    T = len(rule_array)
    W = len(initial_row)
    pat = [list(initial_row)]
    for t in range(T):
        prev = pat[t]
        new_row = [0] * W
        for w in range(W):
            # cyclic neighborhood: modulo handles both walls
            idx = (prev[(w - 1) % W] << 2) | (prev[w] << 1) | prev[(w + 1) % W]
            lut = RULE_4_LUT if rule_array[t][w] == 0 else RULE_146_LUT
            new_row[w] = lut[idx]
        pat.append(new_row)
    return pat


def lifetime(pat: list[list[int]]) -> int:
    """Largest row index containing any black cell. 0 if dead from the start."""
    for t in range(len(pat) - 1, -1, -1):
        if any(pat[t]):
            return t
    return 0


# -----------------------------------------------------------------------------
# Training: single-point mutation hill climbing
# -----------------------------------------------------------------------------

def loss(rule_array: list[list[int]], initial_row: list[int], target: int) -> int:
    return abs(lifetime(evolve(rule_array, initial_row)) - target)


def train(
    target: int,
    T: int,
    W: int,
    initial_row: list[int],
    max_steps: int = 20_000,
    seed: int | None = None,
) -> tuple[list[list[int]], list[int]]:
    """Hill-climb a rule array to lifetime = target.

    Starts from a random binary rule array of shape (T, W). Each iteration
    flips one random cell; the flip is kept iff `new_loss <= cur_loss` (the
    `<=` is what lets the search cross plateaus). Early-stops on loss == 0.

    Returns (trained_rule_array, loss_history). The history has one entry
    per iteration, so its length equals the number of mutations attempted
    (+ 1 for the initial state).
    """
    rng = random.Random(seed)
    arr = [[rng.randint(0, 1) for _ in range(W)] for _ in range(T)]
    cur_loss = loss(arr, initial_row, target)
    history = [cur_loss]

    for _ in range(max_steps):
        i, j = rng.randrange(T), rng.randrange(W)
        arr[i][j] = 1 - arr[i][j]  # flip
        new_loss = loss(arr, initial_row, target)
        if new_loss <= cur_loss:
            cur_loss = new_loss
        else:
            arr[i][j] = 1 - arr[i][j]  # revert
        history.append(cur_loss)
        if cur_loss == 0:
            break

    return arr, history


# -----------------------------------------------------------------------------
# Visualization
# -----------------------------------------------------------------------------

def plot_learning_curves(runs, target: int, out_path: Path) -> None:
    """Loss vs. mutation step for all runs, overlaid."""
    fig, ax = plt.subplots(figsize=(8, 4))
    for k, (_, hist) in enumerate(runs):
        ax.plot(hist, lw=0.9, alpha=0.85, label=f"run {k+1} ({len(hist)-1} steps)")
    ax.set_xlabel("mutation step")
    ax.set_ylabel(f"loss = |lifetime - {target}|")
    ax.set_title(f"Learning curves - {len(runs)} independent runs, target={target}")
    ax.legend(fontsize=8)
    ax.grid(alpha=0.3)
    fig.tight_layout()
    fig.savefig(out_path, dpi=150, bbox_inches="tight")
    plt.close(fig)


def plot_trained_runs(runs, initial_row, target: int, out_path: Path) -> None:
    """Trained rule arrays (top) and their spacetime patterns (bottom)."""
    n = len(runs)
    fig, axes = plt.subplots(2, n, figsize=(3 * n, 7.2), constrained_layout=True)
    if n == 1:
        axes = axes.reshape(2, 1)

    for k, (arr, hist) in enumerate(runs):
        axes[0, k].imshow(arr, cmap="binary", aspect="equal",
                          interpolation="nearest", vmin=0, vmax=1)
        axes[0, k].set_title(f"run {k+1}: rule array\n({len(hist)-1} mutations)",
                             fontsize=10)
        axes[0, k].set_xticks([]); axes[0, k].set_yticks([])
        if k == 0:
            axes[0, k].set_ylabel("LEARNED\nrule array\n(black=146, white=4)",
                                  fontsize=9)

        pat = evolve(arr, initial_row)
        axes[1, k].imshow(pat, cmap="binary", aspect="equal",
                          interpolation="nearest", vmin=0, vmax=1)
        axes[1, k].axhline(target + 0.5, color="red", lw=1.0, ls="--",
                           alpha=0.8, label=f"target row {target}")
        axes[1, k].set_title(f"spacetime (lifetime {lifetime(pat)})", fontsize=10)
        axes[1, k].set_xticks([]); axes[1, k].set_yticks([])
        if k == 0:
            axes[1, k].set_ylabel("RESULTING\nspacetime\n(time flows down)",
                                  fontsize=9)
            axes[1, k].legend(loc="lower right", fontsize=7)

    fig.suptitle(
        f"Wolfram §5 replication - {n} independent training runs, target lifetime = {target}\n"
        "Each run learns a different rule array; spacetimes are unrelated but all die at the target row.",
        fontsize=11,
    )
    fig.savefig(out_path, dpi=150, bbox_inches="tight")
    plt.close(fig)


def animate_trained_runs(
    runs, initial_row, target: int, out_path: Path, fps: int = 5
) -> None:
    """Animated gif: rule array (top) and spacetime (bottom) reveal in lockstep,
    one row per frame. Rule-array row t produces spacetime row t+1.
    """
    n = len(runs)
    arrs = [np.array(arr) for arr, _ in runs]
    pats = [np.array(evolve(arr, initial_row)) for arr, _ in runs]
    lifetimes = [lifetime(p.tolist()) for p in pats]
    mutations = [len(h) - 1 for _, h in runs]
    n_frames = pats[0].shape[0]  # T + 1

    fig, axes = plt.subplots(2, n, figsize=(3 * n, 6.6))
    if n == 1:
        axes = axes.reshape(2, 1)
    fig.subplots_adjust(top=0.86, bottom=0.04, left=0.06, right=0.98,
                        hspace=0.25, wspace=0.10)

    def render(t):
        for k in range(n):
            ax_top = axes[0, k]
            ax_top.clear()
            ax_top.set_xticks([]); ax_top.set_yticks([])
            ax_top.set_title(
                f"run {k+1}: rule array\n({mutations[k]} mutations)", fontsize=10
            )
            display_arr = np.zeros_like(arrs[k])
            if t > 0:
                display_arr[:t] = arrs[k][:t]
            ax_top.imshow(display_arr, cmap="binary", aspect="equal",
                          interpolation="nearest", vmin=0, vmax=1)
            if k == 0:
                ax_top.set_ylabel("LEARNED\nrule array\n(black=146, white=4)",
                                  fontsize=9)

            ax_bot = axes[1, k]
            ax_bot.clear()
            ax_bot.set_xticks([]); ax_bot.set_yticks([])
            ax_bot.set_title(f"spacetime (lifetime {lifetimes[k]})", fontsize=10)
            display_pat = np.zeros_like(pats[k])
            display_pat[: t + 1] = pats[k][: t + 1]
            ax_bot.imshow(display_pat, cmap="binary", aspect="equal",
                          interpolation="nearest", vmin=0, vmax=1)
            ax_bot.axhline(target + 0.5, color="red", lw=1.0, ls="--",
                           alpha=0.8, label=f"target row {target}")
            if k == 0:
                ax_bot.set_ylabel("RESULTING\nspacetime\n(time flows down)",
                                  fontsize=9)
                ax_bot.legend(loc="lower right", fontsize=7)

        fig.suptitle(
            f"Wolfram §5 replication - {n} independent training runs, "
            f"target lifetime = {target}  -  step {t}/{n_frames - 1}\n"
            "Each run learns a different rule array; spacetimes are unrelated "
            "but all die at the target row.",
            fontsize=11,
            y=0.985,
        )

    anim = FuncAnimation(fig, render, frames=n_frames, interval=1000 // fps)
    anim.save(out_path, writer=PillowWriter(fps=fps))
    plt.close(fig)


# -----------------------------------------------------------------------------
# Main
# -----------------------------------------------------------------------------

def main() -> None:
    ap = argparse.ArgumentParser(
        description="Train a rule array to a target lifetime (Wolfram §5)."
    )
    ap.add_argument("--t", type=int, default=60, help="time steps (rule-array rows)")
    ap.add_argument("--w", type=int, default=60, help="width (rule-array cols)")
    ap.add_argument("--target", type=int, default=30, help="target lifetime")
    ap.add_argument("--max-steps", type=int, default=20_000,
                    help="max mutations per run")
    ap.add_argument("--n-runs", type=int, default=4,
                    help="number of independent training runs")
    ap.add_argument("--seed", type=int, default=7,
                    help="base seed (per-run seeds are derived)")
    ap.add_argument("--out-dir", type=Path,
                    default=Path(__file__).resolve().parent,
                    help="where to save figures")
    ap.add_argument("--no-gif", action="store_true",
                    help="skip the animated gif (faster)")
    args = ap.parse_args()

    if not 0 <= args.target <= args.t:
        raise SystemExit(f"target must be in [0, {args.t}]; got {args.target}")

    initial_row = [0] * args.w
    initial_row[args.w // 2] = 1

    rng = random.Random(args.seed)
    seeds = [rng.randrange(10**9) for _ in range(args.n_runs)]

    print(f"Training {args.n_runs} runs at T={args.t}, W={args.w}, target={args.target}...")
    runs = []
    for k, s in enumerate(seeds):
        arr, hist = train(
            args.target, args.t, args.w, initial_row,
            max_steps=args.max_steps, seed=s,
        )
        lt = lifetime(evolve(arr, initial_row))
        print(f"  run {k+1} seed={s}: final loss={hist[-1]}, "
              f"lifetime={lt}, mutations={len(hist) - 1}")
        runs.append((arr, hist))

    args.out_dir.mkdir(parents=True, exist_ok=True)
    plot_learning_curves(runs, args.target, args.out_dir / "learning_curves.png")
    plot_trained_runs(runs, initial_row, args.target,
                      args.out_dir / "trained_runs.png")
    print(f"Saved learning_curves.png and trained_runs.png to {args.out_dir}")

    if not args.no_gif:
        animate_trained_runs(runs, initial_row, args.target,
                             args.out_dir / "trained_spacetime.gif")
        print(f"Saved trained_spacetime.gif to {args.out_dir}")


if __name__ == "__main__":
    main()

Footnotes

[1] If readers are not familiar with NN, here is a great introduction: 3Blue1Brown — But what is a neural network?.

[2] The column is space, and the row is time.

[3] In the case of a list in Python, we usually write from left to right.

[4] Integer division.

[5] Modulo.

Imagine two friends, Ahmad and Bao. Both decide to buy a private apartment in Singapore. Same building, same size. Ahmad buys in 1996 Q3. Bao buys in 2004 Q1. They both hold for five years.

Ahmad’s apartment, by 2001, is worth about 30% less than what he paid. He still has his mortgage. He’s underwater for almost a decade.

Bao’s apartment, by 2009, is worth about 45% more than what he paid. He’s the smart investor at every dinner party.

Same asset class. Same country. Same five-year holding period. Wildly different outcomes.

Most people, looking at this, will say “Ahmad got unlucky.” Or “Bao timed the market well.” Both are wrong, in an interesting way. The honest explanation is statistical, and once you see it, you’ll never read a “long-run average return” line in a property advert the same way again.

This piece walks through what 50 years of Singapore property data actually look like, what statisticians call fat tails, and the single most important — and most under-appreciated — fact about long-term property risk.

The “average return” story

Open any property-marketing brochure and you’ll see something like: “Singapore private property has appreciated by an average of 6.4% per year over the past 50 years.”

That’s not wrong. We pulled 50 years of quarterly data from SingStat — the URA Private Residential Property Price Index, from 1975 Q1 to 2025 Q4 — and the average comes out to about +1.57% per quarter, which annualises to roughly +6.4%. So far, so consistent.

The trouble is that the average is one of the least useful numbers you can compute about property returns. Here’s the actual time series:

The top panel is the price index. The bottom panel is the quarterly log-returns — basically, how much the index moved each quarter. Notice anything?

That bottom chart is not a tame, well-behaved process. It has periods of intense activity (the 1980–81 boom, the 1993–96 boom, the 1997–98 Asian crisis, the 2008 GFC dip and bounce) and long stretches of relative calm. The quarterly returns range from −15.2% (worst, 2009 Q1) to +24.4% (best, 1981 Q1). A single quarter can easily move the price by more than the average annual return.

Calling the average “+6.4%/yr” technically true and practically misleading is what statisticians call a Mediocristan-vs-Extremistan problem. We’ll come back to that.

The thing we don’t talk about: kurtosis

Here is the single most useful number for thinking about risk in fat-tailed worlds, and almost nobody outside finance ever encounters it: kurtosis.

(Pronounced “kur-TOH-sis.” Greek.)

It’s a measure of how much of the action is in the extremes versus the middle of a distribution. The bigger it is, the more the rare events dominate.

For a “normal” bell-curve distribution — the kind you learned about in school — kurtosis is 3.

For Singapore private residential property quarterly returns? 6.5.

For Singapore HDB resale flat returns? 18.2.

The HDB number is genuinely shocking. It is a direct symptom of one specific quarter: 1993 Q2, when HDB resale prices jumped by 27% in three months as a speculative boom rolled through public housing. That one observation, three decades later, still accounts for 74% of the total kurtosis of the entire HDB return distribution since 1990.

Translation in plain English: when you compute “the kurtosis of HDB returns” using 35 years of quarterly data, three-quarters of the answer comes from one quarter. The other 142 quarters together explain only the remaining 26% of it.

This is what “fat-tailed” means in practice. A single, unusual event dominates a statistic that’s supposed to summarise 35 years.

A picture is worth a thousand standard deviations

Here is the same point in chart form. The bars compare four Singapore property indices on four different “fat-tailedness” measures:

The red dashed lines show what a “normal-ish” distribution would look like.

Pearson kurtosis should be 3 for normal. SG indices range 5.6 to 18.2. Max quartic share — how much of the kurtosis is driven by one observation — should be about 0.05 for normal. SG indices range 0.31 to 0.74. Student-T fitted df, a sophisticated fat-tail measure where lower means fatter, with values near 2 indicating the underlying variance estimate is unreliable: SG indices 2.13 to 2.51. Hill α tail exponent, where lower means heavier tail and below 4 means kurtosis itself is mathematically infinite in the population: SG indices 2.17 to 2.91.

Across every measure, every SG property index is in the “fat-tailed” zone. None of them resemble the bell curve that most financial planning quietly assumes.

Why this matters, in dollars

Most retirement planning, mortgage stress-testing, and “how much can I afford?” calculations implicitly assume returns behave like a normal distribution. They use words like “expected return ± standard deviation” and reason about probabilities the way you’d reason about coin flips.

In a normal-distribution world, a quarter that’s 5σ off the mean is essentially impossible. About 1 in 1.7 million.

In a fat-tailed world, what financial textbooks call a “5σ event” can be a 1-in-100 event, or even more frequent. The 1993 Q2 HDB jump is a 7σ event in a normal model. The 1981 Q1 URA spike is a ~5σ event. The 2009 Q1 GFC dip is a ~3.4σ event. We’ve had multiple of these in 50 years, in just one country, in one asset class.

What that actually means if you’re buying a Singapore property today: your downside in any single quarter could be 15% or more, even with no leverage. Your upside in any single quarter could be 25% or more. The “1-in-50-years” event is more like 1-in-10. Standard deviation, as a measure of “how much can this move,” is simply not informative.

But there’s a more important fact than any of these — and it’s the one I think almost nobody knows about.

The real lesson: it’s clustering, not noise

Here is the most underappreciated finding in all of this. The chart below is the headline diagnostic from Nassim Taleb’s Statistical Consequences of Fat Tails. We applied it to Singapore data:

Each panel is one Singapore property index. The blue line shows the kurtosis (fat-tailedness) of returns aggregated over different time windows — 1 quarter, 2 quarters, all the way to 12 quarters (3 years). The green dashed line shows the same calculation, but with the returns randomly reshuffled in time.

Reshuffling preserves the distribution of returns. Same average, same variance, same fat marginal tails. What it destroys is the order: the relationship between consecutive quarters.

Look at what happens. The blue line (real, actual time-ordered data) stays elevated. Even at 12-quarter aggregation, kurtosis is well above the “normal” baseline of 3. The green dashed line (reshuffled) drops to roughly 3 — Gaussian — by lag 8 or 10.

If property returns were truly fat-tailed but independent quarter-to-quarter, the blue and green lines would look the same. They don’t.

What this means: the multi-year fat-tailed risk in Singapore property is not primarily about how fat-tailed the quarterly distribution is. It’s about the fact that bad quarters cluster together, and good quarters cluster together. The market spends years at a time in a “boom regime” or a “bust regime.”

Visible in the data:

• the 1980–81 boom was 6 consecutive quarters of double-digit gains.

• The 1993 HDB boom was two consecutive quarters of +27% then +18%.

• The 1996–2004 URA bust was 10-quarter, ~45% peak-to-trough drawdown, after which the index stayed below the 1996 peak for over a decade.

• The 2008 GFC dip was 4 consecutive negative quarters before recovery.

This is the difference between two mental models. Model A says fat-tailed but independent — each quarter is an independent draw from a fat-tailed distribution; long-run drawdowns wash out via central-limit theorem; standard fat-tail stats describe the risk well; 5-year worst case is moderate. Model B says clustered booms and busts — quarters within a regime are correlated; regimes are persistent; long-run drawdowns compound because all the bad quarters land in the same window; you also need to model regime persistence; 5-year worst case is severe (45%+ drawdowns observed).

The data say Model B is correct.

What this means for an actual buyer

If you buy property today expecting “the long-run average return is 6.4% per year, so over 5 years I should average 32% appreciation,” you’re using Model A. Model A says 5 years of bad luck is a freak event.

Model B says: the 5-year outcome is dominated by what regime you’re in, which is largely determined by when you bought. It’s not about luck. It’s about timing relative to the regime.

Practical consequences:

1. Late-regime entries are more dangerous than they look. Buying at the top of a sustained price run (high transaction volume, optimistic narratives, rising leverage in the system) raises the conditional probability that you’re at the start of a bust regime. Buying at the bottom of a sustained drawdown (low transaction volume, pessimistic narratives, distressed listings) does the opposite. Same property, same physical asset — wildly different conditional 5-year outcomes.

2. Holding period interacts with regime, not with calendar time. A 5-year holder who happens to enter the start of a boom regime exits at peak. A 5-year holder who enters at the start of a bust compounds losses. Same hold length, completely different experience.

3. Leverage that’s “safe in normal times” can ruin you in a long bust. A 70% LTV ratio is a manageable risk in a stable regime — even with the occasional bad quarter. In a 7-year bust regime where prices fall 40%, the same 70% LTV means negative equity for years. You can’t refinance, you can’t sell at non-distressed prices, and you have to keep servicing the loan throughout. Th==e risk is not the worst single quarter; it’s the duration of the bust regime exceeding the buffer your finances can absorb.

4. Stress-test using historical events, not multiples of σ. When your bank or your spouse asks “what’s the worst case?”, don’t say “two standard deviations down.” Say “what if 1996–2004 happens again?” That’s a 45% drawdown over 7 years with the property essentially impossible to sell at non-distressed prices throughout. If your finances can survive that, you can buy. If they can’t, you can’t, regardless of what the average suggests.

5. Don’t outsource your regime-judgment to property gurus. Most property advice in Singapore is sold by people whose income depends on you transacting. They are structurally biased to believe whatever bullish or bearish narrative drives volume. Your actual cycle-positioning decision should rest on regime indicators (transaction volumes, price-to-rent ratios, mortgage-to-income ratios, supply pipelines, policy direction) — not on someone else’s confidence.

The bigger lesson

You can extend this beyond property. Almost every domain you care about is fat-tailed in this same way.

• Equity markets have clustered crashes (1929, 1987, 2000, 2008, 2020)

• Career outcomes are dominated by a few breakthrough years.

• Most of your lifetime medical risk is concentrated in a few specific events.

• A small fraction of relationships carry most of the long-term consequence.

The intuitive ways we think about averages and volatility — trained by exam questions about coin flips and dice — break down in these domains. The standard deviation underestimates the spread, the mean is dominated by outliers, and “averaging out over the long run” doesn’t happen because the long run is dominated by clustered regimes, not by independent draws.

Want to verify this yourself?

Here’s the entire analysis pipeline. Less than 100 lines of Python. The data is publicly available — no special access required.

import json
import urllib.request
import numpy as np
import pandas as pd
from scipy import stats

# 1. Fetch URA Private Residential PPI from SingStat (public API)
URL = "https://tablebuilder.singstat.gov.sg/api/table/tabledata/M212261?limit=5000"
data = json.loads(urllib.request.urlopen(URL).read())
row = next(r for r in data["Data"]["row"] if r["rowText"] == "Residential Properties")
ppi = pd.Series(
    [float(c["value"]) for c in row["columns"]],
    index=pd.PeriodIndex(
        [pd.Period(f"{c['key'].split()[0]}Q{c['key'].split()[1][0]}", freq="Q")
         for c in row["columns"]],
        freq="Q",
    ),
)

# 2. Compute quarterly log-returns
r = np.log(ppi / ppi.shift(1)).dropna().values

# 3. Headline statistics
print(f"n = {len(r)} quarterly observations, 1975Q1 to 2025Q4")
print(f"mean per quarter   = {r.mean():+.4f}")
print(f"Pearson kurtosis   = {stats.kurtosis(r, fisher=False):.2f}  (Gaussian = 3)")

# 4. Single-event dominance test
x4 = r ** 4
print(f"Max single-quarter share of total x^4: {x4.max() / x4.sum():.3f}")

# 5. Clustering test (Taleb's Fig 10.2)
def kurt_at_lag(returns, lag):
    n = len(returns) // lag
    aggregated = returns[:n*lag].reshape(n, lag).sum(axis=1)
    return stats.kurtosis(aggregated, fisher=False)

print(f"raw,        lag=12: {kurt_at_lag(r, 12):.2f}")
rng = np.random.default_rng(42)
shuffled = []
for _ in range(200):
    s = r.copy(); rng.shuffle(s)
    shuffled.append(kurt_at_lag(s, 12))
print(f"reshuffled, lag=12: {np.mean(shuffled):.2f}  (mean of 200 shuffles)")
```

When you run it, you'll see the raw lag-12 kurtosis stays well above 3, but the reshuffled version drops to about 2.7 — exactly the volatility-clustering signature this article describes.

Disclosure

Both this article and the Python analysis code were generated by Claude, Anthropic's AI assistant. The data is from SingStat (Singapore's Department of Statistics) and is publicly available. The methodology follows Chapter 10 of Nassim Nicholas Taleb's Statistical Consequences of Fat Tails (2020), particularly Figure 10.2 on the role of volatility clustering in apparent fat-tailedness.

I ran every test described, generated every chart from the actual data, and have full reproducibility. If anything looks wrong, please tell me — fat-tail analysis is famously easy to get subtly wrong, and a second pair of eyes is welcome.

To get the most out of AI agents, we need to remove human bottlenecks and increase leverage.

If you want to jump straight to the implementation, the full code is here: Github.

What Was Really Being Tested

My company recently held a modeling competition in which participants were allowed to use only AI tools, without writing any code themselves. The objective was straightforward: maximize the AUC of a supervised learning task.

In tabular supervised learning, the practical toolkit is already quite mature. Gradient boosting models remain the dominant high-performance baseline, and in real-world applications the largest gains often come not from changing the model class, but from accumulating more data, engineering better features, and defining targets that better reflect business objectives. Model fine-tuning can help at the margin, but it rarely produces step-change improvements. Even in sequential modeling, much of the value can be understood as learning richer representations of the underlying behavior and structure.

For that reason, the most interesting question was not whether an LLM could write code to implement ideas that human practitioners had already provided. If humans specify the feature candidates, the modeling tricks, and the overall direction, then the exercise becomes largely a test of coding and execution. That is useful, but not especially interesting. A more meaningful test is whether an LLM can autonomously discover promising ideas for itself: what features to construct, which techniques are worth trying, how to interpret intermediate results, and how to iterate toward better performance under a clear objective.

Seen from this perspective, the purpose of the competition, in my own opinion, was not to discover a fundamentally new classification algorithm nor implementing solutions based on human insights. It was to test whether an LLM could independently reproduce the practical workflow behind strong credit risk modeling: generating hypotheses, engineering useful features, running experiments, learning from feedback, and improving performance through iteration. Put differently, if the playbook used by experienced practitioners is only partially specified, how much of it can an LLM recover on its own?

This also made the exercise a test of instruction design. Beyond model performance, it offered a way to understand how tasks should be framed so that an LLM can explore the solution space productively rather than simply execute a predefined recipe.

The Experiment Setup

At first glance, the objective may seem clear enough: give the LLM a target metric and ask it to iterate on its own. But things work more smoothly in human teams because people already share a large amount of tacit context: what counts as a valid experiment, what shortcuts are unacceptable, how performance should be evaluated, and when a result is worth keeping. For an LLM, many of these assumptions have to be made explicit.

To make the exercise meaningful, we needed to specify a set of operating rules that human teams would often leave implicit.

The experimental setup was not fully specified from the start; as I observed the agent’s behavior, I iteratively refined and steered it. For example, in the later stages, I found that the acceptance threshold had become too strict.

Scope. We had to define what the agent was allowed to modify, what it was not allowed to touch, and what kinds of actions were permitted or prohibited.

Integrity. The agent could use only data available before the application date. It also had to check for leakage before proceeding, especially when a single feature appeared to perform suspiciously well.

Evaluation. The evaluation methodology had to be fixed in advance. Otherwise, the LLM could improve reported scores simply by changing the validation setup rather than improving the model itself.

Promotion criteria. We needed to define what magnitude of improvement was sufficient for a new approach to be accepted and carried forward.

Logging. Like humans, LLMs do not naturally produce good documentation unless asked to do so. To make their work inspectable—and to give the agent a usable record of its own progress—we had to explicitly require logging.

Resource constraints. The agent needed rules for efficient experimentation: cache generated features for reuse, avoid recomputing unnecessarily, explore ideas in parallel where possible, and operate within limits on the number and scale of experiments.

Simplicity. Some human judgment still had to be encoded into the setup. In general, we preferred simpler models when they delivered performance comparable to more complex alternatives.

Stopping criteria. We also had to define when the agent should stop iterating, rather than continuing to search indefinitely for marginal gains.

These rules were not just administrative details. They were part of the experiment itself. If the goal was to test whether an LLM could behave like a disciplined modeler, then the environment had to specify the constraints under which disciplined modeling takes place.

You can find the full instruction to the LLM here.

How the LLM Iterated

The LLM spent around 48 hours to reach the final result. In the first 24 hours, I did not prompt the LLM anything and it reached 0.793424 AUC at round 31. The, the LLM stucked for consecutive 12 rounds. I prompted the LLM to leverage websearch to search for ideas, although I already stated that in the original prompt and it preferred relying on its internal knowledge.

Thoughts

With clearly defined objectives and boundaries, an LLM can iterate on its own and uncover most of the early low-hanging fruit much faster than a human can. However, more distant ideas—such as KNN-based approaches or sequential modeling, which require a more creative leap—seem harder for it to discover. That said, the LLM only spent two days exploring the solution space. Without internet access, it is not obvious that a human could have found those ideas within the same time frame either. My guess is that the top-performing team spent far more than two days to achieve its breakthrough, and likely involved multiple team members.

What stands out most is how much cheaper it becomes to try new ideas. The cost of experimentation drops sharply in terms of both time and human effort. With its coding ability, the LLM can translate modeling ideas into working code extremely quickly. Generating roughly 300 additional features, running hyperparameter tuning, stacking multiple models, and building sequential representations of the data—all within two days—would be expensive for a human team. To do the same amount of work, we might need five to ten experienced practitioners. In my case, I did not even fully use the token budget of Claude’s USD 100 max plan.

Will humans lose their jobs? Partly, yes. LLMs will increasingly replace a large share of the coding, pipeline construction, and some feature engineering work. But they still need humans to provide direction. The human role will shift toward defining the scope, constraints, and objectives of the task, and then validating the outputs. At least for now, humans also seem to have better taste—in the sense of searching the solution space more efficiently and recognizing which directions are truly promising. We sometimes hear stories of LLMs surfacing obscure old papers that solve a problem outright, which suggests that this advantage may not always hold. But on average, I still think humans with domain knowledge retain an edge.

Will that remain true as we use LLMs more and progressively transfer domain knowledge into them? I do not know. If forced to give a rough estimate, I would guess that within five to ten years, LLMs may surpass humans even in the discovery of previously unknown solutions.

What seems much clearer is that, over the next five years, human-plus-AI will dominate human-alone workflows. The productivity gain is easily an order of magnitude for many existing tasks, and in some cases effectively unbounded because AI enables work that would not have been attempted otherwise. If you are not using AI every day to learn new things, you are likely falling behind. If you are not using it to accelerate coding-related work, you are almost certainly moving much more slowly. And if you are not using it to help generate new ideas and solutions, you may already be at a meaningful disadvantage. Once these effects compound, the gap between human-only and human-plus-AI workflows becomes very large.

Next Step

If the current limitation is the LLM’s “taste,” then the next frontier is not just better models, but better ways of searching the solution space. The key challenge is to help the LLM explore more intelligently, so that it can identify promising directions earlier instead of relying mainly on broad trial and error. Early thoughts including the use of tree-of-thoughts and Monte Carlo Tree Search (MCTS) which I will try to implement in next week.

I also need to better maximize the available token budget. During this project, the agent never came close to exhausting the token allowance of the Claude Max ($100/month) plan. In practice, a considerable amount of time was spent waiting for model runs to finish while the agent was otherwise idle, suggesting that I did not make full use of the available capacity.

Recommend Readings

Cash is “Still” the King

Many financial advisors say cash is trash because the government can “print” money and that cash will depreciate relative to other assets. Therefore, cash is a poor asset to hold. However, it is not always the case. If equity goes down by 18%, the same amount of cash can now buy 22% more equity (1/(1-18%) - 1) — cash gains in relative purchasing power even though its nominal value stays the same. In particular, during monetary tightening, bond prices fall while cash yields rise, making cash an attractive asset to hold. More generally, cash earns interest when treated as an investable asset rather than a medium of exchange, and its yield roughly follows the short end of the yield curve.

Singapore Savings Bonds

SSB is a 10-year government bond issued monthly by MAS, available to individuals in multiples of $500. What makes it unique is its structure: SSB is a single instrument with a guaranteed principal that replicates the SGS yield curve at every holding period — prioritising the step-up feature when the curve shape doesn’t naturally allow it. To my knowledge, this structure offers a few advantages:

• Flexibility in holding period: Investors do not have to commit to a fixed holding period, unlike with fixed deposits and bonds. SSBs can be redeemed at par in any given month with no penalty.

• No price risk: Unlike a bond, which trades on the secondary market and whose price can drop below par value, the SSB principal is guaranteed.

• No reinvestment risk: The coupons are guaranteed and locked in at issuance. For 6-month or 1-year T-bills, when they mature, investors must reinvest at the then-available rate, which may be lower.

Effectively, SSB offers two embedded protections. The first is a free put option at par, allowing the investor to “sell” it back to the government at face value at any time — this protects when rates rise. The second is a free forward rate agreement on the full yield curve, locking in returns for up to 10 years — this protects when rates fall. The limitation, however, is the investment cap ($50,000 per issue and $200,000 per individual).

How SSB Rates Reflect the Yield Curve

To understand how SSB coupons are derived, it helps to look at the underlying SGS yield curve across different rate environments. The chart below shows three panels: the SGS benchmark yields (input), the resulting SSB coupon rates (output), and the average returns investors actually earn.

Panel 1 — SGS Yield Curves (the input)

The yield curve shape has changed dramatically across eras

• 2015-2017 (purple): Steep upward slope — short rates ~1%, long rates ~2.2%

• 2020-2021 (teal): Lowest across all tenors — near-zero short rates from COVID easing

• 2022-2024 (red): Inverted — short rates (~3.5%) are higher than long rates (~3%) from aggressive rate hikes

• 2025-2026 (orange): Re-steepening as short rates fall faster than long rates

Notably, all eras converge to a narrower range at 10Y (~1.4-3%) than at 1Y (~0.3-3.5%), reflecting the fact that long-term rate expectations are more stable than short-term policy rates.

Panel 2 — SSB Coupons (the output)

• The step-up mechanism transforms the yield curve shape into a monotonically increasing schedule

• Inverted curves (red) become flat coupons — the monotonicity adjustment compresses everything to the 10Y level

• Steep curves (purple) produce dramatic step-ups — from ~1% to ~3.5%

• The Y10 coupon is always higher than the Y10 yield because it compensates for the lower early coupons

Panel 3 — Average Returns (what investors actually earn)

• This is the smoothed version of the coupon schedule — always monotonically increasing and more gradual

• At 10Y, it matches the SGS yield in Panel 1 — confirming the design works

• At shorter tenors, it matches SGS yields only when no monotonicity adjustment is needed

Key takeaway

The three panels tell the story of a single financial engineering pipeline: a market yield curve (which can be any shape — steep, flat, inverted) gets transformed into an investor-friendly product that always steps up, always returns principal, and always delivers the 10Y market return. The price of this guarantee is visible in the red era — when the curve inverted, short-term SSB holders earned well below the prevailing T-bill rate because the step-up constraint sacrificed short-tenor returns to preserve the monotonicity feature.

Methodology

For those interested in the methodology for deriving the SSB coupon from SGS benchmark rates, you may refer to this MAS paper. Here is a high-level skeleton:

Step 1 — Get Benchmark Yields

• Download daily SGS benchmark yields from MAS Benchmark Prices and Yields

• Specifically: 1-Year T-Bill Yield, 2-Year Bond Yield, 5-Year Bond Yield, 10-Year Bond Yield

• Compute the simple average of all trading days from month M-2 (two months before the SSB issue month)

Step 2 — Interpolate the Full Yield Curve

• Use a hermite spline to fill in the missing tenors (3Y, 4Y, 6Y, 7Y, 8Y, 9Y)

• Now you have 10 par yields: Y1, Y2, ..., Y10

Step 3 — Bootstrap Discount Factors

• Convert par yields into discount factors (the present value of $1 received at each future year)

• DF1 = 1/(1+Y1), then each subsequent DF is solved from the no-arbitrage pricing equation

Step 4 — Solve for Step-Up Coupons

• Find coupon rates C1, C2, ..., C10 such that the bond prices are at par for every holding period

• This means: an investor who holds for N years and redeems at par earns the same return as an N-year SGS bond

• C1 = Y1, then each subsequent coupon is solved forward using the discount factors

Step 5 — Enforce Monotonicity

• If the raw coupons don’t step up (e.g. inverted yield curve), adjust them:

  • Minimize the pricing error across all tenors

  • Subject to: coupons never decrease, 10Y return is preserved exactly

• Round to 2 decimal places

Data Sources

• SGS benchmark yields: MAS Benchmark Prices and Yields

• Published SSB rates: MAS Step-Up Interest Rates (127 bonds, Oct 2015 – Apr 2026)

• Technical specification: SSB Technical Specifications, Section 4

Having recently rotated from the Credit Risk team to the Anti-Fraud team, I’ve realized that while the terminology differs, the fundamental logic—derived from the first principle of Maximizing Profit—is remarkably similar. Below, I demonstrate the mathematical unity of the two domains and highlight the key strategic differences.

The Shared Math: Maximizing Incremental Value

Let’s start with the basics. Total profit equals the revenue from good users minus the losses from bad users.

• True Negatives (TN): Approved users who pay (Profit).

• False Negatives (FN): Approved users who default/fraud (Loss).

Define positive as “we block/reject because predicted bad,” and negative as “we approve.

We can express this as:

Where R is Revenue per Good User and L is Loss per Bad User.

However, this equation is too static for strategy design. To decide whether to approve or reject a specific segment, we need to look at the Counterfactual: What is the value added by our decision model compared to doing nothing?

If we compare our strategy against a baseline of “Approving Everyone,” the Total Profit can be rewritten as:

• N_good,N_bad: Total population of good and bad users (Constant).

• TP⋅L: The loss saved by correctly blocking bad users.

• FP⋅R: The revenue sacrificed by incorrectly blocking good users.

Since the Baseline Profit is constant (determined by the population), maximizing Total Profit is mathematically identical to maximizing Incremental Strategy Value.

The Optimality Condition: MC = MB

Economics teaches us that profit is maximized when Marginal Cost equals Marginal Benefit.

Let p^ be the probability that the next user we assess is “Bad.”

• Marginal Benefit: If we block them and they are Bad, we save L.

• Marginal Cost: If we block them and they are Good, we lose R.

We should stop blocking exactly when the cost outweighs the benefit:

​​

This simple ratio, R/(L+R)​, is the “Universal Cutoff.” But the two teams view it from opposite ends.

1. The Anti-Fraud View (The Defender)

In fraud, we “block” transactions.

• Revenue (R): The cost of insulting a good customer (C_insult), which is the interest loss.

• Loss (L): The fraud loss saved (C_fraud), which is the principal loss.

The probability p^here represents the probability of fraud—which is exactly the definition of Precision for that marginal alert.

​​If the model’s precision drops below this threshold, the cost of insulting good customers exceeds the value of the fraud we stop.

A Note on Terminology: Why does Probability (p^) equal Precision?

It might seem confusing to equate a single user’s probability score (p^​) with a group statistic like Precision. However, at the margin, they are identical. Simply apply the Law of Large Numbers:

Imagine our model assigns a risk score of 0.20 to a specific transaction. This prediction literally means: “There is a 20% chance this specific transaction is fraud.” , assuming the model is well-calibrated.

Now, imagine we gather 100 transactions that all share this exact risk score of 0.20.

• Expected Fraud (TP): 20

• Expected Legitimate (FP): 80

If we block this specific bucket of users, the Precision is:

Thus, the Probability Score at the cutoff is simply the Marginal Precision of the decision at that cutoff.

2. The Credit Risk View (The Attacker)

In credit, we “approve” loans.

• Revenue (R): Interest Income.

• Loss (L): Principal Loss.

The probability p^​ here represents the Probability of Default (PD).

​If the user’s PD rises above this threshold, the expected principal loss exceeds the potential interest income. (Of course, this is a simplified way to calculate revenue and cost but it captures the essence.)

Conclusion: Same Line, Opposite Directions

Mathematically, Minimum Precision and Maximum PD are the exact same number.

• The Anti-Fraud team defends the gate, blocking bad actors until the precision drops to the cutoff.

• The Credit Risk team expands the market, approving users until the risk rises to the cutoff.

The Strategic Divergence: Different Enemies

If the math is identical, why do the jobs feel so different? Because while the equation is the same, the enemy is not.

1. Definition of “Bad”

• Credit Risk: “Bad” is defined solely by default.

• Anti-Fraud: “Bad” is defined by intent (Deception). Thus, default alone is not sufficient. The team will also look for suspicous patterns.

2. Static vs. Dynamic (Game Theory)

This is the most critical difference.

• Credit Risk mostly plays against Nature. Borrowers are relatively stable. A user with a 620 credit score today behaves similarly to a 620 user yesterday. Historical “Vintage” data is highly predictive of the future.

• Anti-Fraud plays against an Adversary. Fraudsters are intelligent, coordinated, and reactive. If you set a static rule to block X, they immediately shift to Y.

  • Implication: Credit teams optimize for Efficiency (Calibration). Fraud teams must optimize for Adaptability (Exploration).

3. The Action Space

• Anti-Fraud: The decision is usually binary (Approve vs. Reject) or friction-based (Step-up Verification).

• Credit Risk: The decision is multi-dimensional. We can manage risk not just by rejecting, but by adjusting the Credit Limit, Tenure, or Pricing (EIR). We have more levers to force the unit economics to work.

4. The Entity Dimension (Multi-Modal Risk)

• Credit Risk is almost exclusively User-Centric. We underwrite the person (or the business entity) applying for funds. The unit of analysis is stable.

• Anti-Fraud is Multi-Modal. We don’t just assess the User; we assess the Device, the IP address, the Credit Card, and the Merchant.

The Economic Implication: The variables in our profit equation (C_insult​ and C_fraud​) shift drastically depending on what we are blocking.

• Blocking a Device: If I block a suspicious device ID, the CinsultCinsult​ might be low (the user is annoyed but can switch devices). Result: I can afford a lower precision threshold.

• Blocking a Merchant: If I block a merchant in a marketplace, I cut off revenue from all their customers. The C_insult(Lost Revenue) is massive. Result: I need an extremely high precision threshold—often requiring manual review—before pulling the trigger.

While Credit Risk optimizes one curve (User Risk), Anti-Fraud constantly juggles multiple curves with different breakeven points.

Closing Thoughts

I am still very much a learner in this space, but realizing that Credit Risk and Anti-Fraud share the same Unit Economics has been a helpful anchor for me.

It means that while I am learning new tactics (Game Theory, Pattern Recognition), the underlying grammar of Profit Maximization remains the same.

How do these metrics relate to each other?

The “Two Rooms” Analogy

The standard confusion matrix terms—True Positive (TP), False Positive (FP), True Negative (TN), and False Negative (FN)—can be headache-inducing to communicate in practice.

To simplify this, imagine two separate rooms:

1. The Bad Room: Contains only actual bad actors (Total Bad = TP + FN).

2. The Good Room: Contains only actual good users (Total Good = TN + FP).

Your model is a gatekeeper. You walk into each room with your classifier.

• In the Bad Room, you want the model to identify everyone as bad. The percentage of people you successfully catch here is your True Positive Rate (TPR).

• In the Good Room, you want the model to identify no one as bad. The percentage of people you mistakenly flag as bad here is your False Positive Rate (FPR).

A perfect model has a TPR of 100% (catches everyone in the Bad Room) and an FPR of 0% (flags no one in the Good Room).

Visualizing AUC and KS

Realistically, models output a probability (e.g., “There is a 90% chance this user is a fraud”). We use a “threshold dial” to decide who to flag.

Imagine turning this dial:

• Threshold 100% (Strict): You only flag apparent fraud. You catch almost no one in the Bad Room (TPR≈0), but you also annoy no one in the Good Room (FPR≈0). This is the point (0,0)on the ROC plot.

• Threshold 0% (Loose): You flag everyone. You catch every fraudster (TPR=100%), but you also falsely flag every good user (FPR=100%). This is the point (1,1).

AUC (Area Under the Curve) measures the model’s performance across all possible settings of this dial. It plots TPR against FPR. A random guess gives you a straight diagonal line (AUC 0.5), meaning for every extra bad person you catch, you annoy a proportional number of good people. A good model bows upward, maximizing the gap between the TPR and FPR.

KS (Kolmogorov-Smirnov) focuses on the single best point on that curve. It is simply the maximum difference between TPR and FPR. While AUC looks at the whole story, KS asks: “At the single best setting of the dial, how much separation can we get between the good and bad populations?”

Deep Dive: Why KS is Cumulative

KS is usually plotted using the cumulative number of bads and goods. The maximum difference between the two curves is the KS.

Imagine taking all the people from both rooms and lining them up in a single queue, sorted by their model score from Highest (Most Suspicious) to Lowest (Least Suspicious).

Now, imagine walking down this line from the start. This is equivalent to lowering your threshold.

1. Cumulative Bad (TPR): Every time you walk past a Bad Person, you add them to your count. If there are 100 Bad People total, and you have passed 50 of them, your “Cumulative Bad %” is 50%. This is exactly the True Positive Rate (TPR).

2. Cumulative Good (FPR): Every time you walk past a Good Person, you add them to your count. If there are 1,000 Good People total, and you have passed 100 of them, your “Cumulative Good %” is 10%. This is exactly the False Positive Rate (FPR)

Below is a simulation dashboard I asked Gemini to build to visualize these concepts: Link

Why Anti-Fraud Cares: Precision and Recall

In the anti-fraud world, Recall is just another word for TPR (Bad Room coverage). But Precision is different.

While TPR and FPR require you to look at the rooms separately, Precision requires you to look at who the model flagged from both rooms combined. It asks: “Of all the people the model claimed were bad, how many were actually bad?”

​Why is this preferred over FPR in fraud operations?

1. Operational Reality: In fraud, a positive flag usually triggers a manual review, an SMS alert, or a transaction block. These actions have direct costs (agent time) and customer friction (insult). Precision measures the “purity” of the alert queue.

2. The Class Imbalance Problem: This is the key differentiator. Precision is highly sensitive to the Bad Rate.

   • FPR is calculated only inside the Good Room. If you double the number of good customers, the FPR remains stable.

   • Precision depends on the ratio of good to bad. If the number of good customers explodes while the number of fraudsters stays the same, your Precision will plummet because the “noise” (False Positives) drowns out the signal.

In summary, the Modeling Team often focuses on AUC/KS because they measure the model’s pure ability to rank order, independent of the portfolio’s bad rate. Anti-Fraud focuses on Precision because it reflects the actual operational pain of sifting through false alarms in a sea of good transactions.

Why does the credit risk team seldom look into Precision and Recall?

This question deserves a dedicated deep dive in the next post.

Fundamentally, both Underwriting and Anti-Fraud teams share the exact same goal: maximizing profit. They simply approach the P&L equation from opposite ends (Alert: Fraud is a dynamic process. The environment is not stable because the fraudster evolves.):

• Underwriting aims to maximize disbursements. They expand approvals until the marginal cost of defaults outweighs the marginal revenue from interest. Their constraint is the Breakeven Cost of Risk.

• Anti-Fraud aims to minimize losses. They expand fraud detection until the cost of friction (insulting good customers) outweighs the savings from stopping fraud. Their constraint is Breakeven Precision.

In my following note, I plan to demonstrate mathematically that these two concepts are identical: the Breakeven Cost of Risk in lending equals the Breakeven Precision in fraud prevention.

But when I sat down to analyze my own experiences—trying to pinpoint exactly where that feeling comes from—I realized that anxiety isn’t usually random chaos. It’s almost always structural. It stems from specific flaws in the mental models I use to navigate the world.

If we can identify the roots of the anxiety, we can build a framework to handle it.

Through my reflection, I identified three main sources of anxiety, how they interconnect, and a two-step approach to regain our footing.

Part 1: The Diagnosis (Where Anxiety Comes From)

In my experience, anxiety isn’t usually caused by the event itself, but rather my relationship to the event. It almost always stems from one of these three situations:

1. The Expectation Gap (The Illusion of Control)

We often hear that anxiety comes from a “loss of control.” But that’s only half the story. Before you can lose control, there must be an expectation that you had it in the first place.

Anxiety thrives in the gap between our expectations and reality. Sometimes, we set the bar impossibly high, wanting control over things that are inherently uncontrollable. When we expect to be in the driver’s seat and reality suddenly grabs the wheel, panic sets in. The anxiety isn’t just about what is happening; it is the friction caused by our resistance to reality.

2. The Value Vacuum (Not Knowing What You Want)

If you don’t have a clear internal hierarchy of values—knowing exactly what you want and what is truly important to you—you become a reactive vessel for external pressures.

We live in an era of massive information flow and endless options. Without a strong internal compass, everything feels equally important. The urgent drowns out the important. This leads to chronic overwhelm as we try to juggle conflicting priorities that we didn’t even choose for ourselves.

3. The Social Mirror (External Validation)

This is perhaps the most paralyzing source: putting too much emphasis on other people’s views of us.

When we don’t know our own value (point #2), we outsource the measuring of it to society. We look into the “social mirror” to see if we are okay. The problem is that the mirror is constantly changing, and we have zero control over what others think. Basing your stability on something unstable is a recipe for constant anxiety.

Part 2: The Prescription (How to Handle It)

So, how do we break this cycle? The solution requires flipping our operating system. Instead of looking outward for cues, we must start inward.

Step 1: Define Your “Self” First (First Principles Thinking)

To handle anxiety, you must make your own self the priority. Before you look at the world, you have to look in the mirror and ask: What do I actually want? What is genuinely important to me?

This is difficult. We are conditioned by social norms and existing incentive systems. We often treat these systems (like career ladders or social expectations) as rigid boundaries.

But we must remember that these systems were designed by other people to put constraints on behavior. Don’t treat them as immutable laws of physics before you even know what you want.

The shift: Figure out what you value first. After you know what you want, then you can look at the societal constraints and decide consciously whether you want to work within them or break them. You become the actor, not the reactor.

Step 2: The Spheres of Control

Once you know what you want, the final step is calibrating your effort. While the Stoics famously spoke of the “dichotomy of control” (what is yours vs. what isn’t), I find it more useful to split control into three distinct rings.

Ring 1: Direct Control

This is your internal territory. It includes your actions, your effort, what you say, and how you allocate your time. This is the only place where you have total agency.

Ring 2: Influence

This is the gray area where most anxiety lives. It includes relationships, team decisions, negotiations, and probabilities. You can affect the outcome here, but you cannot dictate it.

Ring 3: No Control

This is the environment. It includes the macro economy, the weather, the past, and other people’s internal states.

How this fixes anxiety:

Anxiety is usually a result of trying to apply Ring 1 energy to a Ring 3 problem. To reduce it, you must map your worries to the correct ring:

• In Ring 1: Act strongly. Focus on high-quality input and effort.

• In Ring 2: Experiment and negotiate. Influence the odds, but detach from the guarantee.

• In Ring 3: Practice acceptance. Observe it without trying to change it.

Moving Forward

Anxiety often feels like a defect, but I’m starting to view it as a signal.

It’s a signal that my expectations are out of alignment with reality, or that I’m trying to control the uncontrollable. By using this framework to diagnose the source and placing my efforts in the correct ring, the fog begins to lift.