Voidware: This App Doesn't Exist

Last week I made a todo app appear out of thin air. No code. No database. No backend. Just an AI hallucinating an entire application into existence, one request at a time.

It works. Which is the part I still can't quite believe.

A Different Kind of Software

We've been using AI to write code faster. Cursor and Claude Code build entire features from natural language. These tools are incredible, but they're still operating in the old paradigm: we build software, then we run it.

What I'm about to show you breaks that assumption entirely.

Picture visiting a website where nothing exists until you arrive. No code waiting on a server. No routes defined. When the page loads, an AI generates the interface on the spot. You click a button, but there's no event handler. The AI sees the click and decides what should happen. You submit a form to /api/todos. That endpoint doesn't exist, has never existed. But the AI receives the request and responds with exactly what a todo API should return.

The model isn't a tool that helps build the app. The model IS the app.

Voidware

This needs a name. I've been calling it voidware: software that never actually exists as software. Not before you use it, not while you use it, not after. Like improvised music that only exists while being played, these applications materialize in the moment of interaction.

The entire implementation is about a hundred lines of glue:

Browser → AI Model → Browser

Your browser makes requests. The AI maintains state through its context window and responds. Somehow, through this ridiculously simple setup, you get something that feels like an application.

↑ A todo app being used, but never built

What I've Learned So Far

State is just memory. Traditional apps store state in databases. Voidware maintains it through the AI's context, with each interaction building on the last. It's fragile, yes, but it's also... working?

Consistency is emergent. I expected chaos. Instead, the AI naturally maintains internal consistency. If it generates a todo with ID 42, it remembers that ID in future responses. Not because I programmed it to, but because that's autoregressive coherence: each token conditioned on all previous tokens, creating self-reinforcing continuity.

The boundaries blur. Frontend, backend, database: these distinctions stop mattering when everything flows through the same model. It's all just tokens being transformed.

It's weirdly personal. Each session creates its own unique application. Your todo app might evolve differently than mine, based partially on how we each interact with it.

The Engineering Challenges Are Fascinating

This barely works. Context windows fill up. State drifts. Sessions are ephemeral. But these aren't fundamental barriers; they're just current limitations.

The trajectory is clear: context windows, inference costs, and generation speeds are all rapidly improving. We're on a path where producing software will cost essentially nothing. When you can generate any functionality in milliseconds for fractions of a penny, what happens to the value of code itself?

More interesting are the design questions this raises. When state lives only in context, how do we handle persistence? When consistency emerges from probability rather than rules, how do we ensure reliability? These aren't reasons to give up. They're fascinating engineering challenges.

Why This Might Matter

I'm not saying we should throw away traditional software engineering. Most applications need reliability, performance, and scale that voidware can't provide. Yet.

But there's something profound here:

Software becomes truly personal. Not customizable, but truly personal. A tax form that generates exactly the fields you need based on your situation, creating workflows that never existed before. Every user gets their own unique version, adapted in real-time to their specific context.

Infrastructure vanishes. No servers to provision. No deployments to manage. No security patches to install. The entire DevOps pipeline disappears. Just a browser and a model. The complexity we've spent decades managing simply... disappears.

Intelligence replaces logic. Traditional software follows pre-written rules. Voidware understands intent. When you ask your dashboard to "show me what's weird about Tuesday," it doesn't just filter preset charts. It invents new visualizations that highlight Tuesday's anomalies.

Bloat becomes impossible. Why ship features 90% of users never touch? Voidware generates only what each user needs, when they need it. That settings page with 200 options? It doesn't exist unless you ask for it.

The Code Is Minimal (That's the Point)

The implementation at github.com/ohadpr/voidware is deliberately simple. A small HTTP server that forwards requests to an AI and returns responses. No framework, no complexity. The interesting part isn't the code. It's the absence of it.

let context = [systemPrompt]

const handler = (req, res) => {
  context.push({ role: 'user', content: req })
  res.send((reply = LLM(context)).content)
  context.push(reply)
}

Where This Goes

I don't know. That's what makes it exciting.

Maybe this is a dead end: a curious experiment that teaches us something about the nature of software. Maybe it's the beginning of something bigger. Software development has always been about managing complexity. What if, instead, we could generate simplicity on demand?

The three trends converging:

• Inference speed dropping below human perception thresholds
• Context windows growing large enough to maintain complex state
• Costs approaching zero for basic operations

We're entering unexplored territory. Software without source. Applications without artifacts. It's weird and broken and fascinating.

A Small Experiment, A Large Question

Traditional software is like recorded music: fixed, perfected, reproducible. Voidware is like jazz improvisation: live, adaptive, ephemeral. Both have their place. But we've only been making recordings.

I keep coming back to this todo app that doesn't exist, watching it respond to clicks with code that was never written, maintaining state that was never stored. It's a small thing, barely functional. But it works.

And if this works, what else is possible?

There is no app