Soft-En Mhers

As a seasoned software engineer, I might have my own take on technology as a whole.

Before we get into technology, I think we have to go back to the beginning of time. In nature, creation comes first, and evolution follows. Something is created, it adapts to its environment, it becomes more complex, and eventually it creates the conditions for something new to emerge.

I believe technology follows the same pattern.

Technology is rarely created in its final form. It begins with an idea: a solution to a problem, a desire to make something easier, or simply curiosity about what is possible. From there, it evolves. One invention becomes the foundation for another. The wheel enabled transportation. Electricity enabled modern industry. Computers transformed information processing. The internet transformed communication. And software transformed almost every industry that followed.

But there is another part of this evolution that I find particularly interesting.

Some people are born to build a system, while others are born to be in the system.

I don't mean that one is necessarily better than the other. A system needs both. Some people are naturally comfortable following established structures, optimizing within them, and becoming extremely good at operating the system. Others constantly look at the system and ask, Why does it have to work this way? What if we built it differently? What happens if we remove this limitation?

Those people become builders.

As a software engineer, I have always found myself more interested in the second question.

I don't just want to use a system. I want to understand how it works, why it works, where it breaks, and whether it can be built better. That mindset is one of the reasons I believe software engineering is fundamentally different from simply using technology. We are not only consumers of technology; we are participants in its evolution.

And software itself has evolved dramatically.

We started with programs designed to perform relatively simple instructions. Then came operating systems, databases, networks, cloud computing, mobile applications, and eventually artificial intelligence. Each generation built upon the previous one. We didn't simply throw away everything that came before. We abstracted it, improved it, and used it as the foundation for something more powerful.

For decades, however, software remained largely dependent on explicit human instructions.

We wrote the code. We defined the rules. We provided the inputs. The computer executed what we told it to execute.

AI is beginning to change that relationship.

We are moving from software that simply executes instructions toward software that can understand objectives, reason about problems, use tools, make decisions, and take action.

That is a fundamental shift.

We are moving from software that we operate to software that can operate alongside us.

And this is where I believe AI agents become important.

An AI agent is not simply another chatbot or another user interface. It represents another abstraction layer in computing. Instead of telling a system exactly how to perform every individual step, we can increasingly describe the outcome we want and allow intelligent systems to determine how to achieve it.

But just as every technological evolution creates new capabilities, it also creates new complexity.

When companies had only a handful of applications, managing software was relatively simple. As organizations accumulated hundreds of applications, we created cloud platforms, DevOps, observability, orchestration, and project-management systems to manage that complexity.

Now we are entering another phase.

Companies are beginning to have not just software applications, but AI agents, agents that can perform tasks, interact with systems, use different models, access tools, and potentially collaborate with other agents.

The complexity is no longer only in the software.

The complexity is in the work performed by the software itself.

And this brings me back to the idea of builders and systems.

Every major technological shift creates a new generation of builders. The people who built the first computers created the foundation for software engineers. Software engineers created the internet and cloud infrastructure. Those systems enabled an entire generation of startups and digital businesses.

Now, AI is creating another generation of builders.

But eventually, even the builders will need systems to manage what they have created.

That is the stage I believe we are approaching now.

We will need infrastructure that allows organizations to create, manage, monitor, coordinate, and scale AI agents just as naturally as modern companies manage people, projects, and software today.

So when I look at the evolution of technology, I don't see AI as the end of the story.

I see another beginning.

Creation leads to evolution. Evolution creates complexity. Complexity creates new problems. And those problems create new systems.

And perhaps that is the most interesting part of being a builder.

You don't simply live inside the system. You help create the system that everyone else will eventually live in.