A developer posted a short obituary for his own toolbox. His audiobook maker that merges single episodes into an m4b and fills in metadata, gone: now he drops the folder at an AI, says one sentence, and the AI drives ffmpeg itself and searches the web for the tags. His music metadata scraper, the clunky one that kept failing, gone: same folder-and-a-sentence routine. Web scraping, gone: hand it to the AI, get structured data back. Programmer toolbox sites, he can't even be bothered to open them anymore. His conclusion was blunt. Individual developers have one direction left, games, and utility software is finished.
I get the feeling. I've deleted tools too. But I think he drew the line in the wrong place.
Why is a one-off tool disposable while a hosted asset compounds?
What AI actually crushed is the *one-off*. Dragging a folder into a chat and typing "merge these and fix the tags" is a disposable act. It happens once, on your machine, for you, and it leaves nothing behind. Tomorrow your friend has the same messy folder and has to repeat the whole dance, assuming they even know the right sentence to type and have the right model wired up.
That's the gap. The task got cheap. The *repeatable, shareable version of the task* did not. One of the replies on that same thread nailed the economics without meaning to: in the AI era the cost of customization has been compressed to almost nothing. True. Which is exactly why a bare one-off has no value, and why the thing that survives is the one someone else can run on day two without you in the loop.
So the move isn't to mourn the tool. It's to stop treating "throw a folder at the AI" as the product and start treating it as the spec. You already know the job cold. Wrap that same job as a hosted thing with a stable front others press repeatedly, and a callable endpoint behind it.
What does that look like in practice?
Take the music metadata case, since it's the cleanest. The job is: take a batch of files with missing or wrong tags, look up the correct info, write it back, hand the result back. That's a function. You can build it as a small Python backend that accepts an upload, does the lookup-and-correct logic, and returns the fixed set, then put a plain web page in front of it so a non-technical person just picks files and clicks a button.
On VicroCode the pieces line up directly. You run Python online for the actual processing logic, no local environment for anyone to set up. You expose it as an API Endpoint so the same job is callable, not just clickable, which is what turns it from a toy into something you can wire into other workflows later. You use a SQLite database to track jobs and keep a history of what was processed. And for the "search the web and fill in the metadata" part, the Model Center APIs give you a model already on the platform to do the enrichment and normalization step instead of you hardcoding a brittle lookup table.
The front end is the part people underrate. web app hosting for the HTML page is what lets your friend, or a stranger, run the thing without ever seeing a terminal. That's the whole difference between "I have a script" and "other people use my tool." Once it's published and shareable, it can sit alongside your other online tools as something with a URL, not a snippet you paste into a chat each time.
If you want it to get smarter over time, a LanceDB knowledge base is a reasonable place to keep a growing set of reference data your tool leans on, so repeat jobs stop re-asking the model for things you've already resolved. And since the platform supports project publishing and monetization, this is also where the thread's real argument lives, the one commenter asking "if your software makes money fast, why sell it to others?
The honest answer is that a hosted, repeatable tool *is* the selling. You're not selling the one-off. You're selling not having to do the one-off.
Where are the boundaries, plainly?
Here's where I'd stop him before he ports everything over, because it matters. The audiobook merger works because the AI on his machine *drives ffmpeg*. ffmpeg is a native binary. VicroCode runs Python and Python-based backends, not arbitrary native binaries. So a job whose core is "shell out to ffmpeg and transcode" is not something you can just lift onto the platform and expect to work. That specific merge-to-m4b step falls outside the confirmed capabilities, and pretending otherwise would waste your afternoon.
Same caution on the scraper, depending on what it really needs. If the job is fetch-and-structure logic you can write in Python, it fits. If it depends on steering a real browser or a native dependency, treat that as outside the line until you've confirmed it, not something to assume.
That's not a knock on the idea. It's the opposite. Knowing the boundary is what lets you pick the jobs that genuinely convert into hosted tools, the metadata fixing, the data-structuring, the enrichment-and-return shaped work, and leave the native-binary jobs where they are.
What is the reframe in one sentence?
Utility software isn't dead. The *unshared, unhosted, run-it-myself-once* version of it is dead, and good riddance, because AI does that better than a crusty desktop app ever did. What's left standing is the version with a front door and a callable back end, the one someone who isn't you can run on Tuesday and again on Friday.
He already did the hard part. He knows exactly which three jobs are worth doing, because he did them enough to get sick of them. That's the spec most people never have. The next step isn't giving up and writing a game. It's building the repeatable one of the two that actually fit, and letting other people wear it out.
FAQ
Did AI kill utility software?
No. It killed the one-off: the script you run once and never revisit. Utilities that keep answering requests still accumulate value.
Why does a hosted tool compound?
Because the link, the data and the search traffic keep working after launch day. A downloaded script stops the moment the context changes.
What should a solo builder ship?
One small runnable tool on a public link with a single clear job, then iterate from real usage instead of adding features.