The Problem I'm Actually Solving
AI changes what I repeatedly retrieve from memory. When an assistant fills in a function signature or a loop construct, I no longer have to pull it out of memory myself. That's the actual mechanism worth naming, not some vague claim that AI makes programmers worse. Retrieval that used to happen dozens of times a day now happens less often, and procedural fluency, the kind that lets you write code without conscious effort, depends on that retrieval happening repeatedly over time.
This isn't an argument against using AI. I use it every day and it works. It's an argument that if retrieval quietly drops out of the loop, the skill that retrieval used to maintain quietly drops with it. Reflex exists to put deliberate retrieval practice back in, on purpose, without asking anyone to stop using the tools that got them here.
I started with gittype, which was useful for going through the whole xv6 codebase early on. Lolevel came after, as a more focused and specialised tool built directly around the important code from MIT's xv6 book rather than the codebase at large. Reflex takes the same underlying idea, retrieving real code from memory rather than reading it, and turns it toward general syntax and API retrieval instead of one specific kernel.
The secondary use case follows from the same mechanism, just at a different starting point. Working memory is limited; anyone learning to program is spending a chunk of it on recalling syntax, which leaves less available for reasoning about algorithms, structure, and invariants. Once syntax retrieval becomes automatic, that same working memory is free for the actual problem. A beginner doesn't need to stop using AI either; they need enough retrieval practice that syntax stops competing for attention with program design.
Hidden Modes: Raising the Difficulty on Purpose
Reflex isn't primarily a typing trainer. Typing is the mechanism, not the point; you have to produce the text, which forces the retrieval, but the skill being trained is active retrieval of programming knowledge, not keystroke speed. The base mechanic types out real code and tells you what you typed. Hidden modes change what has to come from memory rather than from the screen:
- Keyword and syntax hiding: control structures, operators, and language keywords are blanked out; only the surrounding logic is visible. Completing the line means retrieving the syntax rather than copying it.
- Library and API hiding: function calls, standard library methods, and imports are blanked instead. The logic stays visible, but the call signature has to come from memory.
These aren't separate tools; they're the same drill with progressively less support. A learner starts with everything visible, so the first retrieval attempts have something to check against. As syntax becomes automatic, keyword hiding removes that support and forces retrieval instead of recognition. Library hiding removes it again for API calls. Each stage matches the same principle from Lolevel: interactivity has to be load-bearing, not decorative. Blanking something out only helps if recalling it is the actual skill being tested, and retrieval practice only builds fluency if it happens close to the edge of what you can currently produce, not comfortably inside it.
Coding From Scratch: No Reference at All
The modes above still show the shape of the code; retrieval happens inside a known structure. The from-scratch section removes the structure entirely. You get a plain instruction describing what the program should do, and nothing else: no skeleton, no partial code, no reference material open beside you. Every part of the program, syntax and structure and logic together, has to come from memory.
This only works as a final stage, not a starting point. Attempting it before syntax retrieval is reasonably automatic just means staring at a blank editor with nothing to retrieve yet. Once someone has been through the typing drills and the hidden modes, from-scratch coding is where retrieval and design have to happen together, the way they would in an interview, a whiteboard session, or any moment when an assistant isn't there to fill the gap.
Why the Order Matters
The four stages are a deliberate scaffold, each one removing a specific kind of support as automaticity develops underneath it:
- Full visibility typing drills; build initial familiarity with real code.
- Keyword and syntax hidden mode; force retrieval of language constructs.
- Library and API hidden mode; force retrieval of the tools built on top of the language.
- From-scratch coding; combine everything with no reference at all.
The scaffolding comes down in the same order it would if a person were learning this without any tool at all: recognise it, then recall pieces of it, then recall all of it unprompted. Skipping ahead defeats the purpose, not because of some arbitrary rule, but because retrieval practice only strengthens what you can already produce with effort; skip the stage where syntax is still effortful and there's nothing yet for the next stage to build on.
Who This Is For
Two groups, same mechanic, different starting points. Experienced developers who've noticed how much less often they retrieve syntax and API calls from memory now that AI fills in that step, and beginners who haven't built that retrieval up yet and need the working memory it frees for program design. Both groups get the same drills; they just start at different points in the progression.
Where This Could Go
Right now Reflex treats every syntax construct and API call the same way, moving learners through the four stages at a fixed pace. A more useful version would track which specific constructs a person keeps failing to retrieve and schedule those more frequently, the way spaced repetition systems do for vocabulary. Instead of repeating the whole language uniformly, Reflex could weight practice toward whatever someone's own retrieval history says they're weakest on. This is speculative and not built yet, but it's the direction that makes the most sense once the core retrieval mechanic is solid.
How It Got Built
Reflex is a separate tool from typesec, which stays focused on CLI tools. The idea for Reflex came first; the build came from handing Claude Code the concept with Lolevel as a direct reference. Reflex shares Lolevel's interface entirely: same layout, same visual language, same underlying stack. Mathemphetamine already uses that same UI too; no point changing something that's clean and works well. The tools solve different problems, Lolevel teaches xv6 and computer architecture concepts, Reflex trains retrieval of syntax and APIs, mathemphetamine handles quiz-based scoring, but there was no reason to design a new interface each time when the existing one already fit.