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

    Introducción

    Decimos que construimos software.
    Como si fuera algo sólido. Como si hubiera planos definitivos, materiales estables y un momento concreto en el que alguien pudiera decir: «ya está».

    A los desarrolladores nos gusta pensar que escribimos código y que de ahí sale el sistema: limpio, coherente, casi elegante.
    Los diseñadores definen experiencias, flujos y recorridos que luego enseñamos al cliente.
    Y al cliente le prometemos una solución que cubra sus necesidades de hoy… y las de mañana, si llega el presupuesto.

    La palabra clave es construir.
    Porque suena a control. A previsibilidad. A dominio técnico.

    La realidad es otra.

    No construimos software.
    Lo que hacemos es negociar sin parar con la ambigüedad.

    No implementamos requisitos. Interpretamos frases a medias que alguien soltó en reuniones eternas.
    No diseñamos pantallas. Tomamos decisiones irreversibles a partir de hipótesis que no podremos comprobar hasta dentro de meses.
    No entregamos soluciones. Entregamos apaños provisionales entre plazos, costes, expectativas y deuda técnica.

    El código no es el producto.
    El código es el registro fósil de decisiones humanas.

    Cada línea está ahí porque alguien tuvo que decidir deprisa, porque algo no estaba claro, porque «de momento, esto vale». Y ese «de momento» acaba sosteniendo un negocio entero.

    Y entonces llegó la IA.

    La nueva ilusión es que ahora el software se escribe solo.
    Que la fricción del desarrollo ha desaparecido.
    Que, si el código lo genera una IA, el problema ya no es técnico, sino «solo de ideas».

    Pero la fricción nunca estuvo en teclear.

    La fricción está en decidir qué construir.
    En entender por qué algo no funciona.
    En cargar con las consecuencias de una decisión seis meses después, cuando el contexto ha cambiado y nadie se acuerda de por qué se hizo así.

    La IA no elimina esa fricción. La cambia de sitio.

    Ahora el código sale más rápido, sí.
    Pero también llegan más decisiones, antes y con más ocasiones de equivocarse.
    La complejidad no se reduce: se acelera.

    Por eso el objetivo nunca fue eliminar la fricción, sino ponerla donde importa. Ya no dedicamos el esfuerzo a escribir código, ni siquiera a leerlo línea a línea. Lo dedicamos a los mecanismos que nos dan tranquilidad para subirlo a producción y a decidir si de verdad tiene que existir.

    Alguien tiene que validar.
    Alguien tiene que entender.
    Alguien tiene que decir «esto no».
    Y ese alguien sigue siendo una persona.

    Hemos levantado toda una industria sobre ilusiones compartidas:
    que el software se puede planificar como una obra civil,
    que los requisitos existen antes de empezar,
    que los usuarios saben lo que quieren,
    y ahora, que la IA entiende el problema mejor que nosotros.

    Y, aun así, la ilusión no es un defecto. Es el pegamento.

    Sin ella no habría manera de empezar. Nadie firmaría un proyecto que dijera esto:
    «Durante los próximos 12 meses aprenderemos cosas, cambiaremos de opinión, rehaceremos partes clave y, al final, tendrás algo distinto a lo que te imaginabas, pero seguramente más útil».

    Y, aun así, hay quien firma.

    No porque ignore la ambigüedad, sino precisamente porque la reconoce. No cree en la ilusión del control; cree en la capacidad de adaptarse. Ha pasado por proyectos en los que el plan inicial murió a las primeras de cambio y, aun así, el resultado final fue mejor. Ha visto que el valor no estaba en acertar a la primera, sino en aprender más rápido que nadie.

    Esa gente no compra certezas. Compra criterio.
    No espera promesas cerradas; espera equipos que piensen, que digan «no lo sé» a tiempo y que sepan corregir el rumbo sin dramas. No busca que no haya riesgo, sino a alguien que ya haya pasado por ahí y haya vuelto con cicatrices que sirven de algo.

    Para ellos, la ambigüedad no es una amenaza.
    Es una señal de honestidad.

    Porque saben que el riesgo de verdad no es no saber.
    El riesgo de verdad es hacer como que se sabe.

    Son los que han visto hundirse proyectos no por falta de talento, sino por exceso de confianza. Los que han aprendido que una hoja de ruta rígida tranquiliza al principio, pero ahoga al final. Los que prefieren un equipo incómodo que hace preguntas difíciles a uno cómodo que repite las respuestas de siempre.

    Con esa gente no «construyes» software.

    Construyes confianza.

    Y, a partir de ahí, el software llega como consecuencia, no como promesa. Cambia, evoluciona, a veces decepciona, pero casi siempre enseña algo útil. No porque estuviera perfectamente diseñado desde el principio, sino porque hubo margen para pensar, frenar y corregir.

    Quizá por eso la ilusión sigue haciendo falta para empezar,
    pero deja de hacer falta para avanzar.

    Al final, lo que sostiene el software no son los planes, ni el código, ni ahora la IA.
    Son las personas que ya han vivido el caos y que, aun así, deciden volver a meterse.

    Así que seguimos diciendo que construimos software.
    Y ahora decimos que lo hace la IA.

    Pero, en realidad, seguimos haciendo lo de siempre:
    explorar, ajustar, equivocarnos, renegociar y volver a empezar.

    La diferencia es que ahora todo va más deprisa.
    Y nuestros errores también.

    Alex Casquete

    (He/Him)

    CMDO-Chief Market Development Officer