DEV Community: Lucian (LKB)

I built an open, reproducible typing-speed test — and it won't show a number until it earns one

Lucian (LKB) — Sat, 01 Aug 2026 14:48:49 +0000

Search "average typing speed" and you'll get confident numbers — 40 WPM, 65 WPM, "professionals hit 75" — almost always with no passage, no method, and no dataset behind them. I wanted one I could actually defend, so I built a live typing test that collects an open, anonymized dataset and, crucially, refuses to publish an average until it has enough data to mean anything.

It runs on Cloudflare Workers + D1. It's live, the dataset is downloadable, and every headline number is reproducible from a script. Here's how it's built and the decisions that keep it honest.

Why WPM is hard to measure fairly

Three problems sink most "typing speed" numbers:

Comparability. If everyone types different text, WPM isn't comparable — a familiar sentence types faster than a technical one. Fix: one fixed, standardized passage for everyone.
Gross vs. net. Counting every keystroke rewards fast-and-sloppy. Fix: net WPM — only characters that match the passage at the same position count, so mistakes lower your score.
Cheating. A paste "types" 300 WPM. Fix: block paste, and reject anything outside a plausible human range server-side.

The scoring is deliberately boring and standard:

// a character counts only if it matches the passage at that position
let correct = 0;
for (let i = 0; i < Math.min(typed.length, passage.length); i++) {
  if (typed[i] === passage[i]) correct++;
}
const netWpm = (correct / 5) / (elapsedMs / 60000); // 5 chars = 1 "word"
const accuracy = correct / typed.length;             // as a percentage

Keeping submissions honest (without accounts)

No login, but a few cheap gates keep the dataset clean:

A short-lived HMAC token fetched right before submit — blocks tokenless curl spam.
A 1–250 WPM plausibility bound — a paste or bot lands well above 250 and is dropped.
A per-visitor daily cap, so one source can't skew the set.
Privacy: the server never stores your IP. It keeps a salted SHA-256 hash purely for rate-limiting, and the public export contains only timestamp, wpm, accuracy.

The part I care about most: the honesty gate

With a few dozen samples, one fat-fingered run swings the average wildly. So the page hides the headline until it has 1,000 results, and reports the median (robust to outliers) rather than the mean:

function renderHeadline(d) {
  if (!d || d.count < 1000) {
    return `Collecting data — ${d ? d.count : 0} tests so far.`;
  }
  return `The median typist reaches ${Math.round(d.median_wpm)} net WPM ` +
         `at ${Math.round(d.median_accuracy)}% accuracy — over ${d.count} tests.`;
}

Right now it genuinely says "collecting data — 0 tests." That's the point: I'd rather show an honest zero than a made-up average. Typing speed is a trained skill, so the honest description isn't a single number anyway — it's a distribution, which the page draws as a live histogram once results come in.

It's reproducible

The stats aren't a black box. There's a public CSV export and a small Node harness that recomputes every published figure — median WPM, median accuracy, trimmed mean, percentiles, histogram — using a verbatim copy of the site's own stats code:

node typing-speed-study.mjs
# fetches https://lkforge.com/api/typing/export and recomputes the numbers

So the claim isn't "trust my dashboard," it's "here's the raw data and the exact math — run it yourself."

Try it (and feed the dataset)

The whole thing only becomes interesting with data, and it's at zero. If you want to add a point and watch the distribution build:

Take the test: https://lkforge.com/tools/typingtrack/typing-speed-study/
Reproduce the numbers: https://gist.github.com/lucian-devops/063798164ec86d076e977d003eb87c30
Raw dataset (CSV, CC BY 4.0): https://lkforge.com/api/typing/export

I'll write a follow-up with the actual distribution once there's enough data to report one honestly. Curious what people think of the honesty-gate approach — worth the "boring zero," or would you just show the running average with a caveat?

Six Games, Three Classic Algorithms: Shipping Real Game AI in Vanilla JS

Lucian (LKB) — Thu, 30 Jul 2026 17:24:55 +0000

Syndicated from my blog. Canonical: https://lkforge.com/blog/game-ai-three-algorithms/

I built six small browser games — 2048, tic-tac-toe, sudoku, and a few others — and gave each a real AI opponent or solver. No libraries, no WASM, no server calls. Three textbook search algorithms cover all of them:

Minimax with alpha-beta pruning — perfect play for adversarial, fully-observable games (tic-tac-toe).
Expectimax — the same idea, but averaging over chance nodes instead of assuming a rational opponent. This is what drives the 2048 solver, because tile spawns are random.
BFS pathfinding — for the games that are really shortest-path problems in disguise.

The 2048 solver, concretely

2048 isn't adversarial — there's no opponent, just a 90/10 random 2-or-4 spawn after each move. So minimax is the wrong tool; you want expectimax, which alternates max nodes (your move) with chance nodes (the random spawn), weighting each outcome by probability.

The heuristic is what actually matters. Mine rewards three things:

A corner-snake gradient — a weight matrix that pins the largest tile in one corner and wants values to descend in a boustrophedon "snake" from there.
Empty cells — heavily weighted, because running out of space is how you lose.
Smoothness — adjacent tiles close in log2 value, so merges stay available.

Search depth adapts to how full the board is (deeper when there's more empty space to reason about), and chance nodes sample a bounded number of empty cells so branching stays tractable.

The honest part: I measured it instead of claiming it

It's easy to write "unbeatable AI" in a README. I ran a headless self-play harness instead — thousands of games, logged outcomes — and published the real numbers, including the unflattering ones (a depth-capped tic-tac-toe search can still drop a game; the 2048 solver reaches the 2048 tile ~70% of the time, 4096 ~30%, and never 8192 in my runs). The full benchmark write-up and the reproducible harness are linked from the canonical post.

Why vanilla JS

Zero dependencies means the whole thing ships as a static file, runs entirely in the visitor's browser, loads instantly, and never phones home. For small games that's not a constraint — it's the right call.

Full post, charts, and the "run it yourself" harness: https://lkforge.com/blog/game-ai-three-algorithms/

You can also play the 2048 solver (Hint names the best move; Auto-Play runs the whole strategy live): https://lkforge.com/games/2048/

How Much Does It Cost to Charge an Electric Car? I Ran the Numbers for 10 EVs

Lucian (LKB) — Thu, 30 Jul 2026 04:22:09 +0000

Originally published on the LK Forge blog, where the charts are interactive and you can plug in your own car and rate with the EV Charging Cost Calculator.

The honest answer to "how much does it cost to charge an electric car" is it depends — on your battery, your car's efficiency, and above all where you plug in. So I ran one transparent model across 10 popular EVs at three places you charge: at home, on a public Level 2 station, and on a DC fast charger. Here is what a charge actually costs, per full charge and per mile.

The savings are in the garage. Charging at home is where an EV is cheap to run — about 4.6¢ a mile for an efficient car. But at typical DC fast-charging prices the same car costs 13.0¢ a mile, and a big truck can top 27¢ — at or above what a 30-mpg gas car costs per mile. The road, not the car, decides the savings.

At home, a mile costs a few cents

Charged at home at $0.17 per kWh, every car here comes in under 10¢ a mile, and the efficient sedans sit near 4.6¢. The number tracks efficiency almost perfectly — the more miles a car gets per kWh, the less each mile costs. Heavy trucks use roughly twice the energy per mile of a Model 3, so they cost roughly twice as much to drive on the same electricity.

EV	Home cost per mile
Tesla Model 3 (RWD)	4.6¢
Chevrolet Bolt EV	4.8¢
Tesla Model Y	5.1¢
Nissan Leaf	5.4¢
Hyundai Ioniq 5	5.6¢
Kia EV6	5.6¢
Ford Mustang Mach-E	6.3¢
Volkswagen ID.4	6.3¢
Rivian R1T	8.2¢
Ford F-150 Lightning	9.4¢

Where you charge matters more than what you drive

The rate per kWh is the biggest lever on cost, and it swings hard by location. Public Level 2 typically runs around $0.30 per kWh and DC fast charging around $0.48 — roughly 2.8× the home rate. That multiplier lands on every mile:

EV	Home ($0.17)	Public L2 ($0.30)	DC fast ($0.48)
Tesla Model 3 (RWD)	4.6¢	8.1¢	13.0¢
Ford Mustang Mach-E	6.3¢	11.1¢	17.8¢
Ford F-150 Lightning	9.4¢	16.7¢	26.7¢

For comparison, a 30-mpg gas car at $3.50 a gallon costs about 11.7¢ a mile. Home charging beats it comfortably for every EV here; DC fast charging meets or exceeds it for most. That is the practical takeaway: an EV is cheapest when you charge slowly overnight and treat fast charging as the convenience it is.

The full 10-car table

Full charge is a 0–100% home charge at $0.17/kWh; the per-mile columns use $0.17 (home), $0.30 (Level 2) and $0.48 (DC fast) per kWh, all at 90% charging efficiency.

EV	Battery	mi/kWh	Full charge	Home	L2	DC fast
Tesla Model 3 (RWD)	57.5 kWh	4.1	$10.86	4.6¢	8.1¢	13.0¢
Chevrolet Bolt EV	65 kWh	3.9	$12.28	4.8¢	8.5¢	13.7¢
Tesla Model Y	75 kWh	3.7	$14.17	5.1¢	9.0¢	14.4¢
Nissan Leaf	60 kWh	3.5	$11.33	5.4¢	9.5¢	15.2¢
Hyundai Ioniq 5	77 kWh	3.4	$14.54	5.6¢	9.8¢	15.7¢
Kia EV6	77 kWh	3.4	$14.54	5.6¢	9.8¢	15.7¢
Ford Mustang Mach-E	88 kWh	3.0	$16.62	6.3¢	11.1¢	17.8¢
Volkswagen ID.4	82 kWh	3.0	$15.49	6.3¢	11.1¢	17.8¢
Rivian R1T	135 kWh	2.3	$25.50	8.2¢	14.5¢	23.2¢
Ford F-150 Lightning	131 kWh	2.0	$24.74	9.4¢	16.7¢	26.7¢

How to work out your own cost

Every number here comes from two lines of arithmetic. To top up from one state of charge to another, the energy that reaches the battery is the battery size times the percentage added; you pay for a bit more than that because of charging losses. Then multiply by your rate:

Charge cost = (battery kWh × percent added) ÷ efficiency × rate per kWh
Cost per mile = (rate per kWh ÷ efficiency) ÷ miles per kWh
Assumed rates: home $0.17, public Level 2 $0.30, DC fast $0.48 per kWh
Assumed efficiency: 90% (wall to battery); battery and mi/kWh per the table above

These are illustrative assumptions, not measured field data — charging losses, network pricing and driving conditions vary. Plug in the rate from your own bill or charger for an exact figure with the EV Charging Cost Calculator, or estimate your whole monthly bill with the Electricity Bill Calculator.

How Random Is a Random Word Generator?

Lucian (LKB) — Sat, 25 Jul 2026 19:31:55 +0000

This was originally published on the LK Forge blog, where the charts are interactive.

"Random" is a claim, not a given — a generator that quietly favors a handful of words isn't random, it's just unpredictable-looking. We ran 20,000 seeded draws against our Word Generator's default word pool and tested the results with a chi-square goodness-of-fit test to find out whether every word really does have an equal shot.

Across 20,000 draws from the 365-word default pool, the generator samples uniformly: chi-square = 320.572 on 364 degrees of freedom, giving p = 0.9509 — far above the 0.05 threshold for suspecting bias. No word in the pool is favored or starved over the other 364. Statistically, it's fair.

The numbers


Draws sampled	20,000
Chi-square p-value	0.9509
Words in the default pool	365
Expected draws per word	54.8

Is the sampling fair?

A chi-square goodness-of-fit test compares observed draw counts against what a perfectly uniform sampler would produce. With 20,000 draws spread across a 365-word pool, each word should show up about 54.8 times on average if every word is equally likely — that's the expected count per cell, comfortably above the rule-of-thumb minimum of 5 needed for the test to be valid without merging cells. The null hypothesis is "every word is equally likely to be drawn."

The observed chi-square statistic came out to 320.572 against 364 degrees of freedom (pool size minus one), which converts to a p-value of 0.9509. Because that p-value sits far above the 0.05 significance threshold, we fail to reject the null: the deviations we see between words are consistent with ordinary sampling noise, not favoritism. That's the whole "how random" verdict — it says nothing yet about what the generated words look like, which is a separate question below.

What a generated word looks like

This next chart is descriptive, not a randomness test: it compares how often each letter appeared across the 20,000 generated words against how often that letter appears in general English text. It answers "what does the output look like," while the chi-square test above answers "is the sampling fair." The two questions are independent — a generator can sample its pool with perfect uniformity while that pool's letter mix still differs from English at large, because the pool's word list, not the RNG, decides which letters show up.

The widest gap belongs to H: it makes up just 2.5% of letters in the generated words but 6.094% of general English text, a 3.594-point difference. That's a fact about which 365 words happen to be in this pool — plenty of them are short and H-light — not a sign of anything skewed in how those words get picked. The chi-square test above already confirmed the picking itself is uniform.

How long are generated words?

Same caveat as above: this is a description of the pool's word lengths, not a randomness measurement. Across the 20,000 draws, 6-letter words came up most often (7,190 times), closely followed by 5-letter words (6,791), with a sharp drop-off at the short end (178 three-letter words) and the long end (48 nine-letter words). That shape simply mirrors how many words of each length exist in the 365-word pool — draw uniformly from a pool with more 6-letter words than 3-letter words, and 6-letter results will naturally come up more.

What this study does — and doesn't — cover

This study characterizes one thing: the generator's default pool, the 365-word list you get with the Word type filter left on "Words." The Word Generator also ships 8 specialty category lists reachable from that same dropdown — Animals, Birds, Colors, Compound Words, Elements, Flowers, Prepositions, and Spanish Words — each drawing from its own separate word list. None of those 8 lists were sampled or tested here, and this study makes no claim about their sampling fairness or letter/length makeup. Every figure above describes the default pool only.

A seeded stand-in for Math.random()

The live Word Generator draws with JavaScript's built-in Math.random(), which isn't seedable — running it twice gives two different outcomes, so it can't be independently reproduced. For this study we substituted a seeded pseudorandom generator, mulberry32, initialized with seed 42, so anyone can re-run the exact same 20,000 draws and get the exact same chi-square result. That substitution measures the distribution the generator's sampling mechanism (a Fisher-Yates-style draw from the pool) produces, not the specific bit sequence of the browser's own random number source — the sampling logic under test is identical either way, only the source of randomness feeding it changes for reproducibility.

Reproduce it yourself

The harness is public and deterministic — one script that runs mulberry32 (seed 42) through 20,000 draws in 400 batches of 50 against the generator's shipped default 365-word pool, printing the chi-square statistic, p-value, letter-frequency table, and length distribution.

Random word generator randomness harness (public gist)

Every number on this page is printed by that one script. Run it yourself to check any figure above to the exact digit.

The interactive charts are on the LK Forge blog.

Try the tool: Word Generator

WWF vs Scrabble Scoring — Where the Two Games Diverge

Lucian (LKB) — Sat, 25 Jul 2026 19:23:36 +0000

This was originally published on the LK Forge blog, where the charts are interactive.

Words With Friends and Scrabble share a board concept but value letters differently. We scored all 172,835 words in the ENABLE open word list — not the TWL or CSW/SOWPODS Scrabble dictionaries, just the open list — against both letter-value tables. agammaglobulinemic scores 41 points in Words With Friends against 30 in Scrabble, an 11-point swing. Hunt the other direction and the biggest Scrabble edge you can find, on dysrhythmia, is only −3.

That ceiling isn't a coincidence. Only two letters — H and Y — are worth more in Scrabble than in WWF. Ten others (B, C, G, J, L, M, N, P, U, V) are worth more in WWF. So no word can lean on a Scrabble advantage the way it can lean on a WWF one. Across the full list, 8.02% of words (13,862) score identically either way.

The numbers


ENABLE words scored	172,835
Score identically	8.02% (13,862)
Mean absolute point gap	2.528
Widest WWF vs Scrabble swing	+11 / −3

How far scores diverge

Delta is a word's WWF score minus its Scrabble score. A delta of 0 means the two games agree; positive means WWF pays more; negative means Scrabble pays more. Across all 172,835 ENABLE words the mean absolute delta is 2.528 points, and the distribution is lopsided — it stretches out to +11 on the WWF side but stops cold at −3 on the Scrabble side.

Why the gap is lopsided

The asymmetry traces straight back to the two letter-value tables. Compare them letter by letter and B, C, G, J, L, M, N, P, U and V are all worth more in WWF than in standard Scrabble scoring — a long list of common consonants and vowels quietly worth extra points there. Going the other way, only two letters, H and Y, are worth more in Scrabble than in WWF. Every other letter is valued identically. That's why a word stuffed with B's, C's, and M's can pile up a double-digit WWF lead, while the best a word can do by leaning on H and Y is claw back three points.

That single structural fact explains the whole shape of the histogram above: a tall, wide right side (WWF-favoring deltas run from +1 all the way to +11) and a short, thin left side (Scrabble-favoring deltas can't go past −3 because H and Y are the only levers available, and most words only carry one or two of either).

The widest gaps

The 15 widest swings in each direction are all long, uncommon words — the kind of vocabulary that shows up only when a rack forces an unusual play, but a clean illustration of how far the tables can pull apart.

Where WWF scores highest over Scrabble:

Word	WWF	Scrabble	Δ
agammaglobulinemic	41	30	+11
agammaglobulinemia	38	28	+10
agammaglobulinemias	39	29	+10
circumambulating	37	27	+10
counterinfluencing	36	26	+10
immunoglobulin	31	21	+10
immunoglobulins	32	22	+10
macroglobulinemic	38	28	+10
noncommunicating	35	25	+10
uncommunicable	34	24	+10
unconvincingness	34	24	+10
unconvincingnesses	36	26	+10
bejumbling	33	24	+9
buckminsterfullerene	42	33	+9
buckminsterfullerenes	43	34	+9

Where Scrabble scores highest over WWF:

Word	WWF	Scrabble	Δ
dysrhythmia	23	26	−3
dysrhythmias	24	27	−3
hasheesh	14	17	−3
hasheeshes	16	19	−3
hashhead	15	18	−3
hashheads	16	19	−3
hashish	13	16	−3
hashishes	15	18	−3
heathery	14	17	−3
heathy	12	15	−3
hexahydrate	25	28	−3
hexahydrates	26	29	−3
heyday	13	16	−3
heydays	14	17	−3
heydey	13	16	−3

Notice the pattern in the Scrabble-favoring column: every entry carries at least one H or Y, and several stack more than one — dysrhythmia repeats both letters (two H's, two Y's) and hexahydrate repeats the H. That repetition isn't a coincidence given the letter-value gap above; it's the only route to a negative delta at all.

What this means at the board

In practice, this means a word finder that only scores Scrabble-style is quietly under-counting nearly every real Words With Friends play. Racks heavy in B, C, G, J, L, M, N, P, U, or V are worth chasing harder in WWF than a Scrabble instinct would suggest, while H and Y give a small but real edge back to Scrabble players comparing the same word. It's also why the same rack can produce a different "best play" depending on which game you're actually in — the ranking, not just the total, can flip.

That's the reason the Words With Friends Cheat shows both a WWF badge and a Scrabble badge on every result — sorting by the wrong one costs real points, and the two numbers on this page show exactly how much.

About the Scrabble and Words With Friends references

SCRABBLE and Words With Friends are referenced here only descriptively, as the source of their public letter-value tables — public reference points for comparison, not an official analysis by either trademark holder. Both are trademarks of their respective owners; this post is not affiliated with, endorsed by, or sponsored by either.

Reproduce it yourself

The harness is public and deterministic — one script scores every word in the shipped ENABLE list (172,835 words) against both the Scrabble and WWF tile-value tables and records the delta.

WWF vs Scrabble scoring harness (public gist)

Every number on this page is printed by that one script. Run it yourself to check any figure above to the exact digit.

The interactive charts are on the LK Forge blog.

How Long Is Golden Hour? We Measured It for 27 Cities

Lucian (LKB) — Sat, 25 Jul 2026 19:20:13 +0000

This was originally published on the LK Forge blog, where the charts are interactive and every city links to its live local time.

Golden hour is almost never an hour. Photo apps and calendars round it to a flat 60 minutes, but that number isn't measured — it's a convenience. Using the NOAA solar-position algorithm, we computed the real duration — sun between +6° and the horizon, evening — for 27 cities across three dates in 2026. It's shorter than advertised almost everywhere, and it never reaches an hour.

The numbers


Shortest golden hour	24 min — Singapore, equinox
Longest in the set	57.6 min — Berlin, Dec solstice (still under an hour)
Average at the March equinox (27 cities)	30.2 min
Longer at 52°N than at the equator (equinox)	1.7×

The 60-minute golden hour is a myth. At the March equinox not one of these 27 cities reaches 45 minutes — the average is about 30.2 minutes.

Golden hour gets longer as you leave the equator

Sorted by absolute latitude, the equinox golden hour lengthens almost monotonically from the equator to the highest-latitude city in the set — Singapore at 24 minutes up to Berlin at 39.6 minutes.

Shortest at the equinox, longest in winter — and the swing grows with latitude

Near the equator the swing is barely there: Singapore moves from about 24 minutes at the equinox to 26 at either solstice, under three minutes across the whole year. London, at 51.5°N, swings much further — about 39 minutes at the equinox stretching to roughly 55 minutes at the December solstice. Sydney sits in the southern hemisphere, so its calendar flips: golden hour peaks at Sydney's own winter solstice in June (about 34 minutes), not in December. The pattern holds throughout this dataset — higher latitude means a bigger seasonal swing.

Why latitude decides golden-hour length

Near the equator the sun drops toward the horizon almost vertically, so it crosses the +6°→0° elevation band quickly — golden hour in Singapore lasts about 24 minutes at the equinox and barely moves across the year. Toward the poles the sun descends at a shallower angle, so the same band takes longer to cross. London's equinox golden hour runs about 39 minutes, stretching to roughly 55 minutes at the December solstice; Berlin, at a similar latitude, peaks near 58 minutes in December — the longest in this dataset.

The low winter sun is why the winter solstice produces the longest golden hour of the year in this dataset, not midsummer — a small margin near the equator, where the seasonal swing is barely a minute, but a gap of several minutes at higher latitudes, like London's roughly 55 minutes in December against 47 in June. Even so, every city here — up to Berlin's 52.5°N — stays under an hour. Golden hours that genuinely exceed 60 minutes need latitudes above roughly 60°N, places like Reykjavík or Anchorage, beyond the reach of this 27-city set.

The full 27-city dataset

Every figure below is minutes of golden hour, evening, sun between +6° and the horizon.

City	Lat	Equinox	Jun solstice	Dec solstice
Singapore	1.35°	24 min	26.2 min	26.2 min
Manila	14.6°	24.8 min	27 min	27.4 min
Bangkok	13.76°	24.7 min	26.9 min	27.3 min
Hyderabad	17.39°	25.2 min	27.5 min	27.9 min
Mexico City	19.43°	25.5 min	27.8 min	28.4 min
Hong Kong	22.32°	26 min	28.4 min	29.1 min
Riyadh	24.71°	26.4 min	29 min	29.8 min
Dubai	25.2°	26.5 min	29.2 min	30 min
Miami	25.76°	26.7 min	29.3 min	30.2 min
Houston	29.76°	27.7 min	30.6 min	31.7 min
Atlanta	33.75°	28.9 min	32.2 min	33.7 min
Los Angeles	34.05°	29 min	32.4 min	33.9 min
Tokyo	35.68°	29.6 min	33.2 min	34.8 min
Lisbon	38.72°	30.8 min	34.8 min	37 min
Madrid	40.42°	31.6 min	35.9 min	38.4 min
New York	40.71°	31.7 min	36.1 min	38.6 min
Istanbul	41.01°	31.9 min	36.3 min	38.9 min
Chicago	41.88°	32.3 min	37 min	39.7 min
Toronto	43.65°	33.2 min	38.4 min	41.6 min
Seattle	47.61°	35.7 min	42.2 min	46.9 min
Paris	48.86°	36.6 min	43.6 min	49.1 min
London	51.51°	38.7 min	47.2 min	54.8 min
Amsterdam	52.37°	39.5 min	48.6 min	57.1 min
Berlin	52.52°	39.6 min	48.8 min	57.6 min
Sydney	-33.87°	28.9 min	33.7 min	32.3 min
Buenos Aires	-34.6°	29.2 min	34.2 min	32.6 min
Auckland	-36.85°	30 min	35.6 min	33.8 min

Reproduce it yourself

The harness is deterministic and public. It's one script — the NOAA low-precision solar-position algorithm — run against the same 27 cities and three dates (March equinox, June & December solstices, 2026), printing golden hour as the time the sun spends between +6° elevation and the horizon, evening.

Golden-hour harness (public gist)

Every number on this page is printed by that one script. Run it yourself to check any figure above to the exact digit.

The interactive charts and per-city live local time are on the LK Forge blog.

The ENABLE Lexicon Study — Letter Frequency vs Scrabble Tile Values

Lucian (LKB) — Sat, 25 Jul 2026 11:03:59 +0000

This was originally published on the LK Forge blog, where the charts are interactive.

Scrabble's tile values were set in the 1930s by counting letters on a newspaper page. We counted every letter across all 172,835 words in the ENABLE open word list — not the TWL or CSW/SOWPODS Scrabble dictionaries, just the open list — to see how well those 90-year-old values still line up with usage. They don't, in eleven places.

C is the 10th-most-common letter in English word-stock, yet Scrabble scores it 3 points — more than the 1-point U it outnumbers. Eleven letters carry a tile value that doesn't line up with how often they actually appear.

The numbers


ENABLE words analyzed	172,835
Tile value / frequency inversions	11
Letters in the longest isograms	15
More words start with S than X	139×

How often each letter actually appears

Frequency here is occurrences per 1,000 letters: every letter of every word counted, divided by the total letter count, times a thousand. E leads at 115.1 per 1,000, S is second at 95.2, I third at 90.1. Q and J tie for last at 1.6.

Where value and frequency diverge

Butts set higher values for rarer letters, so by design tile value roughly tracks how uncommon a letter is — a rough stand-in for how hard it is to play. Across the full ENABLE list that alignment holds at the extremes (E is common and worth 1; Q and Z are rare and worth 10) but breaks down in the middle. The harness finds all 11 inversions — every case where a higher-value letter is actually more common than a lower-value one. Here is the complete list:

More common (tile value)	Rarer, but lower-value (tile value)	Frequency (per 1,000 letters)
H (4 pt)	B (3 pt)	H 23.2 vs B 18.4
C (3 pt)	D (2 pt)	C 40.9 vs D 33.8
C (3 pt)	G (2 pt)	C 40.9 vs G 27.0
C (3 pt)	U (1 pt)	C 40.9 vs U 32.7
D (2 pt)	U (1 pt)	D 33.8 vs U 32.7
M (3 pt)	G (2 pt)	M 28.4 vs G 27.0
P (3 pt)	G (2 pt)	P 29.4 vs G 27.0
K (5 pt)	W (4 pt)	K 8.5 vs W 7.4
Q (10 pt)	J (8 pt)	Q vs J — 2,536 vs 2,497 uses*
Z (10 pt)	J (8 pt)	Z 4.7 vs J 1.6
Z (10 pt)	X (8 pt)	Z 4.7 vs X 2.9

* Q and J both round to 1.6 per 1,000 letters, so the ranking uses exact counts: Q edges J on raw usage (2,536 vs 2,497) across the 172,835 words.

The single cleanest example is H against B: H is worth a full point more, but shows up more often across the lexicon. If tile values were re-derived from ENABLE frequencies today, several 3- and 4-point consonants — C, H, M, P — would come out lower.

The longest words with no repeated letter

An isogram is a word in which no letter repeats. The longest in ENABLE are exactly 15 letters — and there are only two of them: dermatoglyphics and uncopyrightable.

The most anagram-rich letters

Group every word by its sorted letters and one set wins: the five letters A, E, P, R, S rearrange into 12 different ENABLE words — apers, apres, asper, pares, parse, pears, prase, presa, rapes, reaps, spare, spear.

Letters	Words	The words
A E P R S	12	apers, apres, asper, pares, parse, pears, prase, presa, rapes, reaps, spare, spear
A E L R S T	11	alerts, alters, artels, estral, laster, ratels, salter, slater, staler, stelar, talers
A E L S T	10	least, setal, slate, stale, steal, stela, taels, tales, teals, tesla
A E I N R S T	9	anestri, antsier, nastier, ratines, retains, retinas, retsina, stainer, stearin

Which letter starts the most words

S runs away with it: 18,988 ENABLE words start with S. At the other end, only 136 start with X — a spread of roughly 139 to 1.

About the Scrabble reference

SCRABBLE is referenced here only descriptively, as the source of the standard English tile-value set — a public reference point for comparison, not an official Scrabble analysis. SCRABBLE is a trademark of its respective owners; this post is not affiliated with, endorsed by, or sponsored by the trademark holder.

Reproduce it yourself

The harness is public and deterministic — one script against the shipped ENABLE list (172,835 words), printing frequency per 1,000 letters, tile-value inversions, isograms, anagram-richest sets, and starting-letter counts.

ENABLE lexicon harness (public gist)

Every number on this page is printed by that one script. Run it yourself to check any figure above to the exact digit.

The interactive charts are on the LK Forge blog.

How to Find & Learn the Constellations: A Beginner's Guide

Lucian (LKB) — Thu, 23 Jul 2026 17:34:24 +0000

This guide was originally published on LK Forge, where it links to a free interactive sky map and a live planetarium you can match to tonight's sky.

The constellations can feel like a secret code — dozens of faint patterns scattered across the sky with no obvious place to start. The trick is that you don't learn them one by one. You learn a handful of bright, unmistakable signpost shapes first, then use them to star-hop to everything else. This guide shows you the signposts, the hops that connect them, and which constellations are up in each season — all with the naked eye, no telescope required.

Key takeaway: Learn just three signpost constellations first — the Big Dipper, Orion and Cassiopeia — and you can star-hop your way to almost everything else in the night sky.

You don't need a telescope

Constellations are big — many stretch across a span of sky wider than your outstretched hand. A telescope shows only a tiny patch at high magnification, which is exactly the wrong tool for spotting a large pattern. Your eyes are perfect for the job. To give them the best chance:

Let your eyes dark-adapt for 15–20 minutes — avoid looking at a bright phone screen during that time.
Use a red light (or your phone's red-tint mode) to read a map without ruining your night vision.
Get away from direct streetlights if you can. Light pollution hides the faint stars, but the bright signpost stars punch through almost anywhere.
A darker sky helps, but you can learn the brightest constellations even from a city.

Start with a few signpost constellations

These three are the anchors most stargazers learn first. Once you can find them without thinking, the rest of the sky opens up.

The Big Dipper (Ursa Major)

Seven bright stars in the shape of a saucepan or plough. From most northern latitudes it never sets, so it's visible on almost any clear night — just at different angles through the year. It's the launch-pad for more star-hops than any other pattern.

Orion

The standout of the northern winter (and southern summer) evening sky. Look for three bright stars in a short, straight row — Orion's Belt — flanked by the brilliant stars Betelgeuse (reddish, upper-left) and Rigel (blue-white, lower-right). Nothing else in the sky looks quite like it.

Cassiopeia

A distinctive "W" (or "M") of five stars, sitting on the opposite side of the North Star from the Big Dipper. Like the Dipper, it's visible year-round from northern latitudes, so when the Dipper is low, Cassiopeia is high.

Star-hopping: how to find everything else

Star-hopping means drawing an imaginary line or curve through stars you already know to point at ones you don't. A few classics do most of the work:

Find the North Star: the two stars at the end of the Big Dipper's "bowl" (Dubhe and Merak) are the pointer stars. Draw a line up through them and it lands on Polaris, the North Star — the tip of the Little Dipper's handle (Ursa Minor).
Arc to Arcturus, then speed on to Spica: follow the curve of the Big Dipper's handle outward and it "arcs" to Arcturus, a brilliant orange star in Boötes. Keep going the same distance and you "speed on to Spica," the bright star of Virgo.
From Orion's Belt: extend the belt down and to the left to reach Sirius, the brightest star in the night sky (in Canis Major). Extend it up and to the right to reach orange Aldebaran in Taurus, and keep going to find the tiny, sparkling Pleiades star cluster.
The Summer Triangle: on summer evenings, three bright stars high overhead — Vega, Deneb and Altair — form a large triangle spanning the constellations Lyra, Cygnus and Aquila.

Which constellations are up? A season-by-season guide

The sky's cast changes through the year as Earth orbits the Sun, so different constellations dominate the evening sky each season. The table below is for the Northern Hemisphere, a few hours after sunset. Visibility shifts with your latitude, and in the Southern Hemisphere the seasons are reversed and many patterns appear "upside down."

Season (N. Hemisphere)	Prominent constellations	How to find them
Spring	Leo, Boötes, Virgo, Ursa Major (high overhead)	Arc off the Big Dipper's handle to Arcturus (Boötes), then on to Spica (Virgo). Leo's backwards question-mark "Sickle" sits nearby.
Summer	Cygnus, Lyra, Aquila, Scorpius, Sagittarius	The Summer Triangle (Vega, Deneb, Altair) rides high; Scorpius and Sagittarius sit low toward the south over the Milky Way.
Autumn	Pegasus, Andromeda, Cassiopeia, Perseus	Find the Great Square of Pegasus; Cassiopeia's "W" is high overhead, with the Andromeda Galaxy nearby.
Winter	Orion, Taurus, Gemini, Canis Major, Auriga	Orion's Belt points down-left to Sirius (Canis Major) and up-right to Aldebaran (Taurus). The brightest patch of sky all year.

Tips to actually remember the constellations

Learn a few at a time. Two or three new shapes per session sticks far better than trying to memorise a whole star chart at once.
Go out at the same time each week. You'll watch the same constellations drift a little westward night to night, which cements where they live.
Start with the brightest. The signpost stars and patterns show even in poor skies; save the faint constellations for darker nights once you have your bearings.
Use averted vision. To catch a faint star or cluster, look slightly to one side of it — the edges of your eyes are more light-sensitive than the centre.
Turn on the constellation lines. A planetarium view that draws the constellation figures and labels over the real sky lets you check a shape the moment you spot it — then turn the lines off and test yourself.

Common questions

How many constellations are there? There are 88 official constellations, defined by the International Astronomical Union (IAU). They divide the entire sky into 88 regions, so every star belongs to exactly one constellation. Only a few dozen are prominent enough to pick out easily by eye.

Do I need a telescope? No. Constellations are large patterns, so they are best seen with the naked eye — a telescope shows too small a patch to take one in. It only helps later, for zooming in on individual objects like the Moon, planets or star clusters.

What is the easiest constellation to find? For most of the Northern Hemisphere it is the Big Dipper — seven bright stars in a saucepan shape, visible most of the year. In northern winter, Orion is just as easy thanks to its belt.

Match this to the real sky

The fastest way to turn this into muscle memory is to compare it with the real sky. Open a sky map, find the signposts overhead right now, and trace the same star-hops on screen and above you. The free LK Forge Sky Explorer gives you an interactive deep-sky map to locate any object, plus a live planetarium view (powered by Stellarium Web) that draws the constellation lines and labels straight over the real sky for your location and time — so the exact patterns in this guide are marked out overhead right now. No account or sign-up.

Proving It's Actually Unbeatable: How I Benchmark a Game AI Before Publishing a Number

Lucian (LKB) — Mon, 20 Jul 2026 19:51:00 +0000

This was originally published on the LK Forge blog, where the charts are interactive and you can play the AI it talks about.

"Unbeatable" is a testable claim, not a marketing word. Before that word goes anywhere near the tic-tac-toe page, the shipped AI has to survive a headless self-play harness — the same functions the browser runs, played thousands of times with no human at the keyboard. Here is what that harness measured, including the part that didn't look good at first.

The counterintuitive result

A tic-tac-toe AI with an 87% win rate still lost games that the full-depth engine never would. "It's minimax, so it's unbeatable" is true at exactly one depth setting — and the only way to find which is to run every depth and count the losses.

The numbers


Tic-tac-toe games simulated	1,200
Losses recorded	0
2048 self-play runs	250
Nodes / opening (α-β)	36,528

Against 1,000 games of a random-move opponent, the AI went 825 wins, 175 draws, 0 losses. Against 200 games of the AI playing a perfect copy of itself, every game ended in a draw — the correct result for perfect tic-tac-toe play, and the harder claim to satisfy. Across both runs, 1,200 games total, the loss count is 0. That is the number the word "unbeatable" is actually standing on.

The harness

The benchmark is headless self-play: the exact move-selection functions from the shipped page, imported into a script with no DOM and no human, playing thousands of games back to back. A benchmark written against a re-implementation of the algorithm proves the algorithm is sound in theory; it says nothing about the code a browser actually executes. Pulling the real functions out of the production page means the numbers describe the shipped build, not a clean-room stand-in that happens to share a name with it.

It also has to be re-runnable. A number from one afternoon of manual play-testing is an anecdote; a script that plays 1,000 games and produces the same counts every time is a measurement. Mean move time came out at about 0.3 ms across 500 sampled positions.

Depth is the proof

The shipped engine searches to depth 9 — the full game tree for a 3×3 board — which is what guarantees the zero-loss result. To find out whether that depth is necessary, the harness re-ran the same 200-game vs-random test with the search capped at each depth from 1 to 9:

Search depth	Win % (vs random, 200 games)	Losses
1	86%	0
2	87%	2
3	90.5%	0
4	86%	0
5	83.5%	0
6	77%	0
7	85%	0
8	79%	0
9 (shipped)	81%	0

The honest finding is in the depth-2 row: at a search depth of 2, the AI lost 2 of 200 games. An 87% win rate looks fine on its own, until you notice the two losses hiding next to it. Depth 9 is the only depth with a 0-loss guarantee behind it; every shallower depth is a different, weaker program that happens to share the same UI.

That is the entire argument for benchmarking instead of reasoning from the algorithm's name. "It's minimax, so it's unbeatable" is true only at one specific depth setting, and the only way to know which is to run all of them and look for the losses.

The 2048 case

Tic-tac-toe has a small enough state space that "unbeatable" is checkable in an absolute sense. Most games don't — 2048 has no realistic path to "solved," so the only honest claim is a measured reach-rate: 250 headless self-play games with the shipped expectimax-plus-corner-snake solver.

A strength profile, not a single number — and one that would be indistinguishable from a coin flip if I'd run it 10 times instead of 250.

Reproduce it yourself

The harness is public and seeded, so runs are deterministic. Each file copies the shipped game code verbatim and drives it headlessly:

The benchmark harness (public gist)

node tictactoe-benchmark.mjs   # 549,945 -> 36,528 nodes, 0 losses, depth-2 loses 2
node 2048-benchmark.mjs        # reach-rate profile

The deterministic numbers (node counts, 0 losses at full depth, "only depth 2 loses") reproduce to the exact digit. The stochastic ones (win/draw split, 2048 reach %) reproduce as the same profile with seed-dependent variance. I also included the one number that didn't cleanly reproduce — a Color Lines pathfinding stat that turned out to be board-sampling-dependent — and documented why, rather than curve-fitting to hit it.

The rule this enforces

Benchmark before you publish a number. Any performance or strength claim has to come from a measurement that can be re-run, not a description of what the algorithm should do in theory. The depth-2 result is exactly the kind of thing that rule is for — a plausible-sounding claim ("it's minimax, it can't lose") that turns out to be depth-dependent, and would have shipped wrong without a script that actually played the games.

26 Repos in 29 Days With an AI Pipeline: What Actually Broke

Lucian (LKB) — Sun, 12 Jul 2026 14:20:35 +0000

This was originally published on the LK Forge blog, where the commit chart is interactive and you can play the AI games it talks about.

Between June 5 and July 3, 2026, I took an empty domain to 26 repositories, 1,549 commits, and 335 live pages — one developer, working with Claude Code. The interesting part isn't the volume. It's which failure modes showed up, because none of them were the ones the AI-coding debate argues about.

The numbers


Repositories	26
Days	29
Commits	1,549
Pages shipped	335

Commit cadence: ~53/day average, peak 122 on June 20, exactly one zero-commit day in the sprint. The two heaviest days at the tail (114 each) were a site-wide URL-structure migration — which is itself one of the failure stories below.

The setup

Deliberately boring: one developer, Claude Code in the terminal, git for everything, static-first architecture. Games and tools are self-contained repos of vanilla HTML/CSS/JS; the hub site is Astro. Everything deploys to Cloudflare Workers with static assets at the edge — no backend, no database, nothing to babysit at 3am.

Every session ran the same loop: describe the goal, let the model plan and build, review the diff, make it verify its own work against the live site, commit. That verification step is what earns its keep — every failure below was caught by a check, not by luck.

What the pipeline was genuinely good at

Working classical-AI engines, first try or close. The 2048 solver is real expectimax search with a corner-snake heuristic and adaptive depth. Before publishing any performance number, I ran the exact production code through 250 headless self-play games: it reaches the 2048 tile in 69.6% of games at ~0.5ms per move. The tic-tac-toe opponent is minimax with alpha-beta; the pathfinding in Color Lines is BFS. Textbook algorithms, correctly implemented, shipped in days. That part of the hype is real.

Volume with consistency. 335 pages sharing one brand system, one URL convention, one schema pattern. Once a convention was written into a project memory file, the model applied it across dozens of pages without drift. Those memory files turned out to be the highest-leverage artifact in the whole pipeline.

Audits at a depth a human won't sustain. Full link-graph crawls, redirect-chain verification across hundreds of URLs, per-page canonical checks against live HTTP. The model does the 400-URL tedium without getting bored — which matters, because tedium is where site-wide bugs hide.

What actually broke

Not one failure was a syntax error, a broken build, or code that didn't run. Every real problem was structural — invisible in any single diff, only visible when you look at the whole system.

1. The pipeline competed with itself

Asked for a word-tools hub, the pipeline built one — at /word-tools/, while the existing tools lived under /tools/. Two pages on the same domain targeting the same queries: textbook SEO cannibalization, self-inflicted. Search Console showed both URLs impressing for the same terms before I consolidated with a 301. Each page was locally correct; nobody was watching the query-level picture.

Lesson: the model optimizes the page you asked for, not the site you already have.

2. Twenty-six repos, two URL conventions, weeks of cleanup

Some tools were built as flat files (page.html), others as directories (page/index.html). On Cloudflare's asset serving those get opposite trailing-slash behavior — so the site accumulated canonical mismatches, two-hop redirect chains, and Search Console redirect errors. The fix consumed the two biggest commit days of the sprint and produced a written URL convention plus a pre-deploy crawl checker that now gates every release.

Lesson: conventions the model must follow have to be written before repo #2, not after repo #20.

3. Source and production drifted apart silently

Game repos are mirrored into the hub site for deployment. Over weeks, SEO improvements were applied to the production mirror and never back-ported to source. The trap armed itself: the obvious "sync" — copy source over mirror — would have silently destroyed live metadata. It was caught only because a diff-before-copy check is now mandatory.

Lesson: any two copies of the same file will diverge, and the AI won't notice unless a check forces the comparison.

4. The verification tools lied too

The first link-graph audit reported a wave of orphaned pages. False alarm: it compared absolute URLs against unresolved relative hrefs. A later canonical audit reported 123 mismatches — also false, because the checker assumed file paths equal serving paths, and the CDN serves clean URLs. In both cases the audit tooling — also AI-written — had the bug, and acting on its output would have "fixed" a healthy site into a broken one. Both caught the same way: probe the live site before believing static analysis.

Lesson: verify the verifier. An AI-written check inherits every blind spot of the AI that wrote it.

The economics: 93% of the cost was re-reading, not writing

The sprint produced 44 working sessions and 826MB of transcripts. When I audited the token bill, the headline wasn't generation cost: roughly 93% of token consumption was cached context being re-read, turn after turn, inside marathon sessions that should have been split up.

The mechanics are mundane. A long session accumulates giant context; every subsequent turn re-reads it; a session that drifts across three unrelated tasks pays the full history of tasks one and two as a tax on task three. The model never complains, so nothing forces you to notice.

The fix cost nothing: clear context between tasks, keep durable knowledge in small memory files, treat "one session = one task" as the default. If you run an AI coding workflow and have never audited where the tokens actually go, that single check is probably worth more than any prompt engineering.

What it earned (honest version)

Over the last 28 days the site drew 207 clicks from 7,320 impressions across 257 pages with search data. For a domain about five weeks old, that's a normal, healthy trajectory — and nobody's growth-hack screenshot.

The detail worth reporting: the single biggest click-earner after the homepage is the 2048 game with the visible AI solver — the page where the most genuine engineering lives. Search demand followed the depth, not the page count. 300 thin pages didn't beat one page with something real on it.

The rules that survived

Every one exists because its absence caused a real incident above. That's the only rule-making process that works.

Benchmark before you publish a number. If it isn't measured, it doesn't ship.
Diff before you copy. No exceptions for "they should be identical."
Probe live before believing static analysis. An audit result is a hypothesis until production confirms it over HTTP.
Write conventions down before scaling them — in a memory file the model loads every session, not in your head.
One session, one task. Context is the real cost center.
Check the whole site, not the diff. Cannibalization, drift, and convention splits are invisible at diff level.

The live version, the interactive commit chart, and the AI games are at lkforge.com. The 2048 solver writeup with the full benchmark is here.