Search
  • en
  • es
  • en
    Search
    Open menu Open menu

    Introduction

    We say we build software.
    As if it were something solid. As if there were final blueprints, stable materials and a clear moment when someone could say: “it’s done.”

    Developers like to think that we write code and the system emerges, clean, coherent, almost elegant.
    Designers define experiences, flows, journeys, which we then present to clients.
    We tell clients we will build a solution that covers their current needs… and their future ones, if the budget allows.

    The key word is build.
    Because it sounds like control. Like predictability. Like technical mastery.

    Reality is different.

    We don’t really build software.
    We constantly negotiate with ambiguity.

    We don’t implement requirements. We interpret incomplete sentences spoken in long meetings.
    We don’t design screens. We make irreversible decisions based on hypotheses we won’t be able to check for months.
    We don’t deliver solutions. We deliver temporary compromises between time, cost, expectations and technical debt.

    Code is not the product.
    Code is the fossil record of human decisions.

    Every line exists because someone had to choose quickly, because something wasn’t clear, because “this will do for now.” And that “for now” ends up holding an entire business together.

    And then AI arrived.

    The new illusion is that software now writes itself.
    That the friction of development has disappeared.
    That if an AI generates code, the problem is no longer technical but “just about ideas.”

    But the friction was never in the typing.

    The friction is in deciding what to build.
    In understanding why something doesn’t work.
    In living with the consequences of a decision six months later, when the context has changed and nobody remembers why it was done that way.

    AI doesn’t remove that friction. It moves it.

    Code appears faster now, yes.
    But so do more decisions, earlier, with a larger surface for error.
    Complexity isn’t reduced: it’s accelerated.

    That’s why the goal was never to remove friction, but to put it where it matters. We no longer spend the effort writing code, or even reading every line of it. We spend it on the mechanisms that make us comfortable shipping it, and on deciding whether it should exist at all.

    Someone has to validate.
    Someone has to understand.
    Someone has to say “not this.”
    And that someone is still human.

    We have built an entire industry on shared illusions:
    that software can be planned like civil engineering,
    that requirements exist before you start,
    that users know what they want,
    and now, that AI understands the problem better than we do.

    And yet the illusion is not a flaw. It is the glue.

    Without it, it would be impossible to begin. Nobody would sign a project that said:
    “Over the next 12 months we will learn things, change our minds, rewrite key parts, and at the end you will have something different from what you imagined, but probably more useful.”

    And yet some people do sign.

    Not because they ignore the ambiguity, but precisely because they recognize it. They don’t believe in the illusion of control; they believe in the ability to adapt. They have been through projects where the initial plan died early, but the final result was better. They have seen that the value wasn’t in getting it right the first time, but in learning faster than everyone else.

    These people don’t buy certainty. They buy judgment.
    They don’t expect closed promises; they expect teams that think, that say “I don’t know” in time, and that can correct course without drama. They aren’t looking for the absence of risk, but for people who have already navigated it and come back with useful scars.

    For them, ambiguity is not a threat.
    It is a sign of honesty.

    Because they know the real risk is not not knowing.
    The real risk is pretending to know.

    They are the ones who have seen projects fail not from a lack of talent, but from an excess of confidence. Those who have learned that a rigid roadmap reassures at the start but suffocates at the end. Those who prefer an uncomfortable team asking hard questions to a comfortable one repeating old answers.

    With those people, you don’t “build” software.

    You build trust.

    And from there, software appears as a consequence, not as a promise. It changes, it evolves, it sometimes disappoints, but it almost always teaches something useful. Not because it was perfectly designed from the start, but because there was room to think, to slow down and to correct.

    Maybe that’s why the illusion is still necessary to begin,
    but stops being necessary to move forward.

    In the end, software isn’t held up by plans, or code, or now AI.
    It is held up by people who have already lived through the chaos and, even so, decide to go back in.

    So we keep saying we build software.
    And now we say AI does it.

    But in reality we keep doing what we have always done:
    explore, adjust, get it wrong, renegotiate and start again.

    The difference is that everything goes faster now.
    And so do our mistakes.

    Alex Casquete

    (He/Him)

    CMDO-Chief Market Development Officer