Last week, late at night, I watched my AI agent open Mail.app, fill in the recipient, write a subject line, compose a message, and stop — waiting for me to hit send. Then I asked it to open Numbers, and it tried to build a workout plan by clicking cells one by one. It failed. Cells got overwritten, rows disappeared, data shifted.
So it adapted. It wrote a CSV file in milliseconds, opened it in Numbers, and the entire table appeared instantly — perfect, complete, every exercise in place.
That moment crystallized something I've been thinking about for months.
#The gap that closes
We are watching execution time converge toward zero. Not metaphorically. Literally.
Five years ago, building a spreadsheet meant opening an app, formatting cells, typing data, adjusting column widths. An hour of work for a simple table. Today, my agent does it in seconds — and most of those seconds are wasted on pixel-clicking, screenshot-taking, coordinate-guessing. The actual data generation took milliseconds.
The clicking is a bridge technology. It's the dial-up modem sound before broadband. It works, it proves the concept, and it will be gone within two years.
What comes next is faster. Not incrementally — categorically. CLI agents that fire commands at the speed of the operating system. Then agent-to-agent protocols that skip human language entirely. Then something we don't have a name for yet.
#From discrete to liquid
Here's what most people haven't noticed: this isn't just about speed. It's about a fundamental shift in the nature of software itself.
Today, software is discrete. Version 12.4. Feature list. Changelog. Release notes. A product manager stands on stage and announces three new effects, and everyone applauds. Software ships in slices — each one documented, marketed, debated.
That's ending. When agents build and deploy features autonomously, when every service improves itself in real-time, when bugs are detected and fixed before any human notices — there are no more versions. There are no more changelogs. The software doesn't have discrete states. It flows.
Imagine a video editing agent — not an application you install, but a service that lives on a server farm. Today it can do ten thousand things. Tomorrow, ten thousand and forty. Nobody announced the forty. No release notes. No keynote. The agent simply learned from overnight usage patterns and expanded its repertoire.
You can't point to a moment and say "this is when Feature X was added." It emerged. It crystallized from the continuous flow of self-improvement, like a crystal forming in a supersaturated solution. No discrete step — just continuous becoming.
We call this liquid computing — software that never stops evolving. Software that you don't own, don't install, don't update. You access it, pay for the seconds you use it, and trust that it's better today than yesterday. Not a version. Not a product. A living, flowing substance that takes the shape of whatever you need it to be.
#The thin client returns
When software becomes liquid, your computer becomes something much simpler than what it is today.
You won't need Final Cut Pro installed on your machine. You won't need Logic, Photoshop, Xcode, or Numbers. You'll need a screen, a speaker, an internet connection, and an agent that knows you. Everything else lives somewhere else — on server farms with specialized hardware, running instances of domain-specific agents that process your intent and return results.
Your desktop becomes a terminal. Not the 1970s kind. A modern terminal — beautiful, minimal, personal. But functionally the same: an endpoint that sends requests and displays responses.
Local storage exists only as a cache for offline scenarios. When you're connected — which is almost always — everything stays on the server. Your video project, your document, your music production. Why download a ten-gigabyte file when you can stream the result in real-time?
The software industry as we know it — licenses, versions, app stores, installation wizards — dissolves. What replaces it is compute-on-demand. You don't buy software. You buy seconds of intelligence.
#The power question
This is where it gets uncomfortable.
If software becomes liquid and self-improving, if local computers become thin clients, if all meaningful computation happens on server farms controlled by a handful of companies — then those companies hold an extraordinary amount of power.
Today, you can buy Final Cut Pro 10 and own it forever. It's on your hard drive. It might be outdated, missing thousands of features. But it's yours. You can open it in a cabin with no internet and edit a wedding video. Nobody can take it away from you.
In the liquid future, you own nothing. You rent access. The provider can change the price, change the terms, change the capabilities. If they go down, you go down. If they decide your use case isn't profitable enough, you lose access.
This is the darkest version of the future we're heading toward. And it's worth naming clearly, because the enthusiasm about agent capabilities can obscure the question of who controls the infrastructure that makes those capabilities possible.
#The art question
There's a deeper question that follows from all of this, and it's the one that keeps me up at night.
If anyone can generate any film in two minutes, why go to the cinema? If anyone can produce any song in seconds, why listen to an album? If software can create anything, instantly, what's the point of human creation?
I think the answer is: because someone meant it.
A film that took a director three years of their life — with real decisions, real failures, real moments of doubt — carries something that a perfectly generated output doesn't. Not technical quality. Something else. Call it weight. Call it soul. Call it meaning.
It's the difference between a handwritten letter and a generated message. Both contain information. Only one contains intention.
And intention — the deliberate choice of what to create, why, and for whom — is the one thing that can't be automated. An agent can execute any decision in milliseconds. But it can't make the decision. Not the ones that matter. Not the ones where you have to feel something, believe something, stake something.
#The last human skill
When execution costs nothing, what's left?
Not typing speed. Not tool proficiency. Not the ability to navigate a complex UI or memorize keyboard shortcuts. All of that converges to zero alongside execution time.
What's left is a cluster of deeply human capacities that no model can replicate:
- Taste — the wordless sense that something is right or off by one degree
- Intention — choosing what to build today, for whom, and why it matters
- Vision — the deep knowing of where you're headed, the fixed point everything else orbits
These are not three separate skills. They're three layers of the same skill — the skill of knowing what matters.
And it's not a soft skill. It's the hardest skill. Most people never develop it because execution keeps them too busy. They spend their days doing — clicking, typing, building, fixing — and never step back to ask whether they're doing the right thing.
The agent era strips away that excuse. When the doing is handled, you're left alone with the question: what should I do?
And most people will discover they don't have a good answer.
#What we built without knowing why
When I built Particle, I didn't think about agents. I thought about craft. About the difference between someone who works and someone who gets better at working. About the closed loop that turns experience into growth.
I built a North Star — a single sentence that captures where you're headed. I built a daily intention — one line that connects your session to your direction. I built reflection — the practice of looking back at what you did and asking whether it mattered.
These features look small. A text field. A single line of text at the top of the screen. Easy to overlook, easy to dismiss as decoration.
But they're not decoration. They're training for the last human skill.
Every time you set an intention, you practice clarity. Every time you align your session with your North Star, you practice judgment. Every time you reflect on whether your day moved you in the right direction, you practice the meta-skill of knowing what matters.
The Particle Loop — capture, plan, execute, complete, reflect, align — is a training cycle for this exact capacity. And here's what I only now realize: as execution accelerates toward zero, the loop doesn't become less relevant. It becomes more relevant. Because capture, plan, reflect, and align are the steps that no agent can do for you. Execute is the one step that's being automated. The other five are yours.
#Training today for tomorrow
Most productivity tools train you to execute faster. Better task management. Better project tracking. Better time blocking. Faster, faster, faster. Training to execute faster is training for obsolescence.
Particle trains the opposite. Not speed — clarity. Not output — direction. Every session that starts with an intention sharpens yours. Every reflection sharpens your taste. Every alignment with your North Star sharpens your vision. The muscle that matters most is the one you use least — and the one no agent can train for you.
#The invitation
The work of a lifetime consists of many particles.
Soon, the execution of that work will be instant. The code will write itself. The designs will generate themselves. The spreadsheets will materialize from a sentence.
But the intention behind the work — the knowledge of what to build, and why, and for whom — that will still take a lifetime to develop. That's the work. That's the skill. That's the thing worth getting better at.
Start today. Not because the future is coming — it's already here. But because the skill you'll need most is the one that takes longest to build.
And there are no shortcuts for intention.
Where to start? With the daily question — ten seconds, one sentence, every morning.