Appimals

“My friend said yesterday about some app he made with AI, ‘It’s my first disposable app,’ and it didn’t hit me until just now. Computers are finally free of treating software like hardware. Apps should die and be reborn every time we use them.” —
Me

“Disposable software will very quickly lead us to the state of the world where we summon powerful demons to do our bidding left and right. The necessity to understand things in order to make them happen will go away...” —
Phil (Define Games)

“He’s right though, software is livestock now. It stinks, which is why we live in the homestead and let the animals live in the barn.” —
Me

The Evolution of Software

I am convinced that software is heading toward total disposability. It used to be that updates were slow and cumbersome; we treated software like hardware. But now, as it becomes effortless to generate code on your own, the paradigm is shifting.

We are moving from a "one app, many users" model to a "many apps, one user" model.

In this future, apps will be like animals. They will share a common "DNA" (codebase), but they will adapt specifically to the niche of you. The code is the species, and your specific deployment is an individual animal within that species. This allows software to evolve rapidly, assuming it is open for AI to iterate upon. I think AI agents are already moving in this direction.

For fun, let’s call them Appimals.

The Trap: Metrics vs. Problem Solving

This evolution is both good and bad. On one hand, error correction happens much faster. On the other hand, the motivation for that error correction might be driven less by human utility and more by memes and behavioralism.

I live in Japan, so let’s look at English language learning as an example. English education here is compulsory from a young age, yet proficiency—especially speaking—remains low. Why? Because the system prizes credentials over communication. If you want a management position, you need the English credential on your resume to unlock a higher salary, even if the skill is superficial.

This creates a behavioral loop disconnected from solving one’s own problems. The goal isn't "speak English," the goal is "get the score." In fact, social pressure often discourages people from actually being "a person who speaks English."

Goodhart’s Law states: “When a measure becomes a target, it ceases to be a good measure.”

It’s worse than that, though. The metric can become an obstacle that prevents us from achieving the underlying goal that made us curious about the metric in the first place.

The Rise of "Mosquito Apps"

If people use AI merely to chase metrics, they are solving other people’s problems, not their own. If we create an entire species of apps designed solely to pass the TOEIC exam for a salary bump, we have created the software equivalent of a Mosquito.

Mosquitoes are parasitic; they carry malaria and offer little value except maybe fish food. We don't need mosquito apps. If we lose some ecologically naive

Dodo apps

along the way, that's a shame—but, while I don't know how this all pans out,

I don't think

extinction is written in stone.

Unnecessary "Mosquito" Appimals already exist. Take Duolingo. It is essentially a game with little connection to language acquisition. It solves a psychological problem—“I feel guilty if I don’t look like I’m learning”—rather than the practical problem of learning. An AI-iterating version of Duolingo is likely already being built.

I can’t stop people from building that. But I can code an alternative that caters to my actual understanding of the problem. That is why I'm working on a bunch of open source software right now, like my person-first English-project based immersion learning app: Terakoya.

The Future is Lightweight

This brings me to a technical realization. If apps are to be disposable—dying and being reborn constantly—they cannot be heavy.

I noticed that Anthropic recently purchased Bun, the fastest JavaScript runtime/compiler (written in Zig, which is pretty cool on it's own, BTW). Why? My guess is that it supports this "Appimal" theory. In the past, we waited for a central authority to push an update. Now, updates will happen dynamically through AI. For an Appimal to be reborn every time you use it, the architecture must be incredibly fast and lightweight.

That said, I think for the people that DO care about their Appimals, they'll want to be able to understand the DNA. To me this has always been the advantage of Ruby—it's designed for human enjoyment. It's very close to English, it's fun to read. As far as fun to understand, and fast, there must be a middle ground here between JS and Ruby, but I haven't figured that out yet. So, for now, unfortunately, everything I build feels pretty heavy.

Iterate, Go with the Flow

It has become a cliché in my sphere, but it remains true: “Problems are inevitable, but problems are soluble.”

We shouldn't enter this new era of programming with a pessimistic attitude that shames people for "doing it wrong" (like chasing English credentials). The difference between complaint and criticism is responsibility.

Problems don’t solve themselves. However, the problems that arise from people chasing metrics—the obstacles that get in the way of actually understanding things—are fundamentally interpersonal problems.

If you are used to the old mode of software development, this may seem unsettling. More and more apps may feel outside of developer control, now. People will be "writing code" without understanding it the way you have, or caring about it the way you do. Words like "developer" will stop meaning what you thought they meant.

But staring sarcastically at the changing world won't help. Go with the flow. Let new words arise, let old words change their connotation, and iterate solutions.

Most importantly: enjoy yourself.

If you let enjoyment become optional, my guess is that you are secretly chasing a metric yourself. If that’s the case, perhaps you should change career paths—whether that means literal farming, or software farming.

If you "see" the problem—that AI might exacerbate parasitic metric-chasing rather than individual empowerment—then you understand enough to act. The solution isn't just for computer scientists; it's for anyone willing to take responsibility for their own tools.

[Here's the "conversation" with AI that I used to write this article]

[Here's the article on X]