I think we’re in a personal software era. Not just in an “everyone is launching startups” way, although that’s happening too. A lot of people are shipping into saturated markets and finding out quickly that building is easier than selling in some cases.

For a long time, if you had a niche need, you had two options: adapt your workflow to a SaaS product, or spend weeks building something from scratch. Most people just adapted. It was cheaper to live with friction than to remove it.

It really seems like that tradeoff is changing quickly with LLM agents.

With LLMs in the loop, the cost of trying ideas has collapsed. A capable builder can now cover a lot more surface area in less time, and that changes behavior. Instead of asking “what tool should I buy?” more people are asking “should I just build this?”

And increasingly, the answer is yes.

You can see it everywhere right now. People are building their own MCP servers to expose internal tools exactly how they want. People are building workout apps that match their actual training style instead of forcing themselves into someone else’s template. People are building budgeting apps that reflect their real categories, habits, and goals instead of bending to a generic model.

None of these products need to be massive companies to be successful. They just need to work for the person using them.

That’s why this feels different from previous “build your own tool” moments. The barrier is lower, the feedback loop is tighter, and shipping personal software no longer feels like a side project you might finish someday. It feels normal.

This doesn’t mean engineering suddenly became easy. It means the hard part moved. Err, is moving?

A lot of the old setup effort is getting commoditized: scaffolding, repetitive UI work, basic CRUD flows, and routine integration glue. The harder part now is deciding what matters, shaping the product around a real workflow, and knowing when generated code is confidently wrong. Taste, context, and judgment matter more, not less.

And it’s not just the basic stuff getting condensed. Last July, I spent about $5 in Claude Code and had a full pan-and-find tornado finder feature for Tornadic end-to-end in around 20 minutes, API and frontend included. Doing that manually would have taken me at least a full day.

That was my first real “holy shit” moment with this stuff. I started joking with friends that it felt like a drug, because I couldn’t believe how well it worked, how fast it happened, and that I paid five bucks for the whole thing.

This also shifts how open source gets consumed.

It’s going to change open source more dramatically than we want to admit. In a lot of categories, fewer people will adopt OSS projects out of the box because building a tailored version yourself is increasingly cheap. I’m not sure “scaffolding app” is the right mental model anymore if people can generate the shape they need on demand.

The collaboration doesn’t disappear, though. It shifts. People will still come together around the parts that remain genuinely hard: core primitives, deep domain logic, reliability, data models, security, and the systems work that can’t be faked with a nice demo.

If this trend keeps going, a lot of software categories are going to feel real pressure. Not because SaaS disappears overnight, but because the baseline expectation changes. People won’t just ask “does this work?” They’ll ask “is this better than what I can build or adapt for myself this weekend?”

That’s a brutal comparison, and it’s new.

And to be clear, none of this is stable yet. Models are improving fast, agent workflows are still messy, and the way we build with these tools keeps changing every few months. Some of this take is almost guaranteed to age badly (for many reasons, probably :p).

Still, the direction feels obvious to me: more personal tools, more disposable apps, and more software shaped around individual workflows instead of one-size-fits-all products.

I don’t think the floodgates are opening. I think they already opened.