DEV Community

Cover image for The Internet Could Have Looked Very Different. So Could Everything We're Building Today.
David Shemang
David Shemang

Posted on

The Internet Could Have Looked Very Different. So Could Everything We're Building Today.

Some thoughts on Gopher, the early web, and why the best technology doesn't always win.

I've been building software since 2017, and one thing I've gradually come to appreciate is that the technologies we use today aren't necessarily the only ways things could have worked.

We often look at successful technologies in hindsight and assume their success was inevitable.

The web was always going to be the web. Smartphones were always going to look like smartphones. Cloud computing was always going to become the default way we deploy software.

But history tells a slightly different story.

Some of the technologies that now seem obvious were once competing against alternatives that were just as promising, sometimes even better suited to the conditions of their time.

I was recently reading about the early internet, and I came across something fascinating.

There was a time when the World Wide Web wasn't the obvious future of the internet.

In fact, one of its strongest competitors was a system called Gopher.

And the story of what happened to Gopher says quite a lot about technology, business, and the decisions we make as builders today.

Before the Web Became the Web

Think about how you use the internet today.

You open a browser, type an address, click a link, and move from one website to another. You barely think about what's happening underneath.

We take hyperlinks, web pages, and browsers for granted because they're practically inseparable from our experience of the internet.

But in the early 1990s, things were different.

The internet already existed, but there wasn't yet a universally dominant way for ordinary people to navigate information on it.

One of the popular systems at the time was Gopher, developed at the University of Minnesota.

Gopher didn't work like the modern web.

Instead of visually rich pages filled with images, buttons, and hyperlinks, it presented information through hierarchical, text-based menus.

You selected a category, opened another menu, and continued navigating until you found what you needed.

It sounds primitive now, but consider the environment it was built for.

Internet connections were painfully slow. Computing resources were limited. Downloading even a single image could be an exercise in patience.

In that environment, a lightweight, text-first system wasn't necessarily a bad idea.

It was practical.

And that's something I find interesting about engineering. A solution can make perfect sense within the constraints of its time and still end up being the wrong foundation for the future.

The Decision That Changed Everything

In 1993, something important happened.

The University of Minnesota announced licensing arrangements for commercial uses of its Gopher server software.

Around the same period, CERN made the World Wide Web technology freely available.

It's tempting to reduce what happened next to a simple story: one technology charged money, the other was free, and the free one won.

But I think that explanation misses something.

The web wasn't merely competing on cost.

It introduced a fundamentally different way of organising and connecting information.

With Gopher, information was largely organised through menus and directories.

With the web, documents could link directly to other documents.

A piece of information didn't have to exist only within a predefined navigation structure. It could point somewhere else, and that destination could point somewhere else again.

That sounds like a small architectural distinction.

But it changed what people could build.

The web made it possible for information to grow through connections rather than depend primarily on centrally organised hierarchies.

And because the underlying technology was freely available, developers and organisations could experiment without having to negotiate access to the foundation.

Gopher didn't disappear overnight, and licensing wasn't the only reason the web overtook it. But the contrast illustrates something I've come to believe strongly:

The architecture of a technology determines what is possible. Its distribution model often determines how far those possibilities can spread.

As engineers, we tend to spend a lot of time thinking about the first part.

As founders, we cannot afford to ignore the second.

Being Early Is Not the Same as Being Right

Another interesting example from that period is Apple's Newton.

Apple introduced the Newton MessagePad in 1993, long before smartphones and tablets became everyday devices.

It was a handheld computer with features that now sound familiar, including personal information management and handwriting recognition.

The ambition was impressive.

The execution, particularly the handwriting recognition, was less convincing.

The technology struggled with the expectations placed on it, and the Newton eventually disappeared from Apple's product lineup.

Years later, handheld computing became one of the most important categories in consumer technology.

So was the Newton a bad idea?

I don't think that's the most useful question.

The more interesting question is whether the surrounding technology, market expectations, and user experience were mature enough to support the idea.

You can correctly anticipate where an industry is going and still build a product that fails.

That's a difficult reality for founders.

We often talk about being early as though it's automatically an advantage.

Sometimes it is.

But being early can also mean spending years trying to convince customers to adopt something they don't yet need, cannot comfortably use, or aren't willing to pay for.

And while you're doing that, the economics of keeping the business alive don't disappear.

A product can be ahead of its time and still be a poor business at the time it exists.

Those two things aren't contradictory.

What This Makes Me Think About AI

I find these stories particularly relevant to what's happening with artificial intelligence today.

We're currently in a period where almost every week introduces a new model, framework, agent platform, or approach to building AI-powered applications.

There is enormous excitement around what these systems can do.

And understandably so.

But I sometimes wonder how many of the architectural decisions we're making today will look obvious ten years from now, and how many will look like Gopher.

Consider AI agents.

Right now, there's considerable attention on systems that can reason, use tools, execute workflows, and perform tasks with increasing autonomy.

But we haven't settled on what the dominant architecture for these systems will look like.

Will businesses interact with agents primarily through conversational interfaces?

Will agents operate quietly behind existing software?

Will they communicate through shared protocols?

Will orchestration become a distinct infrastructure layer, or will much of it be absorbed into existing platforms?

I don't think anyone can answer all of these questions confidently yet.

And that's precisely what makes this period interesting.

In my work with conversational AI and workflow automation, one distinction I keep returning to is the difference between a system that can demonstrate a capability and one that can deliver that capability reliably in a business environment.

An agent successfully completing a task during a demonstration is encouraging.

But production introduces a different set of questions.

What happens when an external API fails? What happens when the user changes their mind halfway through a workflow? How does the system recover from an incomplete action? When should it stop trying and involve a human?

And perhaps most importantly, does the value of automating the task justify the cost and complexity of running the system?

These questions aren't as exciting as announcing a new autonomous agent.

But they're often what determines whether a product becomes useful infrastructure or remains an impressive experiment.

The Best Technology Doesn't Always Win

There's a tendency among engineers to believe that better technology should naturally produce a better outcome.

If a system is faster, more scalable, more elegant, or technically superior, surely it should have an advantage.

And often it does.

But technical quality is only one part of the equation.

A product also needs distribution.

It needs an adoption path.

It needs an economic model that works.

It needs to fit into the environment where customers will actually use it.

And sometimes it needs a little luck.

The history of technology is full of products that were impressive but failed to become commercially significant.

It's also full of technologies that succeeded despite limitations their competitors didn't have.

That doesn't mean engineering quality is irrelevant.

It means technical superiority doesn't automatically translate into market leadership.

For someone building a company, that's an important distinction.

You can spend months perfecting an architecture while another team builds something less sophisticated, gets it into customers' hands, learns faster, and establishes a distribution advantage.

Of course, moving quickly with a poor technical foundation creates its own problems.

The challenge is finding the right balance.

Build enough to deliver real value. Design carefully where failure would be expensive. Avoid complexity that doesn't yet solve a meaningful problem.

And keep paying attention to the market.

Because the market doesn't reward engineering elegance in isolation.

The Strange Thing About Progress

There's one more aspect of this history that I find fascinating.

Despite everything we've achieved in digital technology, people are increasingly interested in older, analogue experiences.

Vinyl records, film cameras, and other retro devices continue to attract people who didn't necessarily grow up using them.

At first, that seems strange.

Why would someone choose a less convenient technology when a more efficient alternative exists?

But perhaps efficiency isn't the only thing people value.

Sometimes people care about the experience itself.

The physical interaction. The limitations. The sense of ownership. The feeling that something was made for a particular purpose rather than optimised to do everything.

I think there's a lesson here for software products too.

We often assume that adding more capabilities automatically improves a product.

More features. More automation. More integrations. More intelligence.

But usefulness isn't always proportional to capability.

Sometimes the better product is the one that does fewer things, more predictably, with less friction.

And as AI makes it increasingly easy to generate software and introduce new capabilities, I suspect this distinction will become even more important.

The ability to build more doesn't necessarily mean we should.

What I'm Taking Away From This

The Gopher story isn't really about an obsolete internet protocol.

At least, that's not what makes it interesting to me.

It's a reminder that technology evolves through decisions made under uncertainty.

Engineers choose architectures based on the constraints they understand.

Founders choose business models based on the markets they can see.

Companies make strategic decisions without knowing which assumptions will still hold five or ten years later.

And sometimes, a decision that seems reasonable today becomes the reason a technology struggles tomorrow.

I don't think there's a formula for avoiding that.

But I do think it should make us more thoughtful about what we're building and why.

Are we solving a problem that matters today, or betting entirely on a future that may take longer than expected to arrive?

Are we designing systems that others can adopt and build upon?

Are we mistaking technical sophistication for customer value?

And are we building something people will continue to find useful after the excitement around the technology fades?

These are questions I find myself returning to as I move further from simply writing software into building products and companies.

Because ultimately, we're not just choosing technologies.

We're making bets about how people will work, communicate, transact, and interact with software in the future.

Some of those bets will turn out to be right.

Others won't.

And twenty years from now, someone might look back at what we're building today and wonder how close the world came to turning out very differently.

Top comments (0)