La velocidad llega, la satisfacción se discute
El 20 de noviembre de 2026 se publica un reportaje que pone el foco en una paradoja que recorre hoy los equipos de software de medio mundo: las herramientas de programación con inteligencia artificial hacen que los ingenieros entreguen más y más rápido, pero una parte de los desarrolladores confiesa que echa de menos el esfuerzo y la satisfacción que antes acompañaban al oficio. La tensión no es anecdótica. Se produce en un momento en que la adopción de estas herramientas ya no es una rareza de entusiastas, sino la norma de la profesión.
Los datos de contexto ayudan a medir la escala. La encuesta anual a desarrolladores de Stack Overflow correspondiente a 2026, cuyos resultados se difundieron en octubre, indica que más de ocho de cada diez encuestados utiliza al menos una herramienta de IA en su trabajo. Dicho de otro modo, quien hoy escribe software sin ningún apoyo de este tipo es ya una minoría. La conversación, por tanto, ha dejado de ser si conviene adoptar estas herramientas y se ha desplazado hacia cómo cambian el trabajo, qué habilidades premian y qué se pierde por el camino.
En las grandes tecnológicas el cambio es todavía más visible. Google afirmó en abril de 2026, durante su evento de nube celebrado ese mes, que alrededor del 75 % del código nuevo que se escribe en la compañía lo genera la IA y luego lo revisan y aprueban ingenieros. Según las cifras que la propia empresa ha ido comunicando, ese porcentaje era cercano al 50 % en el otoño de 2025 y rondaba el 25 % en octubre de 2024. La curva sugiere que el papel del programador se desplaza desde la escritura directa hacia la dirección, la revisión y la responsabilidad sobre el resultado.
Sobre el efecto en el mercado laboral puedes leer el impacto de la inteligencia artificial en el empleo de programadores, la postura de Uncle Bob y por qué dejó de leer código generado y el dato de que los agentes ya inician el 40 % de los pull requests.
Este artículo repasa ese desplazamiento con un enfoque práctico. Se examina qué dicen las cifras y qué no dicen, cómo se transforma la profesión, por qué algunos desarrolladores sienten una pérdida real, qué ocurre con la revisión de código cuando la mayor parte del texto lo produce una máquina, qué habilidades ganan valor y qué consejos concretos pueden aplicar los desarrolladores, tanto júnior como sénior, para sacar partido a las herramientas sin vaciar de sentido su trabajo.
Qué dicen realmente los números
Conviene empezar por la cautela, porque las cifras de adopción de IA se citan a menudo sin matices. Cuando una encuesta señala que más del ochenta por ciento de los desarrolladores usa alguna herramienta de IA, se está midiendo uso, no profundidad ni dependencia. Una persona que consulta a un asistente conversacional una vez al mes cuenta igual que otra que trabaja a diario con un agente que modifica varios archivos a la vez. La cifra es útil para entender la extensión del fenómeno, pero poco informativa sobre la intensidad.
Algo similar ocurre con el dato de Google. Que el 75 % del código nuevo sea generado por IA y revisado por ingenieros describe quién redacta el primer borrador, no quién responde por él. El propio enunciado incluye la revisión humana como parte inseparable de la afirmación: no se dice que las máquinas programen solas, sino que el borrador procede de ellas y que una persona valida lo que se incorpora. Además, la cifra se refiere al código nuevo, no al conjunto de una base de código acumulada durante décadas, y la definición exacta de qué cuenta como código generado no es pública en todos sus detalles. Por eso es sensato tratarla como un indicador de tendencia y no como una medida precisa.
Aun con esas reservas, el orden de magnitud importa. Pasar de aproximadamente una cuarta parte a tres cuartas partes en algo más de año y medio indica que, en un entorno con herramientas internas muy integradas, la producción de texto de programación se ha vuelto barata. Cuando algo se abarata, el cuello de botella se traslada a otro lugar. En el software, ese lugar es la comprensión, la verificación y la decisión sobre qué construir.
Hay una lectura adicional que merece atención: las encuestas miden lo que los desarrolladores dicen hacer y sentir, y la percepción de velocidad no siempre coincide con la velocidad medida de extremo a extremo. Escribir más código en menos tiempo no equivale a entregar valor más rápido si el tiempo ahorrado se consume después en depurar, revisar y corregir. Los equipos más maduros miden plazos de entrega, tasa de defectos y tiempo de revisión, y no solo líneas producidas.
Cómo cambia el día a día del ingeniero
El flujo de trabajo típico de hace pocos años partía de un problema, un editor y una documentación abierta en otra pestaña. El ingeniero pensaba la solución mientras la escribía, y el propio acto de teclear servía de espacio para descubrir detalles: un caso límite olvidado, una interfaz incómoda, una función que convenía dividir. Hoy ese flujo se ha reordenado. Muchos profesionales describen un ciclo en el que formulan la intención, reciben una propuesta, la leen, la ajustan o la descartan y repiten.
Ese ciclo comprime tareas que antes consumían horas. Generar andamiaje, escribir pruebas repetitivas, traducir una API de un lenguaje a otro, redactar migraciones sencillas o explorar una biblioteca desconocida son trabajos en los que el ahorro es palpable. También hay un efecto sobre la barrera de entrada a terrenos nuevos: un desarrollador de servidor puede adentrarse en una interfaz web, o al revés, con una asistencia que reduce el coste inicial de aprender las convenciones locales.
Sin embargo, el ciclo cambia también la naturaleza de la atención. Escribir exige una concentración sostenida y generativa; revisar exige una concentración crítica y, a menudo, más fragmentada. Quienes trabajan con agentes que producen cambios extensos describen jornadas llenas de decisiones pequeñas de aceptación o rechazo, con menos momentos de inmersión larga. Algunos lo viven como una mejora, porque se libran de la parte tediosa. Otros lo sienten como una pérdida del estado de concentración profunda que, para muchos, era justamente lo que hacía atractivo el trabajo.
Otro cambio es la manera de repartir el tiempo dentro del equipo. Si el borrador cuesta poco, la discusión previa sobre el diseño cobra más importancia, porque es ahí donde se decide si lo que se generará tiene sentido. Los equipos que antes saltaban directamente al código descubren que necesitan especificaciones más claras, criterios de aceptación más explícitos y pruebas que describan el comportamiento esperado antes de pedir nada a la máquina.
El duelo por el esfuerzo
El reportaje que motiva este análisis recoge una sensación que se escucha cada vez más en foros, conversaciones de pasillo y comunidades profesionales: la de quienes admiten que la velocidad es real, pero que algo se ha desdibujado. Lo que describen no es nostalgia por herramientas antiguas, sino por una experiencia concreta: la de pelearse con un problema difícil, llegar a entenderlo y resolverlo con las propias manos. Esa satisfacción tenía una raíz clara, porque el esfuerzo y el resultado estaban conectados.
Conviene separar aquí los hechos de las valoraciones. Que algunos desarrolladores manifiesten esa pérdida es un hecho recogido en testimonios; que la pérdida sea general o que compense o no el aumento de velocidad es una cuestión de opinión y de contexto. Hay profesionales que celebran justo lo contrario: se sienten liberados de lo repetitivo y dedican más energía a lo que consideran creativo, como el diseño, la experiencia de usuario o la arquitectura. La experiencia depende mucho del tipo de trabajo, de la etapa de la carrera y de la personalidad de cada uno.
Existe un paralelismo con otros oficios que han vivido automatizaciones parciales. Artesanos, fotógrafos o traductores han descrito en su día sentimientos parecidos cuando una herramienta asumió la parte manual de su práctica. En muchos casos el oficio no desaparece, pero se redefine, y quienes más disfrutaban de la parte automatizada deben encontrar otra fuente de satisfacción o reservar espacios deliberados para practicarla.
Hay además una dimensión de aprendizaje. El esfuerzo no es solo una fuente de placer, también es el mecanismo por el que se consolida el conocimiento. Resolver un error difícil deja huella: el desarrollador recuerda por qué falló, qué hipótesis descartó y qué herramienta le dio la pista. Si la solución llega sin ese recorrido, el beneficio inmediato puede ir acompañado de un aprendizaje más superficial. Para los profesionales con años de experiencia, el riesgo es menor, porque ya cuentan con un modelo mental sólido con el que evaluar lo que reciben. Para quien empieza, el riesgo es mayor.
Revisión de código: el nuevo centro de gravedad
Si buena parte del código procede de un modelo, la revisión deja de ser un trámite al final del proceso y pasa a ser el momento en que se ejerce de verdad la ingeniería. Cuando Google habla de código generado y aprobado por ingenieros, el segundo término es el que sostiene la garantía de calidad. La revisión es el punto donde una persona asume la responsabilidad de que lo incorporado funciona, es seguro y encaja con el resto del sistema.
Revisar código generado tiene particularidades. El texto suele ser fluido, bien formateado y con nombres razonables, lo que transmite una falsa sensación de corrección. Los fallos típicos no son errores de sintaxis, sino suposiciones incorrectas sobre el contexto: una función que existe en otra versión de la biblioteca, una validación omitida en un caso poco habitual, un manejo de errores que traga excepciones, una consulta que funciona con pocos datos y se degrada con muchos. Detectarlos exige entender el dominio y el sistema, no solo leer líneas.
Otro riesgo es la fatiga de revisión. Cuando los cambios son grandes y frecuentes, la tentación de aprobar tras una lectura rápida crece. Un revisor que ha visto cien propuestas correctas tiende a bajar la guardia ante la ciento una. Los equipos que manejan bien este fenómeno limitan el tamaño de los cambios, exigen descripciones claras de la intención y automatizan todo lo que se pueda comprobar mecánicamente, de modo que la atención humana se reserve para lo que las máquinas no verifican bien.
También cambia la pregunta de fondo. Antes, el revisor valoraba si el autor había entendido el problema. Ahora debe valorar además si el propio autor, que quizá no escribió el código, lo entiende. Una práctica sana consiste en exigir que quien envía un cambio sea capaz de explicarlo sin ayuda: por qué se eligió ese enfoque, qué alternativas existían y qué riesgos conlleva. Si no puede, el cambio no está listo, con independencia de que las pruebas pasen.
Por último, la propiedad del código se vuelve un asunto de cultura de equipo. Un código que nadie ha escrito con intención y que nadie comprende en detalle se convierte en deuda técnica difícil de mantener. La regla más simple, y quizá la más eficaz, es que cada línea que entra en el repositorio tiene un responsable humano que puede defenderla.
Habilidades que suben y habilidades que se ponen a prueba
En este escenario, algunas capacidades ganan valor de forma evidente. La primera es la lectura crítica de código: la habilidad de recorrer un cambio ajeno, reconstruir su intención y detectar lo que falta. Durante años se consideró una competencia secundaria frente a la escritura; hoy es central. Quien lee bien, además, escribe mejores indicaciones, porque sabe qué detalles importan.
La segunda es la capacidad de especificar. Pedir a una herramienta que haga algo exige expresar con precisión el comportamiento deseado, las restricciones y los criterios de éxito. Esa claridad se parece mucho a la que se necesita para redactar un buen diseño o una buena prueba. Los desarrolladores que dominan el pensamiento en términos de contratos, invariantes y casos límite obtienen resultados notablemente mejores.
La tercera es el conocimiento de fundamentos. Estructuras de datos, complejidad, concurrencia, redes, bases de datos, seguridad y modelos de fallo no pierden relevancia; la ganan, porque son lo que permite distinguir una propuesta plausible de una correcta. Un asistente puede producir una solución que parece razonable y esconde un problema de rendimiento o de consistencia. Sin una base sólida, ese problema pasa inadvertido hasta que aparece en producción.
La cuarta es la depuración. Cuando el código lo ha escrito otro, o algo distinto a una persona, la capacidad de razonar sobre un fallo a partir de síntomas, registros y trazas se vuelve más importante. Quien depende por completo de que la herramienta arregle sus propios errores se queda sin recursos cuando ella no lo consigue, lo que ocurre con más frecuencia de la deseada en sistemas complejos.
Y hay habilidades que se ponen a prueba. La memorización de sintaxis y de interfaces pierde peso, pero el juicio sobre arquitectura, el criterio de gusto sobre qué es simple y qué es enrevesado, y la comunicación con otras personas del equipo y con el negocio quedan como lo más difícil de sustituir. La ventaja competitiva se mueve hacia lo que requiere contexto, responsabilidad y criterio.
El efecto sobre quienes empiezan
Uno de los debates más delicados es el de los desarrolladores júnior. Tradicionalmente, las tareas pequeñas y bien acotadas servían como escuela: corregir errores sencillos, escribir pruebas, añadir campos a una interfaz. Son justo las tareas en las que las herramientas de IA resultan más eficaces. Si esas tareas se automatizan, surge la pregunta de dónde aprenderán los nuevos profesionales lo que antes aprendían haciéndolas.
No existe una respuesta cerrada y conviene evitar pronósticos tajantes. Lo que sí parece razonable es que las organizaciones tendrán que diseñar de forma más deliberada los itinerarios de aprendizaje: acompañamiento por parte de ingenieros con experiencia, revisión de código como ejercicio formativo, rotación por distintas áreas y encargos en los que se pida explicar y no solo entregar. El riesgo de no hacerlo es formar a una generación que produce con soltura pero no comprende lo que entrega.
Para el propio júnior, la recomendación práctica es tratar la herramienta como a un tutor al que se interroga y no como a un oráculo al que se obedece. Pedir explicaciones, contrastar con la documentación oficial, reescribir a mano fragmentos clave y proponerse resolver sin ayuda ciertos problemas elegidos son hábitos que preservan el aprendizaje sin renunciar a la ventaja de la velocidad.
También es una oportunidad. Quien aprende hoy con asistentes capaces puede abordar proyectos de mayor alcance desde el principio, cometer errores más rápido y recibir retroalimentación inmediata. La clave está en que esa retroalimentación se convierta en comprensión y no en simple copia.
Seguridad, calidad y responsabilidad
La aceleración tiene un coste potencial en calidad si no se acompaña de controles. El código generado puede introducir dependencias innecesarias, patrones inseguros o configuraciones por defecto poco prudentes. No se trata de que la máquina sea especialmente propensa a ello, sino de que produce mucho y deprisa, y el volumen amplifica cualquier fallo que pase la revisión.
Por eso las prácticas de ingeniería habituales cobran más valor. Las pruebas automatizadas deben cubrir el comportamiento, no solo ejercitar líneas. El análisis estático y los escáneres de dependencias y secretos conviene que formen parte obligatoria del proceso de integración. Las revisiones de seguridad han de prestar atención a la entrada de datos, la autenticación y los permisos, que son terrenos donde una solución plausible pero errónea resulta especialmente costosa.
La responsabilidad tampoco se delega. Si un cambio generado por una herramienta causa una caída o una fuga de datos, la responsabilidad profesional y legal recae en las personas y las organizaciones que lo desplegaron. Por eso las políticas internas sobre qué herramientas se permiten, qué datos pueden compartirse con ellas y cómo se registra su uso son una parte cada vez más relevante de la gobernanza técnica. Conviene que esas políticas sean claras y conocidas, porque el uso informal y sin reglas es una fuente habitual de riesgos, desde la exposición de código propietario hasta el uso de fragmentos con licencias incompatibles.
Consejos prácticos para desarrolladores
A partir de lo anterior, es posible resumir un conjunto de hábitos útiles, válidos tanto para quienes disfrutan de las herramientas como para quienes las miran con recelo.
Primero, definir antes de generar. Dedicar unos minutos a escribir qué se quiere conseguir, qué restricciones existen y cómo se comprobará que funciona mejora de manera notable la calidad del resultado y reduce las iteraciones. Si no se sabe describir el resultado, es una señal de que todavía no se entiende el problema.
Segundo, cambios pequeños y verificables. Pedir y aceptar cambios acotados facilita la revisión y permite detectar errores pronto. Un cambio enorme generado de una vez es difícil de evaluar y fácil de aprobar por cansancio. Dividir el trabajo en pasos con pruebas intermedias mantiene el control en manos de la persona.
Tercero, escribir las pruebas con criterio propio. Las pruebas son la especificación ejecutable del comportamiento. Delegar por completo en la herramienta tanto el código como las pruebas que lo validan crea un círculo cerrado en el que ambos pueden compartir el mismo error. Revisar con especial cuidado las pruebas, o escribir a mano las más importantes, es una inversión rentable.
Cuarto, leer todo lo que se incorpora. Es una regla simple: nada entra en el repositorio sin que el autor lo haya leído y lo entienda. Si algo resulta opaco, se pide una explicación o se simplifica. Una solución que nadie comprende es una carga futura.
Quinto, conservar espacios de práctica deliberada para el oficio. Quienes echan de menos el esfuerzo pueden reservar tiempo para resolver sin asistencia ciertos problemas, trabajar en proyectos personales con reglas propias o profundizar en áreas que les apasionan. No se trata de rechazar la herramienta, sino de decidir cuándo conviene usarla y cuándo no, de modo que la satisfacción tenga dónde sostenerse.
Sexto, cuidar la comprensión del sistema. Dibujar diagramas, documentar decisiones y mantener un modelo mental actualizado de la arquitectura evita que el equipo se convierta en un grupo de aprobadores de cambios que nadie sabe situar. Cuanto más código produce la máquina, más valor tiene que las personas conserven el mapa.
Séptimo, medir con honestidad. Si una herramienta aporta, debería notarse en indicadores de entrega, calidad y bienestar del equipo, no solo en la sensación de rapidez. Medir permite ajustar el uso y detectar a tiempo si el ahorro inicial se está pagando con depuración y retrabajo.
La mirada de las empresas y los equipos
Desde el punto de vista organizativo, el reto es doble. Por un lado, aprovechar la capacidad que ofrecen estas herramientas; por otro, evitar los efectos secundarios sobre la calidad, la cultura y el aprendizaje. Las empresas que anuncian porcentajes altos de código generado lo hacen, en parte, para mostrar eficiencia, y esos anuncios deben leerse con la prudencia debida: un porcentaje alto no garantiza por sí mismo mejores productos ni equipos más satisfechos.
Los responsables técnicos tienen varias palancas. Pueden redefinir los criterios de evaluación para premiar el juicio, la claridad y la capacidad de revisión, y no solo el volumen. Pueden invertir en formación sobre uso eficaz y seguro de las herramientas. Pueden adaptar los procesos de revisión a un mundo con más cambios y más grandes. Y pueden preguntar de forma sistemática al equipo cómo vive el cambio, porque la satisfacción en el trabajo influye en la retención y en la calidad.
También hay un debate sobre las expectativas. Si la dirección asume que la IA multiplica la productividad por un factor fijo y fija plazos en consecuencia, puede generar presión y desgaste. Los beneficios reales varían según la tarea, la base de código y la experiencia del equipo. Las expectativas realistas, basadas en datos propios, protegen tanto la calidad como el ánimo de las personas.
Por último, la diversidad de situaciones es amplia. Una startup que arranca un producto nuevo se beneficia de manera distinta que un equipo que mantiene un sistema crítico con décadas de historia. En el primer caso, la velocidad para explorar vale mucho; en el segundo, el conocimiento del contexto y el coste de un error pesan más. No hay una receta única y conviene adaptar el uso a cada realidad.
Antecedentes: no es la primera vez que cambia el oficio
La profesión de programar ha vivido otros desplazamientos de abstracción. El paso del lenguaje ensamblador a los lenguajes de alto nivel, la aparición de los entornos de desarrollo con autocompletado, la difusión de bibliotecas de código abierto y los servicios en la nube modificaron en su día lo que significaba escribir software. Cada transición generó dudas semejantes: se temía que los nuevos programadores no entendieran lo que ocurría por debajo y que el oficio perdiera rigor.
En muchos casos, esos temores se cumplieron en parte y a la vez la profesión creció. Hubo quien dejó de dominar detalles de bajo nivel y, en cambio, pudo construir sistemas mucho más ambiciosos. El balance, mirado desde lejos, fue positivo en capacidad, aunque no exento de pérdidas en conocimiento especializado y en cierto tipo de satisfacción artesanal.
La diferencia de esta etapa es la velocidad y la naturaleza de la herramienta. Un compilador es determinista y su comportamiento puede razonarse; un modelo generativo produce resultados probabilísticos que pueden variar y fallar de maneras menos previsibles. Eso obliga a mantener la verificación como parte central del proceso y distingue este cambio de abstracciones anteriores, donde se podía confiar en la capa inferior con mucha mayor seguridad.
Aun así, la lección histórica es útil: las herramientas cambian lo que se considera trabajo difícil y lo que se considera trabajo rutinario, pero el valor de entender los problemas y responsabilizarse de las soluciones permanece. Quienes se adaptan sin renunciar a los fundamentos suelen salir reforzados.
Situación actual
A fecha del 20 de noviembre de 2026, la adopción de herramientas de programación con IA es amplia y sigue creciendo. La encuesta de Stack Overflow de 2026 muestra que la gran mayoría de los desarrolladores las usa, y compañías como Google sostienen que la mayor parte de su código nuevo parte ya de generación automática con revisión humana. Al mismo tiempo, el debate sobre sus efectos en la calidad, el aprendizaje y la satisfacción laboral sigue abierto y no hay un consenso establecido.
Lo que existe es un conjunto de testimonios, datos de uso y experiencias de empresas que apuntan en direcciones compatibles: hay ganancias claras de velocidad en muchas tareas, la revisión y el criterio adquieren más peso, y una parte de los profesionales siente que el trabajo ha perdido algo de lo que lo hacía gratificante. Falta todavía evidencia sólida y a largo plazo sobre cómo evolucionarán la calidad del software, las trayectorias profesionales y el bienestar de los equipos.
Las empresas continúan afinando sus procesos, las comunidades de desarrolladores discuten buenas prácticas y los propios fabricantes de herramientas siguen incorporando capacidades más autónomas, con agentes capaces de encadenar tareas. Previsiblemente, la presión por definir mejores controles, políticas de uso y modelos de formación aumentará a medida que esas capacidades se extiendan.
Conclusiones
El reportaje del 20 de noviembre de 2026 recoge una tensión real y bien documentada por los testimonios: la IA acelera a los ingenieros, pero no todos viven ese cambio como una mejora íntegra. Las cifras de adopción, con más de ocho de cada diez desarrolladores usando alguna herramienta según Stack Overflow, y el 75 % de código nuevo generado por IA y aprobado por ingenieros que Google comunicó en abril, confirman que no se trata de una moda pasajera sino de una transformación del modo de trabajar.
La consecuencia más importante es que el valor se desplaza hacia el juicio. Revisar, especificar, verificar y comprender el sistema pasan a ser las competencias que marcan la diferencia, mientras que la producción de texto de programación se abarata. Esa transición no elimina la necesidad de fundamentos sólidos, sino que la refuerza, porque sin ellos es imposible distinguir una propuesta plausible de una correcta.
También exige atender a las personas. El esfuerzo no es solo un coste: es una fuente de aprendizaje y de satisfacción. Los equipos y los desarrolladores que reserven espacios para el trabajo deliberado, cuiden la formación de quienes empiezan y mantengan la responsabilidad humana sobre cada cambio estarán mejor situados para aprovechar la velocidad sin perder el oficio. La herramienta puede escribir el borrador, pero el criterio, la responsabilidad y, en buena medida, el sentido del trabajo siguen siendo cosa de quien programa.
