Formable

Every piece of software you use is somebody else's frozen answer to a problem they decided was worth answering.

That isn't a complaint. Frozen answers are great. Someone thought hard, built the thing, and now you don't have to. The whole industry runs on it and mostly that's good.

But freezing has costs, and they're easy to miss, because they show up as absence.

The solution floor

Every tool has a minimum viable problem.

Below that line there isn't bad software. There's no software. The problem is real, recurring and annoying, and it simply never crossed the threshold where anybody would build for it, so it lives in a spreadsheet, or a script, or your head.

You can't browse this. There's no category page for the things nobody made. So the floor stays invisible, and everything underneath it gets quietly absorbed as "work."

My guess is that most of what you actually do on a computer sits below the floor.

The other failure

Above the floor there's a different problem, and it's sneakier.

Software has an opinion about your problem. It has to. To ship a solution you have to decide what the problem is, and you decide it for the median customer, because that's who pays.

So the tool shows up with a shape, and whatever part of your work doesn't match that shape gets bent. You rename your stages to match its stages. You keep the thing it can't hold in a side doc. You develop workarounds, then you train new people on the workarounds, and after a while nobody remembers which parts of the process are the work and which parts are the software.

Fitting yourself to your tools is so normal it doesn't register as a cost. It's just what using software feels like.

And problems move

Then the third thing. A solution is frozen at the moment it shipped, and problems don't hold still.

Fit decays. The team changes, the market changes, the rules change, and the tool that fit two years ago is now a slightly wrong shape you're carrying around. Vendors fix that on their schedule, for their median customer, which is to say not for you.

Between the floor, the bending and the decay, the band of problems that software serves well is a lot narrower than the software industry makes it look.

A tool for forming solutions

So here's the shift I care about.

Instead of building another tool that is a solution, build a tool for forming solutions — around whatever problem you actually have, at whatever size it happens to be.

Any size cuts both ways.

Downward: the second-Tuesday review, the check you always forget, the one-off analysis you'll want twice. Too small to fund, big enough to matter.

Upward: the tangled one that spans six apps and belongs to no category, so no vendor can own it end to end. Right now the integration layer for that problem is a person, holding it in their head, re-deriving it every morning.

Neither has a product, and it's the same reason both times. The shape of software has been set by the economics of distribution rather than by the shape of problems.

What forming requires

If you're going to form solutions instead of buy them, three things have to be true, and none of them is "the model got smart enough."

Ground that lasts. What you make has to survive the conversation that made it, and the model that made it, or you haven't formed anything.

Pieces that combine. Any output has to be able to become an input. Otherwise you're not forming solutions, you're generating one-offs.

Limits you can state. A formed thing needs an envelope you can describe and supervise, or you won't trust it enough to run it a second time.

Formable is the property you want. Those three are the price.

The posture change

The old loop was: notice a problem, go looking for a solution, evaluate, adopt, adapt yourself, tolerate.

The new one is: notice a problem, describe it, look at what comes back, shape it, keep it. And when the problem moves, move the thing.

The subtle part isn't the loop though. It's that you stop pre-filtering.

Right now you don't even register most of your problems as problems, because you've internalized the floor. You know there's nothing out there to go find, so you stop looking, and the thing gets quietly reclassified as just how it is.

Drop the floor to zero and that reclassification stops happening. Which I think is the real unlock. Not the software you'll make, but the problems you'll let yourself notice once making is cheap.

P.S. Try this. Write down five annoying things from last week that you never once considered fixing. Notice how fast the list comes, and how long it's been since you thought of any of them as solvable.