Navigation
Let’s talk Pune, India / Independent developer
All writing

Software isn't dead. It's getting expensive.

AI makes software easier to build, but recurring tool costs can make it harder for students and independent developers to compete.

Software is dead. Developers are dead. Apparently every framework you've spent the last three years learning is obsolete too.

I don't buy it. Software will keep existing, and someone will have to understand why it exists and keep it running. Agents writing more code won't make that responsibility disappear.

What worries me is what it costs to participate.

Prompts still need engineers

We've spent decades trying to make programming less tedious. Higher-level languages let us describe what we want without spelling out every machine instruction. Prompts take another step in that direction.

I see a prompt as another medium for programming. It changes how we ask for software, but the result still needs engineering. Someone has to check what the agent built, secure it, and work out why it fails under load. Someone has to understand what the hell is happening underneath the abstractions.

I expect developers who can direct agents and understand the systems they build to have plenty to do. The job will change. I don't think it will disappear.

But that leaves another question. Who can afford the tools we're increasingly expected to use?

The compiler didn't need your credit card

There was something I loved about getting into software. A laptop, an internet connection and an unreasonable amount of curiosity could get you a long way.

Documentation was public. People answered questions on forums, wrote tutorials and shared the source code for things they'd built. If you wanted to understand a tool, you could often read the tool itself.

Free alternatives mattered. You could use Linux instead of buying an operating system. You could use Blender without paying for a commercial 3D package. You could learn a language and download its compiler without first choosing a subscription tier.

Hardware and internet access still cost money. Plenty of people couldn't afford either. I don't want to romanticise that out of the story. But once you had a usable computer, much of the software you needed to learn and build was available to you.

You could spend an evening breaking something, fixing it, and trying an unreasonable idea. You might fail spectacularly, but at least the compiler wasn't asking for your credit card.

Now imagine a beginner trying to learn agentic development in 2026. Alongside the editor and documentation, there's a recurring bill.

At current US monthly list prices, Claude Pro costs $20 and Ultra costs $200. Free access exists too, but the plans have different usage allowances. Limits also depend on the model and the work you give it.

Those allowances affect how much you can experiment. You can hit a limit halfway through a task, wait for it to reset, or pay for more capacity. An experienced developer might know how to make fewer attempts. A beginner is still learning which attempts are worth making.

A more expensive plan doesn't guarantee better software. Bad requirements remain bad requirements with a larger context window. But having enough capacity to try again can matter when you're learning.

Open models don't make the cost disappear

Open models are a real alternative. They deserve better than a dismissive footnote in this argument.

You can run smaller models on ordinary machines. Whether they do the job you need, at a speed you can tolerate, depends on the model and your hardware. Larger working contexts also need more memory, as Ollama's documentation explains.

So downloading a model and replacing a hosted coding workflow are different jobs. Running several agents or giving a model a large codebase can add demands that your existing laptop doesn't comfortably meet.

For some people, local inference is the right choice. For others, avoiding a subscription means buying a more capable machine.

Congratulations. You've escaped the subscription economy by entering the hardware economy.

Open models still matter because they give us options. They don't make memory, electricity or the time spent setting things up free.

You can build for free. Competing is harder to price.

The old tools haven't vanished. You can still install Linux, open an editor and write Python or Go. Nobody has put a payment terminal in front of the compiler.

The pressure comes from the people you're competing with.

If another developer can afford more model usage, they may be able to test more approaches before you finish the first one. That advantage depends on the work and how well they use the tools. It won't rescue a bad product, and it won't make every task faster.

But when the tools do help, opting out has a cost too. You may spend more of your own time doing work that someone else can delegate. The software remains free to use while the working method that saves you time comes with a monthly bill.

That's the distinction I care about. AI can make an individual task cheaper while raising what you spend to keep up with the people around you.

A company can buy shared infrastructure or treat subscriptions as a routine business expense. A student deciding whether to pay for another month has a different calculation. So does an independent developer whose product hasn't earned anything yet. The same dollar price also means different things depending on where you live.

I worry about that gap more than I worry about whether the next agent can generate another CRUD app.

The layoffs discussion needs some care here. Tool prices alone don't explain staffing decisions, and I don't have evidence that subscription bills are driving layoffs. Companies also care about revenue, demand and how much work a team can deliver.

Still, I think the cost of the whole development process deserves more attention. If agents save engineering time, a company might spend less overall even while its model bill grows. It might also reorganise work around the tools. The effect on an independent developer can be quite different from the effect on that company.

Calling all of this the death of software engineering tells us very little about either situation.

I want better agents. I want less time spent on repetitive code. I also want someone with an ordinary laptop to have a fair chance of building something that competes with a well-funded team.

Free tools and open models help preserve that chance. So does sharing what we learn instead of assuming everyone can buy the same setup.

I keep thinking about the next kid with a laptop, an internet connection and an unreasonable idea. They can still build. I want them to be able to keep going when the free allowance runs out.

How much of their chance should depend on a monthly budget for intelligence?