For most of the last thirty years, we told ourselves a simple story about software: the hard part is writing it. Learn to code, the thinking went, and everything after that is detail. It was never quite true, but it was true enough that "developer" became the job that decided what got built and what didn't.
Then, almost overnight, the writing got easy. You describe what you want, an agent writes it, and the result is good. Not a toy. The real thing. Someone who has never opened a terminal can now produce a working application in an afternoon, and a week later it does something a small team would have quoted three months for.
So the bottleneck moved. And it moved to the one place nobody wanted to look.
The part that never got easier
Writing an app and running an app are two different jobs that happen to share a word. The first is now a conversation. The second is still a server you have to rent, a domain you have to point, certificates that expire, a database, secrets that must not leak, and a thing that falls over at 2am and takes the business down with it.
None of that got easier. If anything it got worse, because now the person who built the app has no idea any of it exists. They asked for a customer portal. They did not ask to learn what a reverse proxy is.
The moment your idea works is the moment your real problems start.
This is the quiet tax on the whole "anyone can build now" promise. Yes, anyone can build. Almost nobody can operate. And operating is not a one-time cost you pay at launch. It is a standing obligation that follows the app for as long as it is alive.
Who carries the pager
Ask where the work actually goes and you get an uncomfortable answer. It goes to whoever is least equipped to do it. The founder who can describe an app in plain English is now also, by default, the person on call for it. The agent that wrote the code cannot rent the server, cannot renew the certificate, cannot notice at midnight that the thing has stopped responding.
So the human gets pulled back into infrastructure. Not because they want to be there. Because there is no one else, and the tools quietly assume someone technical is standing by.
That assumption is the bug. It is the last place a person should have to be, and it is exactly where most of today's tools leave them.
What we think comes next
We started Pantry on a single belief: if an agent can build the app, an agent should be able to run it, and the human should never have to meet the server at all.
That means the boring, dangerous, never-finished work of operations becomes something the agent does on your behalf. Deploys just happen. Things break and the fix comes back to your chat instead of your weekend. The apps you build start to know about each other. And the whole apparatus underneath stays where it belongs, which is out of sight.
The expert who could run all of this by hand is not going away. But they are about to become a much smaller part of the story, the same way the blacksmith did not disappear so much as stop being the bottleneck for everyone who needed a horseshoe.
The hard part was never the idea. It was everything that came after. We think that part is finally up for grabs.