Will Software Ever Be Solved?

The next thing needs you curious, not convinced it's already built.

A year ago, I couldn't build the things I can build today.

I'm a designer, not a developer. But with AI tools I've shipped products that would have taken a team and six months. A year ago I'd never written anything either; this is my third article. AI didn't make me a writer. It just cleared out whatever used to sit between a thought and the page.

I find this genuinely exciting. More people getting their ideas into the world more easily is one of the better things happening right now. But the more I use these tools, the more I keep thinking about what comes after them, and about what we've quietly decided they already mean.

Because there's a story going around. AI can build apps and websites, so developers are unnecessary, so don't bother learning. Software is solved. Just do the product thinking and let the machine build.

It's landing. You see it in the headlines, the hiring freezes, the way students now ask whether learning to code is even worth it.

And for the apps we have today, it isn't entirely wrong. A lot of what used to take real effort now takes a decent prompt and some patience.

But I think we're making a mistake about what that means.

We've been here before. When mobile phones first arrived, someone could have said: we've got payphones, home phones, pagers if it's urgent. Communication is basically solved.

They'd have been right about what existed. What's harder to predict is how restless people are. Curiosity, boredom, the simple itch for something better, they keep pushing us past whatever we've just built. Take the camera. Nobody was suffering without one in their pocket. In 1997, a guy named Philippe Kahn was stuck in a maternity ward waiting for his daughter to be born, and he wanted to share the photos right then. So he rigged his digital camera to his flip phone with a wire from his car phone and some code on his laptop, and sent the first picture of his newborn to a couple thousand people. Their reaction wasn't applause. It was confusion. Nobody could work out how he'd shared a photo while still standing in the hospital, because the idea didn't exist yet.

Then it did. And everyone wanted it. Then they wanted more. Colour screens, music, maps, paying for lunch by scanning a code.

None of it solved a crisis. It happened because someone built a thing nobody had asked for, and the wanting came after. We see what's possible, and only then do we get tired of what we had.

The apps we use today are the payphones. Functional and familiar. And honestly, most people are a little tired of them: the notifications, the dark patterns, the ten-step checkouts, the captchas. That tiredness is usually a signal. It tends to show up near the end of a cycle, not the middle.

Here's what I keep coming back to. Software is the bridge between a person and the machine. It turns what a human wants into something hardware can do.

That bridge gets rebuilt every time things change. Command line: text in, text out. Then the mouse arrived and someone had to invent what it even means to click. Then touch, and the whole grammar changed again: swipe, pinch, pull to refresh. Obvious now. All invented.

Software was never solved. It got rebuilt for every new shore.

And the next shore is big. The screen itself might go away, into space, into the things around us, into something we wear. Nobody knows what "click" is with no cursor, or how an interface tells you it's thinking when there's no screen to show it. Deep problems. Unsolved. A prompt can't build a bridge to a place no one has been. The AI was trained on the bridges that already exist.

And it isn't just the bridges. The language we build them with keeps changing too. A programming language is just how we talk to a computer, and we've reinvented it again and again, each time because the old way couldn't say what someone needed to say.

So maybe a prompt becomes enough to build serious software one day. But that's the surface. Underneath, the harder work continues: new languages, new structures, new ways to tell a machine what you mean. When a problem won't fit the tools we have, a developer doesn't have to force it; they can build a new language shaped for that problem instead. As long as that keeps happening, programming isn't solved.

And we're a long way from that. I'll say it as someone who can't even write real code, which is sort of the point: even from the outside, you can see how much further there is to go.

Building any of this will be harder, not easier. And it won't come from thinking about a problem at a clean distance. It comes from being in the mess, hands dirty, getting it wrong enough times that you notice the thing you'd never have predicted. The insight comes from the doing.

That's the half the "just do the product thinking" story leaves out. AI might be the best execution tool we've ever built, but the everyday version of it remixes what already exists rather than inventing past it. It doesn't get bored, doesn't feel when something's off, can't chase a hunch towards a thing that isn't there yet.

The people who can do that are usually the ones who've gone deep on something and love it enough to sit in the hard part. Good tools carry you a long way now without that depth; I'm proof of that. But it only goes so far. What moves things forward is range across fields and real depth somewhere. The range lets you connect; the depth is what you connect with.

The leaps that change things tend to come from a few of those people together, each deep in their own field, curious about everyone else's, building what none of them could alone. You can't have that room if everyone was told their depth wasn't worth building. The barrier dropping doesn't reduce the need for it. It multiplies it, because far more ideas now reach the point where someone has to ask how to make them real, and genuinely new.

These tools are improving fast, and it's easy to look at that and assume the hard part is closing too. Every new model lands with a benchmark a notch higher than the last, and you watch that line climb and assume it tops out at 100%, and then we're finished. But hitting 100% wouldn't mean finished. It would mean we're finally ready for the next thing. That part rarely gets said.

And the way we talk about it matters. "AI replaces people" points one way. "AI removes the barrier between an idea and trying it" points somewhere else entirely. One is a story about cutting costs, the other about making new things. Same technology, but they invite very different people in, and ask very different things of them.

There's also so much still to do. We call phones and computers solved, and yet huge numbers of people can't really use either. Opening a browser, finding a website, buying something online is second nature to some and bewildering to millions of others. Closing that gap means new hardware, new software, new ways to interact. It's an enormous open space, and I can't understand why we aren't pointing people towards it.

And all of it still needs to be built. Writing code by hand doesn't all have to survive; plenty of manual work has been handed to machines, and mostly for the better. We don't all need to know how a washing machine works to use one. But software isn't a finished appliance. It's the thing almost everything new still gets built with, and it's nowhere near done. Handing the typing to a machine is fine. Letting the understanding of it fade is not, because that understanding is what carries the whole thing forward.

So we need more people who understand software, not fewer. More people writing code, designing, building the structures underneath, arguing about what comes next. How they do it will keep changing, but the need grows, it doesn't shrink. We need a generation curious enough to want in, and maybe to work out what coding itself turns into next. That curiosity is the thing to protect, and right now these tools are marketed as if coding is the one part you no longer have to think about.

If the excitement of getting deep into the details disappears, that's the part I'd miss: the trying, the failing, the what if it worked this way instead. The details were never the boring bit before the idea; they're where the idea comes from.

And this one's personal. I know I'll build things I can't picture yet, and I'll only get there through the experiments, the dead ends, the lucky accidents. Being told today is the ceiling feels like giving up on all that before I even get there. Maybe I'm wrong about all of it. I'd just rather keep going and find out.

Subhankar — Accidental Designer

The Philippe Kahn story is worth reading in full: androidauthority.com