The Future of software has already begun

Three years ago, when I started my Computer Science degree, I was taught how software is built in a world where AI was not yet seen as a real threat. Because of that, I learned in a very hands-on way how important classic frameworks and development models were for turning software ideas into something real.

One example is the waterfall model, where you were expected to follow a very clear sequence of steps: gather requirements, design the solution, write the code, test it, and then deal with the never-ending maintenance phase.

The waterfall model aged badly, but a lot of what came after it was still built on the structure it helped validate. For a long time, building software meant following processes, respecting each phase, and most importantly, designing in advance what would only be implemented later.

But the world changed.

I’ve been reading and following what’s happening very closely. This past week especially, I went deep into articles about how AI is changing the way code is created, and I studied what the main tools in the industry are doing to improve their products for a world increasingly shaped by AI.

And here’s the truth about the biggest insight I’ve had while following the tech world right now: no one, absolutely no one, is fully sure about what’s happening.

At the end of the day, almost everything we see and hear right now is still a bet.

The internet

Recently, I watched the series that portrays the legal battle involving television and Google Earth, set between the 1990s and the 2010s, at the beginning of what would become the internet as we know it today. And honestly, I think we are living through something very similar.

Back then, everything people said about the internet was mostly guesswork. The so-called experts working in telecom and technology had no real idea of what was actually coming. Even so, everyone had an opinion. Some were more optimistic, others more pessimistic.

What I take from that is simple: real transformation does not ask for permission. Even in the middle of uncertainty, some people built fortunes, others lost ground, but adaptation happened anyway. It can be uncomfortable, but it is also natural.

What matters now

In the middle of all this uncertainty and speculation, there is one thing that already feels very clear to me in 2026: a big part of what I studied in college three years ago, and what is still being taught today, no longer fits the future that is already knocking at the door.

And I say that carefully.

This does not mean everything we learned has lost its value. It means the practical logic of how software is built is changing faster than universities, courses, and even a good part of the market can keep up with.

Remember that stage where you were supposed to prototype a solution in high fidelity using tools like Figma?

For students and people just starting out in the field, I need to say this very directly: that no longer exists in the same way many people were taught.

The big shift

The first point is this: between November and December of 2025, we saw a major improvement in language models built for coding. And that changed the game in a big way.

A lot of specialists who used to reject AI because of the poor quality of generated code started using it actively. Not because it became trendy, but because the quality improved to a point where ignoring these tools started to feel unproductive.

The practical impact of that is huge.

Generating code has never been easier. You no longer need to wait for a perfect design before you start building. Your next product no longer depends, necessarily, on a long design and diagramming phase done with the same level of rigor as before.

Now, in many cases, a business idea goes straight from someone’s head into a prompt. And that prompt can already generate, automatically, a large part of the code needed for a functional first version of the solution.

That does not remove the need for thinking. But it completely changes the order of things.

When code comes before design

Maybe one of the most interesting changes in this new moment is exactly that: in many cases, code now comes before the polished interface.

That breaks a logic that was taught for years. Before, the traditional flow was to think, design, validate visually, and only then implement. Now, in many contexts, the opposite is starting to happen: you build a functional version first, validate it quickly, and only then improve the interface with more precision.

And that brings us to Figma.

MCPs are here to stay

At the end of 2024, Anthropic introduced an open-source communication model for LLMs called MCP.

I am not going to get into a detailed technical explanation of how MCP works here, because that deserves a text of its own. But the important point right now is something else: the way this kind of structure is already affecting the daily work of people who build software.

And a lot.

Remember Figma?

Figma, which I mentioned earlier, has been releasing improvements to its MCP server and related features throughout 2025 and 2026, and those updates reinforce exactly the shift I mentioned above.

In practice, tools already exist that let you turn the UI code of a product into a high-quality Figma prototype.

I literally managed to send this entire blog project into a clean, fully usable file with a prompt.

All of this points to a trend that seems clearer and clearer to me: code comes first, and only after that do we think about refining the UI in high fidelity.

On top of that, Figma itself now has prompt-based features for generating canvases and screen structures. For anyone who started college just a few years ago, that would have sounded almost absurd.

The 2023 freshman version of João would have lost his mind if he knew it would be possible to create and validate entire screens by writing just two lines of prompt: “Using this Figma file: [Figma file URL], create a new settings page, use auto layout, and use our existing components.”

What no one tells you in college

If you are at the beginning of your degree and studying Product Design or UI, I honestly recommend keeping a close eye on what tools like Figma are doing.

Not because college has stopped mattering, but because there is a growing gap between what is still being taught in a traditional way and what is already happening in practice inside the tools that are shaping the market.

Reading Figma’s documentation, following product updates, watching how these companies are positioning themselves, and understanding new workflows may teach you more about the future of software development than a lot of content still stuck in older ways of thinking.

And that applies not only to design, but also to development, product, automation, and team collaboration.

What excites me about all of this

In the middle of all this uncertainty, there is one thing that excites me a lot: no one has ready-made answers.

And to me, that is great.

In a world where no one knows exactly what is happening, there is also an entire universe of new possibilities and new things waiting to be built.

You know the story of the Agile Manifesto, created by “a few guys” in 2001 out of pure necessity, in response to new dynamics in the software market?

I think we are living through a moment like that again.

New professions will appear. New methodologies will emerge. New specializations will be created to solve problems that, right now, do not even exist yet.

And the questions keep coming:

• What is the role of the new Computer Science student in society?
• What should they actually be studying today?
• When and how will AI become truly accessible to the broader public?
• How will AI reshape the traditional SaaS market?
• What will development teams look like in this new reality?

There are still so many unanswered questions.

And honestly, that excites me a lot.

Maybe it should excite you too.

Because in a time when no one has ready-made answers for anything, this may be exactly the moment to discover, test, and build things that could shape the next few decades.

---

This article purpose was to generate reflexions above of answers but don't worry, many more articles on related topics to come, stay tuned!