There is a moment in every new technology when people notice the recursion and treat it as a punchline. We used electricity to build the power grid. We used computers to write software. Now: we are using AI to build AI.
The joke wears off quickly. The loop is real, and it is where most of the interesting work is happening.
I do not mean training the next foundation model with synthetic data—though that happens too. I mean the quieter, more practical recursion: using an AI assistant to write the Stimulus controller that wires up your chat UI. Using it to scaffold the tool definitions your agent will call. Using it to debug the harness that keeps the model from deleting the wrong file. The model is not building itself. It is building the infrastructure that makes itself usable.
That distinction matters. The hype version of “AI creating AI” imagines a self-improving god in a datacenter. The useful version is a developer on a Tuesday afternoon, iterating on the boring parts faster than they could alone.
The new interface is AI.
That is not a product slogan. It is a structural claim about where the human-facing layer is moving. The best analogy I have found is the TUI—the terminal UI. Raw shells were powerful but hostile: you memorized commands, flags, and each tool’s dialect. Then TUIs arrived—htop, lazygit, k9s—and gave you a navigable surface on top of the machinery. Still text-native. Still close to the metal. But someone had designed the panes, the keybindings, the layout of what you saw when you sat down to work.
AI is playing a similar role now. Intent in, orchestrated action out. Files, APIs, tests, and deploys stay underneath. The session is the control surface—the way a good TUI is the control surface for a cluster or a repo.
It is not a one-to-one fit. I am not claiming chat replaces every button. We will still have regular UI elements—forms, tables, charts, buttons. Buttons are not going away. What changes is who decides what appears on screen and when. AI drives the display layer: which controls matter for this task, this user, this moment. The interface stops being a fixed layout you shipped last quarter and starts behaving more like a TUI that redraws itself around the problem in front of you.
That is where “applications that create themselves on the fly” comes in—not science fiction, but a direction already visible at the edges. You describe what you need. The system assembles the right combination of widgets, data fetches, and actions. Not a new app in the App Store every time. More like a surface that composes itself for the job, then dissolves when the job is done. Static screens were a compromise forced by compile time. We are loosening that constraint.
When the interface is AI, building AI infrastructure is interface design at a higher tier. Skills, tools, verification gates, permissions—these are the panes and keybindings of the new layer. The colleague from my earlier essay on working with AI is also the terminal you type into. The harness from the essay before that is the layout engine underneath.
This is not new, exactly. We have always used tools to build tools. Compilers compile compilers. Debuggers help you fix the debugger. What changed is the shape of the work.
Before LLMs, the loop looked like this: think, type, run, fix, repeat. The thinking and the typing were tightly coupled. You could not get one without the other. AI loosens that coupling. You can think at the level of intent—“add a verification step before destructive writes”—and get back something concrete enough to edit, run, and reject.
The skill is not prompting. The skill is knowing what to ask for, what to accept, and what to rewrite from scratch because the first pass missed the point. That is the same skill as working with any sharp colleague. The recursion just makes the colleague faster at producing drafts you still have to judge.
Where the loop compounds:
Scaffolding and exploration. Harnesses, skill files, hooks, test suites—the structurally obvious parts AI collapses from intent to runnable draft, often with alternatives you would not have reached alone.
Iteration on iteration. Fix, explain, patch, test, repeat—the same loop you would run alone, except the middle steps move faster when the task is well-scoped and verifiable.
Documentation and skills. Using AI to write the instructions that teach the next AI session how to work in your repo. Institutional knowledge at the speed of conversation.
Each pass makes the next pass cheaper. That is compounding, not magic.
Last week I needed a pre-commit hook that blocked commits when the Astro build failed. Routine harness work. I described the behavior, got back a shell script and a hook config, ran the build to test it—the hook fired on a deliberate failure, which was correct—and then noticed the script checked the wrong directory when run from a subdirectory. Predictable first-pass mistake. I pointed at the diff, got a patch, ran the build again, committed the hook. Twenty minutes, most of it verification.
That is the loop in miniature:
Intent. Block commits if npm run build fails; keep it repo-local.
Draft. Hook file plus script, plausible on first read.
Verify. Break the build on purpose; run a commit from a nested path; read the diff.
Compound. The hook stays. The next session does not re-learn our build command.
Nothing mystical happened. The AI did not understand why subdirectory paths matter. I did. The speed came from skipping the blank page. The quality came from still reading the diff.
The failure mode is obvious: you let the loop run without a human who understands what is being built.
Generated code that nobody reads becomes generated debt. A harness that “works” until it does not, because nobody verified the verification step. Skills files that encode yesterday’s mistakes as tomorrow’s rules. An interface that rearranges itself beautifully and hides the one button you needed to cancel a destructive action. The recursion accelerates everything—including mistakes.
The antidote is the same as always: verify, iterate, keep the hard judgments for yourself. The AI can draft the tool definition. You decide whether the tool should exist and what it is allowed to touch. The AI can suggest three layouts. You pick one based on constraints the model does not feel—latency, accessibility, what you are willing to maintain at 2 a.m.
Creating AI with AI is not abdication. It is leverage with guardrails.
There is something almost philosophical in the recursion, if you squint. We are building systems that help us build systems that help us think—and that help us see. The harness gets built, in part, by the voice inside the harness. The spinal cord grows new nerves with assistance from the organs it connects. The TUI analogy is imperfect; the direction is not.
I find that less alarming than the boosterism and less dismissive than the panic. It is craft. It is iterative. It requires taste, verification, and a human who knows when to stop generating and start reading.
The people who will build the most useful AI in the next few years are not necessarily the ones training the largest models. They are the ones who learned to sit in the loop—using AI to build the thing that makes AI worth using, and the interface that makes both legible—and who never forgot that someone still has to understand what got built.
That someone is you. The loop closes there, not in the datacenter.