Open letter to Latin American programmers about the future of software

But this letter is not to generate panic. It is to generate clarity.

We don’t program faster. We verify faster.

For decades, the bottleneck to developing software was writing its source code. Translating an idea into instructions that a machine could execute required years of training: learning the syntax of a programming language, design patterns, and data structures. That bottleneck disappeared. Not gradually, but all at once, in less than twelve months.

The new bottleneck is us. Our ability to decide.

An example: Previously, a programmer could spend a week implementing a feature. Today, it can generate ten different versions in an hour. The problem is no longer creating. It is choosing. Which of these ten versions is correct? How do I verify that you haven’t introduced subtle errors? What does it mean to deliver a product that I didn’t write line by line and don’t fully understand?

The question that arises is whether we are really improving our productivity. Maybe we’re really just discovering faster what we don’t want to build.

From the economy of attention to the economy of decision

There is an idea that captures the world we lived in until recently. In 1971, the economist Herbert Simonwho would later win the Nobel Prize, observed that “an abundance of information creates a lack of attention.” For decades, that was the rule: companies, media and platforms competed to capture our focus and increase its retention by creating search engines, music and video recommendation platforms, ads, and notifications. We lived in an attention economy where the bottleneck was the user’s ability to pay attention.

But something changed. When execution becomes instantaneous, attention is no longer the most scarce resource. What is now in short supply is the ability to make good decisions. We are therefore moving towards an economy of decision based on generative AI. And that transition produces fatigue for which we were not trained. A cognitive fatigue, not a physical one. When programming with generative AI, we have more decisions than before, each decision depends on the previous one. Each choice carries consequences that we must anticipate along a chain of reasoning.

The irony is brutal: we can generate code faster than ever, but that same speed drags us into hasty decisions, unnecessarily complex architectures, and subtle hallucinations that go unnoticed.

Why the code and not other fields

Why does this revolution hit programming first and not other disciplines? The answer lies in the very nature of our craft. We have something that other professions do not have: an automatic verifier. This checker comes in the form of a compiler, a command interpreter, or a battery of tests that define whether the code behaves as expected. These systems tell us deterministically whether something works or not.

This generates clearer feedback so that a model of IA learn. It is easier to learn with “right” or “wrong” signals than by interpreting the ambiguities of human behavior. Furthermore, programming languages ​​are formal, with context-independent grammars, much easier to learn than natural language. That’s why models improve so quickly in code generation. And that is why we, those of us who wrote it, are at the epicenter of the earthquake.

Karpathy describes it accurately: we were handed an alien tool with no instruction manual, and we’re all trying to figure out how to hold it while a magnitude nine earthquake rocks the profession.

The new programming language

There is a new layer we must master: how to communicate with intelligent agents, how to give them context, and how to verify their results. It is programming at a higher level, where human language replaces many lines of code.

That’s why human language is becoming the most popular new programming language. Prompts are the new code. And context engineering, the art of injecting the right information so that language models write better code, has become the battleground for defining what really adds real value.

What didn’t change

Here’s the good news: the fundamentals changed less quickly than it seems.

The IA it did not replace programmers. It replaced the programming language as the main interface. But behind every complex system that works correctly there is still a person who defines what to build, who establishes the limits of what is acceptable, who translates ambiguous requirements into precise instructions. Someone has to anticipate what can go wrong and decide what is worth checking. That job didn’t disappear. It became central, at least until now.

The best programmers of the future will be those who clearly navigate the limits between what they know and what they don’t, between what the model can do and what it can’t, between the uncertainty inherent to generative AI and the guarantees that the product needs. In that sense, the skill set needed to write quality software did not go down. He went up.

What it means for Latin America

For our region, this moment has a particular meaning. For decades, the barrier to entry into the global technology industry was access to formal education, infrastructure, and contact networks. Today, a programmer in Lima, Santiago, or Mexico City has access to the same tools as one in Silicon Valley.

Democratization is real. But so is the risk of remaining consumers of technology instead of creators. The question is not whether we can use these tools. It’s whether we can help define how they develop.

Advice for those who come

To young people who want to enter this profession, I say: there has never been a better time. The promise that anyone can code is finally being fulfilled. The gap between having an idea and having a functional system has never been smaller. They can create video games, automate processes, compose music, build applications for smartphones. Things that previously required years of specialization.

To experienced programmers who feel they need to upgrade, I say: your experience is worth more than ever. They have seen many systems work and fail in their years of experience. They have intuition about where things can go wrong. They are like a verifier with much more training data. That experience is a multiplier when combined with these new tools.

To all of you, I ask you to look for communities where you can share experiences and learn from others. Update frequently, because thirty days now feels like an eternity. Focus on fundamentals, design, scalability, and architectures. Learn how to use these tools, but also learn how they work on the inside. Keep an open mind. Embrace change and uncertainty.

But more importantly: rest assured that now you can do more things, faster. Things you may have once thought you would never have the knowledge to do.

The immediate future

In the future, human intelligence will not be measured by accumulated knowledge, but by their ability to enhance their abilities with intelligent systems. This change takes us all starting from scratch. All trying to figure out how to operate this alien tool. The difference between “use AI tools” and “knowing what problem you are solving” today is huge, and no one has all the answers yet.

But that is precisely what makes this moment so extraordinary. For the first time in decades, knowledge is not the only determining factor. Creativity, curiosity, the willingness to experiment, qualities that abound in Latin America, have become competitive advantages.

The real challenge now is learning to think deeply while accelerating execution. In knowing what to ask. In deciding what to build. In staying calm while everything changes at incredible speeds.

Software engineering reinvented itself in one year. We have to reinvent ourselves too.

The future awaits us.