Unformed Delta - recommended

For even a bad pause

Wed, 29 Apr 2026 06:51:00 +0000

Even a global treaty pausing all new training of frontier AI models, would leave a lot of room for existing models to continue to disrupt.

Our existing workflows weren’t designed with AI agents in mind and there’s abundant low hanging fruit for optimization. Every time I use Codex or Claude Code, I learn something new, and there’s plenty of things I just don’t have time to try.

Beyond code there’s plenty of other domains. Claude Cowork, the 10 folders of markdown files that caused the SaaSpocalypse, Claude Design, and more aren’t new models, they’re just harnesses for making it easier to work with existing ones.

What will be the impact on the economy once even our existing systems are widely adopted?

There’s a bunch of good things that we get for free by pausing AI progress.

The technology as it exists today would diffuse. The public lags behind what those of us interested in AI see.

More election cycles gives more opportunity for more informed and reasonable lawmakers to be elected. It also gives us room to negotiate and dream up better AI policies.

Nothing about pausing means AI safety research needs to stop. Who knows what novel problems or breakthroughs we might find in the next years?

Bernie Sanders and Alexandria Ocasio-Cortez’ AI Data Center Moratorium Act is just 1853 words — well worth reading all of.

Half of the bill is a sizzle reel of quotes from experts and industry leaders. The functional section of the bill is tiny:

154 words define “Artificial Intelligence Data Center”
287 words set the terms of the moratorium: no new AI data centers until AI is safe and built to be mutually beneficial for all Americans
275 words requisition various reports, and give the Secretary of Energy the power to verify that the moratorium is being followed
161 words ban the export of chips to countries not implementing similar measures

It’s a far cry from a global treaty. But it takes action now buying time and leverage to get a more comprehensive treaty implemented.

The bill cedes our largest advantage to China. Chinese models are only 3-9 months behind the US frontier, slowing down puts us at risk of losing the frontier.

This is costly, but perhaps might also serve as a signal. How can we better demonstrate our commitment to AI safety?

AI labs have frequently say that they want AI regulation. I also look at this bill as an invitation to the labs: help us figure out how to make AI mutually beneficial for society, and then you can go on building the data centers you want.

My largest quibble is with some of the most concrete details. To me one of the benefits of a sloppy pause are that it gives us time to contemplate what better legislation might look like. Enforcing that AI data center development be done with union labor while nice, seems far from necessary and I’d prefer a bill with less provisions about what is necessary to end the moratorium.

I’m confident that If Anyone Builds It, Everyone Dies. Will we be able to stop, or are the rewards from training better and better AI models too tempting? How long would it take us to stop even if policy makers unanimously agreed that we should?

Perhaps we should slow down as much as we can now.

I don't want your skills

Sat, 25 Apr 2026 04:03:00 +0000

I often notice people advertising their custom skills as a solution to your agentic programming problems. They’ll provide you some genuinely useful advice, then cap it off by offering you skills that operationalizes their advice.

I found the failure modes and tips identified in Software Fundamentals Matter More Than Ever insightful. I never thought about having a glossary of shared vocabulary to make communication with AI agents more effective. AI agents outrunning their headlights by doing way too much autonomously provides metaphor for my common experience of having AI agents do underspecified work. Focusing on building deeper modules with a lot of functionality hiding behind a small interface, is a pattern I’ve been thinking around, but haven’t yet been able to put words to.

But following the insight with skills that will “solve” the problem for you, is the equivalent to giving a tutorial on how to implement nanoGPT and then capping it off by saying: but you can just use https://chatgpt.com¹.

Yes, it does seem helpful to have my AI agent /grill-me — asking detailed questions instead of providing corrections to plans reflecting a fundamental misunderstanding of the problem over and over again. Of course, I’d love to /improve-codebase-architecture modularizing my codebase. But running a skill won’t help you understand how it works.

These skills probably work in simpler codebases. But simpler codebases are also the best environment to understand the principles behind the skills and learn how to build them yourself. And without understanding the principles, you won’t necessarily understand that or how the skill failed in a more complex codebase.

I’ve noticed this pattern before in discussions with other engineers. I explained to another engineer: just giving Claude Sonnet 4.5 our feature flag documentation plus a list of files that needed to modify was enough for it to make the changes fully autonomously. They responded by asking if I could package that up into an /add-feature-flag skill.

I didn’t see the point. The skill would just be 1-2 sentences of text and a list of files that needed to be modified in order to make changes to the feature flags. The skill would encapsulate nothing but the fact that this task was now easy to automate.

My recommendation is to engage with content that offers you skills, but try to learn the principles behind the skills instead of using the skills themselves. Try to prompt your AI agent to solve the problem yourself.

Doing this, I’ve found that after a while, I want to abstract my prompt into my own skill.

I remember reading an article about adding comments to plan documents inline, instead addressing them one by one in Claude Code’s prompt. I liked this technique and after trying it, ended up building produced this skill. Though I’ve provided a link, I recommend not clicking it.

Downloading skills won’t make you a good AI engineer. Understanding why they work and operationalizing the principles behind them will.

Andrey Karpathy does not do this. ↩

programming language features (and optimizations)

Fri, 24 Apr 2026 00:12:00 +0000

My dream programming language would be able to express the syntax and semantics of every other programming language idiomatically. In this framing a good programming language would have few builtins¹ but would still be able to manifest many more specific features as library definitions.

I take a very general view of features. Optimizations are included in this list because in order practically exploit the fact that one programming can express the semantics of another, it must be able to match its performance². Thus optimizations are more or less “features” for a programming language; they help determine what the programming language can practically be used for.

Maximizing which features are expressible as part of the standard library, maximizes what users are able to rewrite. If users don’t like the features the language provides in its standard library they can write their own. Such a language is maximally flexible for users.

Of course, actually using custom built features comes at the expense of interoperability with the broader ecosystem. But I think it is better to give users the choice of what they need to interoperate with, rather than artificially restricting it to guarantee good interoperability³.

With a sufficient floor of metaprogramming capabilities, any feature could be implemented as a builtin or as part of the standard library. I collect this list so that I can sort/consider which features are more primitive and which are the most useful to be able to reprogram. Each programming language features thus becomes both a test and an axiom for programming language expressivity.

Meta note: I went through and made a bunch of these notes public. There’s still a lot of links that aren’t public. A lot of the pages themselves are stubs and have highly varying levels of research/detail/revision put into them.

meta programming

Features enabling and enabled by metaprogramming. In some sense these are the most important because they’re what enables implementing features in terms of each other. I’m also interested in evaluating which of these features are the most irreducible.

Features providing metaprogramming ability:

Features implementable by metaprogramming:

embedded query languages, e.g. LINQ
EDSLs in general get better as metaprogramming is better supported by a programming language

Features kind of like metaprogramming in terms of the expressiveness they provide:

working with (generally monadic) effects

This category encapsulates language features that make working with effects easier:

do notation
monad extraction
idiom brackets
lifted versions of boolean operators
dedicated syntax for specific effects
pattern match failures are an effect / parsers via pattern matching
the runtime system should be deeply tied to effect system
Implicit Conversions Between Effects
See also: Effects

working with coeffects

method (/with) notation: relatively undeveloped, but interesting
coeffects can act as interpreters for effects: vague but interesting, method notation has some extra ideas for this
See also: coeffects / consumer effects

concurrency / distributed programming

Working with data

pattern matching:

Accessors / key paths / lenses:

generic/uniform syntax for arbitrary n-functors/lenses

optimizations

evaluation order

types

Primitive types:

basic types: closed vs open types
- structs/record types
- row types (i.e. extensible records)
- coproducts / variants / enums
- polymorphic variants
- recursive (µ) types
- nominative (ν) types
- algebraic data types
dependent types:
- dependent product
- dependent sum
- interval / cubic type theory / univalence
- cumulative universes
linear types

Broader concepts:

type inference (+ list of methods) / elaboration
completeness checking
subtypes / subtyping
structural types
gradual typing / migratory typing
pure functions, mutability
- ST monad

Weird/highly non-standard stuff:

dual type operator
co-completeness checking
self types
Lambda with receiver
probably not practical or interesting: representing types as just namespaces

typeclasses / traits

Typeclass features:

standard library

The main purpose of a standard library is to define the shared vocabulary that all programs can coordinate around. Because more primitive features are implemented as part of the “standard library”, it places an even larger burden on the design of its standard library.

Properties the standard library should have:

layers of primitiveness: that allow giving up progressive amounts of interoperability for the ability to redefine larger parts of the language
facilitate migrations between standard library types to make the decision to include/not-include various things as unimpactful as possible

Must haves:

type safe dates/times/durations
OSString type
theorem proving:
- explicitly unordered containers

Things to consider adding to a type class hierarchy beyond what Haskell has:

modules / scoping

lifetimes / scoping

RAII
defer statement
deconstructors / deinitializers
lifetime annotations ala rust
borrow checker
move semantics (e.g. consume in Swift)

control flow

implementing control flow as library functions
loops:
- for loops
- foreach loops
- while loop
- until loop
- do while loop
- unconditional forever loop
- do while with block loop
if statements
switch / case analysis statements
allowing statements to be used as expressions
defer statement
try { … } catch { … }

Dis-preferred:

code location / relocating code

removing indentation from nested code structures
unit tests can be co-located with code
get calling function location
defer statement is useful for putting de-initialization next to initialization logic

testing

unit tests can be co-located with code
inspection testing
unit tests can be discovered at compile time / in the IDE without necessarily running arbitrary code

My Neovim configuration

Thu, 23 Apr 2026 06:02:00 +0000

I use Neovim for 95%+ of my writing, both prose and code. I originally picked Vim over Emacs because I liked its modal text editing. Over the following years I’ve honed it to my preferences, building up over ~4000 lines of configuration. I’ve flirted with switching to Emacs with evil-mode for a better plugin ecosystem, but Vim is too deeply engraved in my muscle memory to move away from.

Lua vs Vimscript

I don’t have a strong preference for Lua/Vimscript. Historically, Vimscript was the only language for configuring Vim¹ . I generally assume that I will always use Neovim nowadays. Neovim makes Lua a first class language for configuring Vim. In fact, in addition to bridging all of Vim’s APIs to Lua, new APIs (such as vim.lsp) are often only offered through Lua.

Rewriting all of my configuration in Lua just to lose support for Vim completely seems like a waste of time, so I still keep a lot of my configuration in Vimscript. I tend to prefer Vimscript’s syntax for mappings and autocommands to Lua’s anyways. Lua’s feels a little bit too verbose, and is harder to understand quickly in my opinion.

Neovim makes it very easy to mix Lua and Vimscript, which makes it possible to maintain interoperability even while maintaining configuration in both.

Escape key

Because the escape key is far in the top left corner of modern keyboards, mapping jj or jk to escape in insert mode is fairly common. I used to do this. At some point I learned that Vim and most Vim plugins for other text editors treat <C-[> as escape. Rebinding caps lock to control system wide, made it possible to press <C-[> with my two pinkies simultaneously. An escape key mapping was previously the only configuration I truly couldn’t do without so this has the added benefit of letting me use Vim-mode plugins in other editors (or Vim itself through SSH) well enough without needing to configure them.

Modularization

Because my config has grown quite large, I need to keep it modularized for it to stay maintainable.

Mostly I rely on the runtime directory structure which allows loading a lot of files flexibly:

init.vim has logic that needs to run before other configuration, plus a bunch of stuff that I’ve been too lazy to move elsewhere
plugins.vim is sourced from init.vim and loads plugins. I have this separated out because I use a lot of plugins
ftsyntax directories for autocommands improving file type detection, or adding new
ftplugin/after directories house language specific configuration to prevent needing to define autocommands for them
autoload directories store “library” functions that I use from other pieces of my configuration
lua/my modules serve the same purpose, but for Lua code
plugin directories for configuration insensitive to loading order

Plugins

I still use vim-plug to manage my plugins because it works well enough, and well written plugins lazy load by design, thus not requiring anything fancier.

I’m a heavy plugin user so I’ll only go through my favorite plugins. The most notable category is plugins that add generic cross language features to the editor without conflicting with default keybindings:

tpope/vim-repeat makes it possible to use . with custom actions provided by other plugins. This should really just be a built in Vim feature.
tpope/vim-sleuth makes indentation behave sanely by default.
tpope/vim-surround adds a truly essential ys/cs/ds text editing verbs for adding/changing/deleting surrounding text
tommcdo/vim-exchange provides a very useful cx text editing verb for swapping text
wellle/targets.vim adds extra text objects (e.g. for function arguments) and makes existing text objects more flexible (e.g. selecting the next instance of a text object if you aren’t already inside of it)

I use overcache/NeoSolarized for my color scheme because it’s the most modern true color Solarized color scheme that I could find. I use nvim-lualine/lualine + nvim-tree/nvim-web-devicons to make the UI a bit prettier.

For more IDE like features, I mostly rely on language servers, but some extra support is provided by plugins.

hrsh7th/nvim-cmp for autocomplete though I’m considering switching off this because it is now unmaintained
LuaSnip for snippets

Other than that, there’s pretty much just a bunch of syntax plugins.

I’ve also factored bits of my config as plugins (e.g. vim-magic-link-paste) plus a syntax plugin for moss-lang. A way to keep it easy to edit these even though they are no longer in my dotfiles repo is to branch on whether the repository exists on my computer:

if isdirectory($HOME.'/src/vim-magic-link-paste')
  Plug $HOME.'/src/vim-magic-link-paste'
else
  Plug 'lehmacdj/vim-magic-link-paste'
endif

This way, vim-plug won’t clone them, and I can edit the source and have it stay up to date automatically.

Making changes to configuration

I find being able to quickly navigate to a specific bit of configuration that I want to tweak important so that I’m able to fix problems / add new configuration without breaking my flow.

I use mappings that open up a configuration file in a split:

" Edit vimrc
nnoremap <Leader>ev <Cmd>split $MYVIMRC<CR>
" Edit plugins
nnoremap <Leader>ep <Cmd>split $VIMHOME/plugins.vim<CR>

My favorite is my one for editing language specific tweaks, it directly opens up the appropriate file for the current file type:

" Edit filetype file
nnoremap <expr> <Leader>ef '<Cmd>split '.$VIMHOME.'/after/ftplugin/'.&filetype.'.vim<CR>'

Language specific tweaks

I most frequently edit my language specific configuration when I’m learning a language, or using a language I haven’t edited in a while. Most commonly, language specific configuration is overrides for my global vim config like not converting tabs into spaces for Makefile or setting up soft wrapping for Markdown. I also include custom keybindings that are only relevant for particular file types, like publishing a note from my wiki.

Wiki specific stuff

For my notes specifically I have a custom language server that I use providing autocomplete + title transclusion from random ids + go to definition for navigating between notes. I rely heavily on conceal to keep markdown syntax hidden while reading notes in Neovim.

There also were remote plugins. But they require installing language runtimes, and have a more limited API than exposed through Vimscript. ↩

Metadata patterns not accounted for by music apps

Wed, 22 Apr 2026 06:34:00 +0000

I hesitated a lot when first getting into anime idol music. I was definitely a little self-conscious that the album art can get fairly suggestive.

13+ album art with characters wearing swimsuits

But more importantly I feared its complexity would render my music cluttered and unnavigable. I mostly engaged with my music navigationally as opposed to searching. I liked to select a genre, an artist within that genre, and then pick out an album within that genre to listen to. Instead of staring at an empty search field, wanting music for focusing, I could pick Soundtrack, evaluating that Joe Hisaishi (i.e. Ghibli Soundtracks) was chiller than John Williams (Star Wars), then Spirited Away, deciding Princess Mononoke was too gloomy and I needed a little more whimsy.

Idol music would seriously upset this balance. Many tracks were only available as singles, and — GASP — would need to learn to organize my music into playlists. But as listening to nightcore music on YouTube transitioned into watching Love Live! Sunshine’s Aqours’ lyrics videos, eventually I decided that the sanctity of my navigable music library would need to be broken, and started adding μ’s and Aqours music to my music library.

When I got tired of manually importing metadata I discovered beets, a command line tool that automatically tags music with MusicBrainz metadata. This kept my music organized, but once I was listening to a huge number of artists and franchises¹, navigability in my music player started to break down, none the less.

None of these matter when listening to an algorithm generated playlist on Spotify or YouTube Music. But regardless, I still have a strong desire to navigate — I think it helps me feel more intentional about my music listening.

Classical music once had a lot of similar problems, e.g. the same piece but separate recordings different orchestras/conductors. Eventually, Apple implemented better navigability through specialized services like Apple Music Classical.

These are the metadata patterns I want custom support for when Claude is able to build me a custom music app.

Character vs Voice actor

Each character is portrayed by a voice actor. Voice actors often also publish music as themselves, and sometimes the same voice actor portrays multiple characters². If I want to listen to music by a particular singer because I like their voice, I’d love to be able to jump to all of the music by the voice actor. YouTube Music/Spotify usually doesn’t even show the voice actor (it depends on the franchise).

Deep hierarchies

Because idol anime franchises are primarily a vehicle for selling merchandise for a huge number of characters, they end up with tons of characters sorted into different units (groups of characters that perform together). Idolm@ster is a particularly illustrative franchise³: it contains at least 8 sub-franchises, of which Idolm@ster Shiny Colors contains 8 units, of which Noctchill contains 4 members.

Overlapping hierarchies

Groups aren’t even static a lot of the time. In Idolm@ster Million Live, pretty much every new single features a never-seen-before unit. Fortunately, when credited as artist these units usually include list of their members, which makes it possible to find songs containing a particular character through search.

So fans are confident their favorite character will get a new song eventually, albums/singles are often sorted into series⁴. I often wish I could navigate between albums in the series while listening to music.

Tracks you typically don’t want to listen to

Albums often bundle tracks that don’t make to listen to typically. Most albums include karaoke tracks without vocals, plus there’s often also drama tracks with character story. These are sometimes interesting to listen to, but I don’t typically want my music listening to be interrupted by a podcast.

Beyond that there’s often variants of the same song: solo versions, short versions (i.e. ~1:30 versions used in rhythm games), and live recordings. MusicBrainz’s data model actually works fairly well for variants, linking recordings to a single song, but I haven’t found a music app that allows navigating these relationships.

Music apps aren’t able to filter these out for general listening, but still expose them when desired.

nayuta, Idolm@ster, Love Live!, Project SEKAI (especially More More Jump! and Nightcord at 25:00) are my favorites. I’ve even gone to a couple of live shows in Japan. ↩
Ruby Kurosawa and Airi Momoi’s voice actor are both Ai Furihata. ↩
https://project-imas.wiki is organizes all this complexity neatly. ↩
For example there are 7 albums in THE IDOLM@STER SHINY COLORS “CANVAS” series (just numbered 01 through 07). ↩

5 unexpectedly mindful activities

Sun, 19 Apr 2026 19:48:00 +0000

I’ve been increasingly interested in mindfulness over the past year, starting to meditate about ~2 months ago. Overall, it has been fairly transformative in terms of my qualitative stress and overall sense of well being. These are activities that didn’t seem mindful, but I ended up finding meditation like benefits in.

Playing Riichi Mahjong

I originally learned Riichi Mahjong at work. When Mahjong Soul added my favorite character from Idolm@ster Shiny Colors in a collab, I started to play online. At first, 5 seconds a turn felt like a tiny amount of time to identify patterns in a 14 tile hand and decide what tile to discard. But, as I got better, simpler hands became easy to play mechanically, and the extra time between turns made it easy for my mind to drift to other things.

But the game has a surprising amount of depth. Even if optimal tile efficiency becomes trivial, there’s room to improve by paying more attention to what your opponents are discarding, expected value calculations, and so on.

Ultimately Riichi Mahjong is still a heavily luck based game, and it’s unfortunately common to play perfectly, and still end up in last place. This creates a good opportunity for equanimity practice, by remaining composed while losing, you maximize your chances of making an extremely satisfying comeback.

Walking without listening to anything

When I first was getting interested in being more mindful, I was listening to something on my AirPods almost all of the time. I started to make an effort to only listen to podcasts or audiobooks intentionally. I started by designating transitions, such as entering a building AirPods free. At first, I frequently felt unproductive unproductive because I wasn’t ingesting information at every possible moment, and it was easy to slip into putting my AirPods and listening to something anyways. Eventually, I started to enjoy mindfully putting my shoes, and riding down the elevator before heading out for a walk. I now often notice I’m not actually enjoying what I’m listening to, and stop it, enjoying the rest of a walk in silence.

Brushing my hair

Almost any mundane activity can be done mindfully. Even boring chores like brushing my hair, washing dishes, or cleaning my apartment. If anything, the more boring the activity, the more space it provides for mindful reflection. Nowadays I mostly do these activities while listening to a podcast or music if I’m having trouble motivating myself to start doing them.

Just listening to a podcast or music

As I listened to less podcasts, audiobooks, and music while doing other things, I found there was still audio that I wanted to make time to listen to. Mindfully listening has helped me be more discerning of what I like best. For shorter pieces like songs, this 4 step attention procedure for listening is a good way to engage more deeply when desired.

Watching Yuru Camp

Laid back-camp (ゆるキャン), is a slice of life anime, focusing on high school girls going camping in and around Yamanashi prefecture (right around Mt. Fuji). Because it’s primarily slice of life, there isn’t much plot. Sometimes it features seconds of nature scenery montages and panoramas at the expense of character interaction. While watching season 1, I thought this made the show ideal for solving Jig-Saw Puzzles while watching the show. But mindfully watching the show gave me an even better experience. Watching one episode each night before bedtime gave me space to process my day and feel ready to go to sleep. After finishing the latest season, I still haven’t found anything that I like quite as much as a replacement.

Anything can be mindful

Anything can be done mindfully as long as it isn’t too stimulating or addictive. Find activities you don’t reach for compulsively but want to do anyways. Activities that you multitask while doing or do while multitasking can be good candidates. They leave your mind free enough to pursue them with more intention. Focusing on doing such activities often makes the activity feel more meaningful.

Dominion is the ultimate strategic deck-builder

Sun, 19 Apr 2026 03:19:00 +0000

In Hearthstone, Yu-Gi-Oh, Magic the Gathering, or really any TCG the winner of a match is sometimes predetermined before either player has taken their first turn. Control decks are hyperspecialized to clear the tiny minions produced by an aggro deck, then grind them out with more valuable cards. Aggro decks will usually swarm the board and beat down a combo deck player before they manage to set up their combo. Combo decks tend to beat control decks, setting up a rock paper scissors like meta-game.

This meta-game has immense strategic depth. Players consider the available pool of cards, and try to craft a deck with the best possible win rate. But another player could have a better win-rate by countering the straightforwardly best looking deck. Thus players must imagine the complete distribution of decks and balance using the most powerful cards, being resistant to being countered, and trying to counter their competition. This strategic depth of the meta-game has always been my favorite part of TCGs.

Dominion is a deck-building game that distills this meta-game into the game itself. Players start out with a deck with just 7 coppers and 3 estates, but throughout the game purchase cards, adding them to their deck. Unlike a TCG where the available cards only changes every few months when a new set of cards is released, in Dominion each game has a different set of 10 available kingdom cards. Randomly selecting from over 500 available cards, means that there are well over \(10^{25}\) possible kingdoms¹, each with their own strategic considerations.

Much like TCGs, strategies can be sorted into different deck archetypes²:

big money decks aim to buy a province each turn, by improving the money the average 5 card hand generates
engines optimize to draw the entire deck each turn, often buying multiple provinces in a turn
combos utilize unique card combinations usually culminating in a single big turn in which they end the game
slogs aim to slow down the game, while acquiring cards that give them a bigger advantage the longer the game lasts
rushes use cards that gain more cards to end the game as quickly as possible, scoring just enough points to win

Dominion’s strategic deck building decisions dominate the game from the very start. Each turn you have a 5 card hand, only shuffling new cards into your deck after having used up your entire deck. Starting from a 10 card deck, on your first turn, you already know your second hand. Because all 10 kingdom cards are visible at the start of the game with 10 copies of each, players can plan ahead to their final deck before buying a single card.

Different deck archetypes need very different cards, and often want to make very different early purchases. Hedging and buying a card that is good for multiple different plans is only useful if you actually might need to pivot based on what your opponent does. The opportunity cost of doing so is often too high to pay.

Other deck-builders fail to have this strategic depth. For example, in Slay the Spire, you only see 3 cards at a time and pick one. You don’t know what cards you’ll be able to acquire later in a run. This makes committing to a longer term strategic plan foolish, because it significantly cuts your optionality³. Instead of replicating the, any card goes, deck building of constructed TCG formats, it replicates drafting.

After creating your game plan, Dominion’s tactical gameplay is mostly mechanical. You track your deck and concretize your plan by reacting to your particular shuffle luck plus your opponents behavior. In a close game, the endgame features Dominion’s heaviest tactics, as players vie to ensure that they will be able to end the game on their turn in the lead. If you missed a good strategy, and your opponent catching you off guard, it’s usually already too late to pivot.

Because winning or losing hinges on strategic deck building choices, Dominion players love to analyze kingdoms, debating at length the subtleties of different plans without even playing the game. Freed from the burden of shuffling, online Dominion games last just 10-15 minutes. Usually the first 3-5 minutes is spent figuring out what deck best suits the given kingdom.

In Dominion more than any other game⁴, strategy dominates over tactics. It doesn’t just give you the ability to, but requires playing with a bird’s eye view, thinking about the deck you plan to build, right from the start.

There’s a bunch of extra selection factors: Landscape cards like Events, Landmarks, Projects, etc. plus cards that require extra cards like Young Witch which requires the selection of a bane, that make calculating the exact number fairly tedious. ↩
My terminology here is borrowed from Wandering Winder’s The Five Fundamental Deck Types. Sometimes thinking in terms of these archetypes is overly restrictive, but it’s a good starting point for understanding the different strategies one might pursue in a Dominion game. ↩
Because engines/combos appeal to me (and often are the strongest strategies in Dominion), I usually go for silly infinite combo decks with the Silent, resetting if I don’t get the cards I need. But this is more playing a slot machine, rather than finding strategic depth in Slay the Spire. ↩
I’ve mostly framed this as being about deck-builders, because it’s a lot easier to compare apples with apples. That said, I think Dominion has a particularly high density of strategy to tactics for any game.
Consider chess. Though opening theory is arguably fairly strategic, it’s extremely memorization heavy. Beyond that, tactics tend to dominate. The game tree is too chaotic to make concrete plans about end-game strategy in the mid-game.
In my opinion the strongest contender for strategically most dense game is Prismata, which takes Dominion’s open market and removes luck completely. Unfortunately it never took off, thus has a small player base and hasn’t added as many distinct “units” (the equivalent of kingdom cards). ↩

Against foolproof software

Fri, 17 Apr 2026 06:37:00 +0000

If you’re familiar with spaced repetition systems, this should work as a standalone post. This is the last post of a 3 post series. The first two posts explain WaniKani and jpdb.io in more detail.

WaniKani tries very hard to make learning Japanese foolproof. They don’t let you grade yourself or undo mistakes they want to protect you from “the illusion of knowing”. They don’t offer the ability to blacklist or permanently mark cards as known.

These design decisions probably make WaniKani more effective for the user profiles they think about the most. WaniKani’s testimonials highlight two kinds of users:

Japanese residents, who likely either need Japanese for work, e.g. “My job requires me to work with a number of Japanese companies.”, or strong intrinsic motivation, e.g. “I’ve lived in Japan for eight years”. For this kind of person, it’s easy to dedicate 1-2 hours every day to learning Japanese.
self-learners, with a lot of time to dedicate to learning Kanji. My friends who made it through much more of WaniKani than me, all fit into this category. Even for me, WaniKani worked well at first, before betraying my expectations in a couple of important ways.

First, WaniKani ended up growing into a much larger time commitment than I assumed from my first few weeks using it. WaniKani doesn’t claim how many hours per day it will take to learn Japanese in just over a year. But, because early on WaniKani’s mechanics for unlocking lessons prevented me from investing the ~30 minutes per day I wanted to, I assumed that the workload would continue to be manageable. Then, when reviewing flashcards from the past 4 months, the workload became overwhelming. jpdb.io’s better spaced repetition algorithm lets you build it into your schedule more consistently from the start, while also adapting better if you’re willing to commit less time in the future.

Second, WaniKani promised to teach me “2,000 kanji, hand-picked and cleverly ordered” plus “6,000 Japanese words, all carefully validated by a human to be common or useful”. Of course, I didn’t have a good sense of what vocabulary I wanted to learn, so this was part of what appealed to me when I chose WaniKani. If I’d been willing to commit the time to mine songs and texts for vocabulary I cared about, I probably would have started with Anki. But over time, the rigidity of the curriculum started to frustrate me. I longed to be able to exclude words, even considering a Firefox extension for WaniKani that would autofill the correct answer for words that I didn’t want to review.

Both of these problems were mostly a misalignment between my goals and knowledge, and the needs WaniKani’s developers assume their users have. But WaniKani is designed to be foolproof, without options or configuration that would make it less effective for certain kinds of users.

Aiming for foolproof makes a lot of sense when designing a product. Less options, configuration, and variables to consider makes the product simpler. This has huge dividends for scalability. A simpler product is easier to explain, optimize, market, and sell without needing to consider the needs of individual users.

But I wasn’t interested in WaniKani as a mindless consumer, I was interested in a tool to help me learn Japanese. Instead of aiming to be foolproof, jpdb.io trusts its users to accomplish their goals. This unlocks the possibility for it to be better tailored to any individual user’s specific goals.

Not everyone will carefully tweak all the configuration options to figure out what works the best for them. Good defaults will make sure that the average user still has a good experience. But almost everyone has specific complaints about the products they use or things they would want tweaked. It’s worth building a configuration option for at least the most common ones.

Even if users want something that you think would make the product worse, they’re probably trying to act in their own best interest. Sometimes, as the designer, you really do know better. But, at other times you don’t understand the user’s complaint well enough. If enough people request a setting you find confusing, perhaps it’s worth exercising some intellectual humility and adding it anyways, along with an explanation for why you think they shouldn’t use it¹. If you trust that your users are acting in their own best interest, they’re probably motivated enough to try to understand your reasoning.

Most users don’t need to be protected from themselves. Instead of making your software foolproof for your assumed user, design it to adapt to the needs of your specific users.

jpdb.io’s settings page actually does this several times. I haven’t changed any of the settings it recommends against. ↩

What makes a good spaced repetition system? (jpdb.io)

Thu, 16 Apr 2026 05:01:00 +0000

I recommend reading yesterday’s post discussing my follies with WaniKani the first time I tried learning Kanji.

Over a year and a trip to Japan passed before I made a serious effort at studying Japanese again. WaniKani had failed me in several ways, and I was reluctant to try a spaced repetition system that wouldn’t solve them.

I wanted something that would adapt to my existing Japanese knowledge, letting me avoid redundant flashcards. More importantly, I needed something that would respond more gracefully to getting overwhelmed or returning after a break.

jpdb.io checked both of these boxes. Instead of a fixed curriculum, jpdb.io allowed you to choose exactly which vocabulary you wanted to learn. Even better, it offered a wide variety of pre-built decks with vocabulary from anime, visual novels, and books. It also claimed to handle lapses and irregular time periods between flashcard reviews better by implementing an ML based spaced repetition algorithm.

jpdb.io’s flashcard system/lessons are simpler than WaniKani’s. There are only two kinds: kanji flashcards (which includes radicals) and vocabulary flashcards. Kanji flashcards come with mnemonics¹ ask you to visualize or draw the kanji or radical based on its name while vocabulary flashcards ask you to guess the pronunciation/meaning of the word in the context of an example sentence.

I was enjoying the Summer Pockets anime at the time and eager for more content, wanted to try reading the source visual novel as Japanese practice. jpdb.io configured to feed me the most common vocabulary in Summer Pockets, I raced through 30 minutes of flashcards per day, mostly marking that I would never forget vocabulary that I already knew.

Unlike WaniKani, flashcards are self graded — you choose whether remembering the kanji/vocabulary was hard/medium/easy or whether you forgot the flashcard nothing/something.

Anki allows using FSRS as its spaced repetition scheduler providing pretty much the same benefits as jpdb.io’s scheduler.

I was aware that without strongly committing to an answer, there was a risk that I would assume that I would assume my answer was correct, even when I hadn’t really known before seeing the solution. To guard against this I took the time to trace the kanji in the air and subvocalize the vocabulary’s meaning and pronunciation before clicking through to see the solution. Deciding how to grade myself was tricky at first. Sometimes when tracing out a kanji, I would draw the right strokes but in the wrong order. Because I was only tracing into the air, it was hard to judge how accurately I’d drawn the shape, so I opted to grade myself more conservatively.

jpdb.io’s spaced repetition algorithm also lived up to its promises. I’ve noticed two main benefits in practice. First, flashcards are pretty much always the right difficulty. My accuracy on jpdb.io ended up being fairly consistent with my accuracy on WaniKani at ~90%. Despite this, I rarely get a flashcard that I want to mark as easy; usually I have to think at least a second or two, before remembering the correct answer. Second, unlike WaniKani I don’t get flashcards wrong, only to weeks later on my next review still have no idea what the right answer is. Instead, jpdb.io usually shows me the flashcard again much sooner (i.e. the next day) when I get a flashcard wrong.

All of this remained true even when abandoning jpdb.io for longer periods of time, be it several weeks for a trip, or even once for several months. Just continuing to review my flashcards at whatever pace I manage when I got back, slowly reintroduces me to the flashcards I forgot, while giving me credit for remembering a longer period of time, for the flashcards I got wrong. It’s also been really nice to be able to tailor the vocabulary I’m learning to whatever Japanese media I’m consuming over the past year.

I haven’t practiced Japanese quite as consistently since switching to jpdb.io. But, I’ve been using it for at least a year, whereas WaniKani burnt me out after just ~5 months. It effortlessly slots into my life when I want it to, adapting to whatever is going on in my life at the moment, making it as painless as possible to pick it back up again.

Continued in Against foolproof software.

At least the most common ~1000 radicals/kanji have mnemonics. I found that learning the most common words in Summer Pockets, I fairly quickly started running into some kanji missing mnemonics. But jpdb.io lets you to define custom mnemonics, which has the added benefit of making it easier to remember your mnemonic (assuming you try reasonably hard to make one). ↩

What makes a good spaced repetition system? (WaniKani)

Wed, 15 Apr 2026 05:17:00 +0000

This is part 1 of a ~3 part post. This part explains how WaniKani works through my first experience and follies using a spaced repetition system.

Japanese is one of the world’s most difficult writing systems. Compared with English, Hiragana and Katagana are simple phonetic alphabets. Their pronunciation is always consistent, and across both alphabets there’s just ~92 distinct characters plus a handful of consistent diacritics and multi-character compounds. Much easier than English where “ghoti” could arguably be pronounced “fish”¹.

But to read Japanese, you also need to be able to interpret at least 2000 Kanji characters. Most Kanji characters can be pronounced at least two different ways depending on context: a native Japanese pronunciation (kun’yomi) in addition to the pronunciation derived from Chinese (on’yomi). For common characters there’s usually at least one or two more. In the worst cases, for example 生, an extremely common character that Japanese children learn in first grade, a single character can have as many as 6 different kun’yomi and 2 different on’yomi.

I knew all of this when I set out to learn the 2000 most common Kanji. I’d just returned from my first trip to Japan, and was more motivated to learn than ever.

WaniKani

WaniKani made getting started frictionless. Kanji can be broken down into radicals, bits of characters with a consistent meaning/shape. Each WaniKani level, starts off with lessons teaching you the names of the radicals. Each radical is taught with a mnemonic and often comes with a cute picture too:

Since there are no circles in Japanese characters, sometimes rectangles or squares have to make do. In this case, this big rectangle is the sun. The middle line is a cloud, moving across the sun. Picture it, but don’t actually look at the sun and burn your eyes!

After a couple hours, you prove that you remember the names of each of the radicals by typing them out, and then you’re done for a few hours. You review the radicals again, then again after a day, and finally if you’ve gotten the item right 4 times in a row, you’ve proven that you’ve committed the radical to your “medium-term” memory. The radical upgrades from the “Apprentice” to the “Guru” memory stage, unlocking Kanji that depend on that radical. For Kanji there’s two separate things you learn and are tested on: meaning and pronunciation. When a Kanji advances to “Guru” you unlock dependent vocabulary, again with separate meaning and pronunciation lessons. Once all but 3 Kanji in a level are “Guru”, you advance to the next level, unlocking the next set of radicals.

At first, it only took 5-10 minutes a day to do all of my reviews plus new lessons. I returned to WaniKani for my reviews after the exact review time intervals, to make sure that do my reviews as soon as possible. Because I was also maintaining a high accuracy, I was able to advance a level every ~8 days. Projecting forward, it wasn’t difficult to imagine getting to the last level, level 60 in a year and a half as advertised. I was starting to notice the vocabulary I was learning in the music I listened to, excited that so as long as I could match my current pace, I would have mastered Japanese in just over a year. How naive I had been.

The thing about spaced repetition systems, is that you’re trying to commit the Kanji and vocabulary to your long-term memory, remembering them indefinitely. So you keep reviewing again after 1 week, after 2 weeks, after 1 month, and finally, in WaniKani, after 4 months the item is considered “Burned” and you never see it again in reviews. Beyond that, ambient exposure through reading is probably enough to avoid forgetting it.

These longer-term reviews didn’t get in the way of my high accuracy rate, but the additional workload made my review sessions start to take longer and longer. By the time I was hitting my first batch of 4 month reviews, I was spending at least an hour a day on my 200ish of my lessons and reviews. To be confident that this was as hard as hard as it would get I calculated that about ~150 total vocab/radicals/kanji per WaniKani level. Some vocabulary were also starting to get fairly obscure. I’m still not exactly sure what outpatient means in English, but 外来 was one of the words I was learning in Japanese. An hour a day was a large enough time commitment that I was starting to question whether it was worth continuing.

When getting an item wrong, spaced repetition systems adjust their model of how well you know that item. WaniKani uses discrete memory stages: “Apprentice” 1-4, “Guru” 1 & 2, “Master”, “Enlightened”, and “Burned”. WaniKani places a lot of weight on how often you get an item wrong before you get it right. Getting an item wrong only once, then right on the next try because you carefully reviewed and committed the mnemonic to your short term memory, only moves an item back 2 memory stages ². This means you can get an item wrong after not having seen it in over 4 months, and then next see it again over two 2 weeks later. Just getting the item right on the first re-try isn’t enough to prove that you still know the item well enough to remember it in two weeks. This can make reviews feel extra frustrating because you’re being asked to review cards that you don’t actually have a good chance of getting right.

I started to dedicate less time to WaniKani, just 30-60 minutes per day instead of just over an hour. Some days I wouldn’t even finish all of my reviews, much less all of my new lessons. Consequently, I started to level up more slowly, and my accuracy started to drop. My lower accuracy further increased my workload, and I found that my accuracy on cards that I’d gotten wrong two weeks earlier stayed fairly low. Eventually I was rarely finishing all of my reviews. After traveling for two weeks, the mountain of reviews I returned to made continuing feel impossible.

After a couple of months futilely trying catch back up, my accuracy rate quickly falling, I let go completely, giving up not only on finishing WaniKani, but also achieving Japanese reading and writing proficiency.

Check out part 2 where I try again more intelligently.

“gh” as in cough, “o” as in “women”, and “ti” as in “nation”. ↩
The exact formula is documented in WaniKani’s knowledge base. ↩