Most people never think about why we call it software. The name just feels obvious.

But it wasn’t.

The word reportedly started as a joke, a tongue-in-cheek contrast to hardware. In 1958, nobody knew what to call this new invisible thing that told machines what to do. It wasn’t mechanical. It wasn’t physical. You couldn’t tighten it with a wrench.

So they called it soft.

Not soft like a pillow. Soft like squishy, malleable, still-forming. It was the part of computing that was fluid, flexible, and easy to change.

At least at first.

”Soft” as in Malleable

When John Tukey used the word in 1958, the defining characteristic of this new phenomenon was simple:

• It wasn’t fixed.
• It wasn’t permanent.
• It was shapeable logic, not metal.

Hardware was steel and silicon. Software was ideas and instructions.

Early software embodied that. It was easy to change. A small team could rewrite an entire system in weeks. A single engineer could transform an application overnight.

Soft was the whole point.

Then Software Started Eating the World

And when demand outgrew the simplicity of early codebases, the nature of software shifted. Almost simultaneously across the industry:

• Codebases grew larger than any one person could hold in their head.
• Software architectures emerged to manage the complexity.
• People were needed to manage parts of those architectures.
• Business structures grew to match software structures.
• Teams expanded into roles: PMs, architects, designers, QA, analysts, scrum masters.
• Releases required planning, alignment, ceremonies, and handoffs.
• Changes became expensive. Refactoring became risky.
• The business depended more and more on digital systems that couldn’t break.
• To justify the investment, more planning, more meetings.

Software became hard.

Hard because of its size. Hard because of the coordination needed. Hard because of the scarcity of people who could work on it. Hard because of the cost of getting it wrong.

The irony is hard to miss:

We named it “software” for its flexibility, then built an industry that made it rigid.

The cost of change rose so high that software felt more like architecture than clay.

Software Is Becoming Soft Again

Agentic programming is, in my opinion, the most significant shift in software production since the compiler. More than the cloud, more than whatever else we’ve hyped over the years.

Now:

• Code generation is cheap.
• Refactoring is safe and reversible.
• Prototyping takes minutes instead of months.
• Documentation and tests stay in sync automatically.
• Ideas can be explored before meetings even happen.
• A single engineer can produce what once required a team.

It feels like we’re moving back to software being malleable.

Back to trying ideas quickly. Reshaping systems rapidly. Evolving designs continuously. Bending the system instead of negotiating with it.

The constraints that made software hard are dissolving:

• Team coordination overhead shrinks.
• The cost of iteration drops.
• The danger of change is mitigated by intelligent tooling.
• Agents handle the drudgery, letting humans shape ideas again.

Software is returning to the fluidity it was named for. It’s becoming soft again.