TecnImagIA https://tecnimagia.com/ Tecnología, imagen e inteligencia artificial desde mi propia experiencia. Sat, 31 Oct 2026 20:27:15 +0000 es hourly 1 De un documento técnico a una aplicación: mi experiencia con SDD usando Kiro https://tecnimagia.com/spec-driven-development-kiro-documento-aplicacion/ https://tecnimagia.com/spec-driven-development-kiro-documento-aplicacion/#respond Sat, 31 Oct 2026 19:14:37 +0000 https://tecnimagia.com/?p=151 Cómo estoy incorporando el desarrollo guiado por especificaciones a mi forma de construir sistemas con .NET, SQL Server e inteligencia artificial.

The post De un documento técnico a una aplicación: mi experiencia con SDD usando Kiro appeared first on TecnImagIA.

]]>
Cómo estoy incorporando el desarrollo guiado por especificaciones a mi forma de construir sistemas con .NET, SQL Server e inteligencia artificial.

Introducción: cambiar la forma de desarrollar

En los últimos años, las herramientas de inteligencia artificial han comenzado a modificar la manera en que desarrollamos software. Ya no se trata únicamente de pedirle a un asistente que explique un fragmento de código o que genere una función: ahora podemos apoyarnos en estas herramientas durante buena parte del ciclo de desarrollo de una aplicación.

Una de las propuestas que me ha llamado la atención es el Spec-Driven Development (SDD), o desarrollo guiado por especificaciones. La idea consiste, en términos generales, en partir de requisitos bien definidos y utilizarlos como referencia para planificar, organizar e implementar el software. En cierta forma, podría decirse que seguimos haciendo algo que conocemos desde hace tiempo: analizar, documentar y planificar antes de desarrollar. La diferencia es que ahora podemos utilizar esas especificaciones para guiar a una IA durante buena parte de la implementación.

Mi acercamiento a esta metodología ha sido principalmente práctico. He comenzado a utilizar Kiro en algunos proyectos en mi trabajo, buscando una forma de aprovechar la IA sin perder el control sobre las decisiones funcionales y técnicas.

No considero que haya encontrado una metodología perfecta ni que mi proceso sea una implementación estricta de SDD. De hecho, hay aspectos que todavía puedo mejorar. Pero después de trabajar con este enfoque en dos o tres proyectos, he identificado algunas ventajas, dificultades y aprendizajes que vale la pena compartir.

Y debo comentar, después de utilizar la IA integrada en Visual Studio y Visual Studio Code, conocí Antigravity, que fue la herramienta con la que hice mi primer sistema apoyado con este tipo de IDEs y, desde ese momento, cuando aún no conocía SDD, mi intuición no fue sentarme a hacer vibe code, sino me dije, “esto tiene que tener un orden, debo seguir desarrollando el documento de requerimientos, pero debo hacerlo más explícito, más completo, porque ahora ese documento se lo daré a una IA y ella debe entender y debe tener todos los detalles de lo que debe programar”.

En este artículo quiero relatar cómo estoy trabajando actualmente: desde el documento técnico inicial hasta la implementación y las pruebas de una aplicación. Y deben tener en cuenta el antecedente, como fue que inició mi cambio en la forma de desarrollar.

1. Todo comienza con un documento técnico

Antes de utilizar Kiro, preparo un documento de requerimientos técnicos en Word. Dependiendo de la complejidad del sistema, este documento ha llegado a contener 50 y 70 páginas. Aquí, la comunicación con el área para la cual se está implementando el sistema es importante, debido a que los requerimientos que constituyen el documento técnico se obtienen a partir de las reglas de negocio del área.

No es un documento que empiece desde cero cada vez. Ya tengo una estructura y secciones que reutilizo entre proyectos, especialmente cuando se trata de funcionalidades comunes.

Por ejemplo, hay aspectos o funcionalidades que suelen repetirse:

  • Notificaciones por correo electrónico cuando ocurren determinadas acciones.
  • Registro de actividades de los usuarios mediante una bitácora o auditoría.
  • Administración de usuarios y roles mediante Directorio Activo.
  • Elementos comunes de la interfaz institucional.

Y algunos de los apartados que son parte de la estructura del documento son.

Roles y permisos

Primero identifico los diferentes perfiles que utilizarán el sistema. Puede haber administradores, empleados, responsables de áreas u otros perfiles dependiendo de la aplicación.

Interfaces y funcionalidades

Después describo las vistas a las que tendrá acceso cada rol. No me limito a enumerar pantallas: procuro explicar qué puede hacer cada usuario desde ellas.

En algunos casos incorporo imágenes de referencia para mostrar cómo espero que se comporte o se vea determinada interfaz.

Identidad visual

También incluyo las características generales que deben conservar las aplicaciones institucionales: colores, logotipo, encabezado, menús, identificación del usuario y, cuando corresponde, mecanismos para cambiar de rol.

Para ello utilizo algunas pantallas como referencia. También, aunque lo describo en el documento técnico, tengo una skill para el stack tecnológico y para la identidad visual y un archivo CSS que anexo al proyecto una vez que inicia la implementación.

Flujos de trabajo

Esta es una de las partes que considero más importantes. Describo los procesos que seguirá cada usuario y las condiciones que deben cumplirse durante su ejecución.

Por ejemplo, en un sistema de permisos, un empleado puede generar una solicitud que posteriormente recibe su jefe directo. Cuando la solicitud se envía, el empleado deja de poder modificarla. El jefe puede revisarla, devolverla con observaciones o autorizarla y así entre otras áreas. Es importante identificar los flujos a partir de las reglas de negocio del área, y más importante saberlas explicar y describir en el documento técnico ya que de estas descripciones surgen parte de la estructura de la base de datos y de la funcionalidad en las vistas de cada rol.

No basta con decir que existe un proceso de autorización: hay que explicar qué sucede en cada etapa, quién puede intervenir y qué acciones están permitidas.

Estructura de la base de datos

Finalmente, incluyo una sección dedicada a la base de datos, que normalmente trabajo con SQL Server.

En ocasiones propongo desde el inicio las tablas y entidades que logro identificar y que considero necesarias. Posteriormente, me apoyo en la inteligencia artificial para identificar elementos adicionales que quizá no había contemplado.

Este documento es, en realidad, el punto de partida de todo el proceso. Mi intención es que contenga suficiente información para que la herramienta comprenda qué debe construir, pero también que permita identificar oportunamente aquello que todavía no está definido.

2. Antes de desarrollar, utilizo la IA para revisar los requisitos

Una vez que tengo una primera versión del documento, comienzo un proceso de revisión utilizando dos herramientas: Copilot de Microsoft 365, directamente desde Word, y posteriormente Kiro.

Mi objetivo no es pedirles que completen el documento por su cuenta, sino que me ayuden a encontrar problemas que quizá no he identificado.

Con Copilot reviso principalmente cuatro aspectos:

  • Ambigüedades en los requerimientos.
  • Inconsistencias o contradicciones entre diferentes secciones.
  • Funcionalidades que aparecen descritas varias veces y cuya redacción podría unificarse.
  • Requisitos incompletos: situaciones en las que se menciona que el sistema debe realizar una acción, pero no se explica cómo debe hacerlo.

Este último punto me parece especialmente importante.

Si en el documento indico que el sistema debe enviar una notificación por correo electrónico cuando se autoriza una solicitud, pero no he definido en qué momento se envía, quién la recibe o qué información debe contener, quiero que la IA me señale esa ausencia.

No quiero que invente una solución y la incorpore automáticamente. Prefiero que me indique qué falta para que yo tome la decisión.

Cuando recibo las observaciones, complemento el documento y vuelvo a realizar la revisión. Repito el proceso hasta considerar que los requerimientos están suficientemente definidos.

Después exporto el documento a PDF y lo incorporo a Kiro para realizar una revisión similar.

De esta manera tengo dos revisiones asistidas que me ayudan a detectar problemas antes de comenzar el desarrollo.

Mi intención es utilizar la inteligencia artificial como una especie de revisor lógico de los requisitos, no como alguien que tome decisiones funcionales que todavía me corresponden.

3. El diseño de la base de datos también puede beneficiarse de la IA

También he comenzado a apoyarme en Kiro para diseñar las bases de datos. En un proyecto anterior, relacionado con la gestión de vehículos, le proporcioné los requerimientos y algunas entidades iniciales, como usuarios, documentos y vehículos. A partir de esa información propuso un modelo más amplio, incorporando tablas que no había considerado y que me ayudaron a identificar necesidades adicionales.

Para el proyecto actual quiero seguir un enfoque similar, pero partiendo de una propuesta inicial de estructura que Kiro pueda revisar y complementar. Una vez definido el modelo, le solicito generar el script SQL, que ejecuto y reviso junto con sus tablas, relaciones y diagrama entidad-relación.

Trabajo bajo un enfoque Database First: yo preparo y controlo la base de datos, y Kiro desarrolla la aplicación tomando esa estructura como referencia. Personalmente no me gusta que sea la aplicación, mediante Entity Framework, quien la modifique directamente durante la implementación; cualquier ajuste debe pasar primero por mi revisión.

Así aprovecho la capacidad de la IA para proponer y detectar elementos que podrían faltar, sin perder el control sobre las decisiones del diseño.

4. De los requisitos a las especificaciones con Kiro

Cuando considero que el documento técnico está suficientemente completo, paso a la siguiente etapa: utilizar Kiro para generar los artefactos necesarios para trabajar con SDD.

En este punto le proporciono el documento y le solicito que prepare los elementos que organizan el proyecto:

  • Constitution: las reglas y principios que deben respetarse durante el desarrollo.
  • Specifications: las especificaciones que describen lo que debe construirse.
  • Plan: el plan de implementación.
  • Tasks: las tareas en las que se divide el trabajo.

Estos elementos permiten transformar un documento técnico extenso en una estructura de trabajo más organizada.

También le solicito que revise los archivos generados y compruebe que sean congruentes con los requerimientos originales.

Aquí debo reconocer que mi revisión de estos artefactos todavía no es tan exhaustiva como probablemente debería ser. Hasta ahora he realizado una revisión general, confiando en buena medida en el resultado que proporciona Kiro. No he tenido problemas importantes que me obliguen a detener el proceso, pero considero que esta es una de las áreas que puedo mejorar.

En cuanto al modelo de inteligencia artificial, normalmente dejo Kiro en modo automático. Es la propia herramienta la que determina qué modelo utilizar según la tarea. No selecciono manualmente un modelo para cada actividad.

Una vez que considero que los artefactos están listos, comienzo la implementación.

5. Definir las tecnologías y dejar que Kiro resuelva parte de la implementación

En mis proyectos empresariales suelo trabajar con un conjunto de tecnologías bastante definido:

  • .NET y C#.
  • ASP.NET Core MVC.
  • SQL Server.
  • Microsoft Entra ID para la autenticación.
  • Telerik y Kendo UI para los componentes de interfaz.

También incluyo indicaciones relacionadas con la seguridad. Por ejemplo, solicito que el desarrollo considere las recomendaciones de OWASP y que se eviten vulnerabilidades como SQL Injection.

Sin embargo, no defino absolutamente todos los detalles de la organización interna del código.

Por ejemplo, sí establezco que el proyecto debe utilizar MVC, pero no siempre especifico de antemano cómo debe implementar cada controlador o cómo organizar todos los componentes internos.

En ocasiones le indico expresamente cómo quiero que genere determinados controladores. En otras, dejo que proponga una solución y después reviso si me parece lógica y adecuada.

También hay decisiones de arquitectura y configuración que sí procuro dejar claras.

Un ejemplo es el almacenamiento de parámetros de negocio. Si estoy desarrollando un sistema de control de asistencia y existe una tolerancia de 15 minutos para determinar si un empleado llegó tarde, prefiero que ese valor se almacene en una tabla de configuración de SQL Server y no directamente en el archivo appsettings.

De esta manera, si posteriormente cambia la regla, puede modificarse el parámetro sin necesidad de alterar el código de la aplicación.

Mi enfoque consiste en definir las tecnologías, las restricciones importantes y las reglas de negocio que deben respetarse, pero permitir que Kiro resuelva parte de los detalles de implementación.

No significa que cualquier decisión que tome sea correcta: sigue siendo necesario revisar el resultado.

6. La implementación: trabajar con las especificaciones

Cuando comienza la implementación, suelo trabajar con las especificaciones en el orden en que fueron generadas, desde la primera hasta la última.

No acostumbro detenerme después de cada especificación para realizar una validación funcional completa. Dejo que Kiro avance con la implementación de todas ellas y, cuando termina, comienzo una etapa de revisión más amplia.

Esta forma de trabajar tiene una ventaja práctica: puedo obtener una primera versión navegable de la aplicación sin tener que intervenir constantemente entre cada tarea.

Pero también tiene una consecuencia: algunos problemas de integración o de interpretación de los requisitos pueden aparecer hasta que la aplicación está construida y comienzo a utilizarla.

Por eso, la implementación no representa el final del trabajo. Es el momento en que comienza una etapa que considero indispensable: comprobar que el sistema realmente haga lo que se espera de él.

7. Probar la aplicación: la parte que sigue dependiendo de mí

Una vez que Kiro termina de implementar la primera versión, ejecuto la aplicación en mi entorno local y comienzo a probarla.

Para ello preparo una base de datos local y diferentes cuentas de prueba, procurando representar los roles que intervienen en el sistema.

Si una aplicación contempla empleados, superiores jerárquicos y operadores de áreas, por ejemplo, tengo cuentas que me permiten simular a cada uno de esos perfiles.

Después recorro los procesos de principio a fin, intentando reproducir los pasos que seguiría un usuario real.

Durante estas pruebas identifico problemas de distintos tipos:

  • Errores visuales o de distribución de los elementos.
  • Funcionalidades que no se comportan como deberían.
  • Información que no se guarda correctamente en la base de datos.
  • Notificaciones que no se envían.
  • Errores de programación que aparecen durante la ejecución.

También utilizo las herramientas de desarrollo del navegador (DevTools) para identificar errores y localizar información que pueda ayudarme a encontrar su origen.

Cuando detecto un problema, se lo comunico a Kiro para que realice la corrección.

Aquí tengo dos formas de trabajar.

Si encuentro un error que no impide continuar con las pruebas, lo documento junto con otros ajustes y sigo revisando el sistema. Por ejemplo, puedo registrar que una operación no guarda correctamente cierta información o que no se dispara una notificación de correo electrónico.

Si el problema bloquea el proceso que estoy probando, detengo la revisión y me concentro en corregirlo con Kiro antes de continuar.

Esta etapa se convierte en un ciclo de pruebas, identificación de problemas, correcciones y nuevas validaciones.

En otras palabras, aunque la IA realiza buena parte de la implementación, soy yo quien comprueba que el resultado responda a las necesidades reales del sistema.

8. Los cambios posteriores: una adaptación de mi proceso

Una situación interesante aparece cuando la aplicación ya está implementada y comienzan a surgir nuevas necesidades.

En un proceso SDD más estricto, lo ideal sería mantener las especificaciones actualizadas y documentar los cambios dentro de esa misma estructura.

Sin embargo, en mi experiencia todavía no trabajo exactamente de esa manera.

Cuando necesito incorporar nuevas funcionalidades o realizar correcciones, preparo un documento independiente con los ajustes solicitados. Es un documento más puntual que el original, pero sigue una lógica similar: describo qué debe modificarse, qué comportamiento espero y qué funcionalidades nuevas deben incorporarse.

Después se lo proporciono a Kiro para que realice los cambios.

Las especificaciones iniciales permanecen sin modificaciones.

Es una adaptación práctica que me ha permitido continuar trabajando, aunque reconozco que podría mejorar la trazabilidad entre los requerimientos originales, los cambios posteriores y el código implementado.

Mantener esa relación actualizada ayudaría a que la documentación siguiera siendo una referencia confiable durante toda la vida del sistema, y no solamente durante su construcción inicial.

9. ¿Qué tan cerca está la primera versión del resultado esperado?

Una de las preguntas que me parece más interesante después de utilizar este enfoque es: ¿qué tan bien queda una aplicación en su primera versión?

Mi estimación personal es que la primera versión que comienzo a navegar y probar se acerca aproximadamente a un 50 o 60 % de lo que realmente necesito.

No se trata de una medición formal ni de un porcentaje de código correcto. Es una apreciación basada en qué tan cerca está el resultado inicial de lo que tenía en mente y de lo que describí en los requerimientos.

En términos funcionales, normalmente encuentro que la aplicación está razonablemente encaminada. Sin embargo, donde suelo identificar más diferencias es en el diseño y la organización visual de las pantallas.

10. Lo que he aprendido y lo que todavía puedo mejorar

Después de trabajar con SDD y Kiro en algunos proyectos, mi principal aprendizaje es que la calidad del resultado depende en buena medida del trabajo previo, de la calidad del documento técnico inicial.

Un documento técnico incompleto o ambiguo puede convertirse en una implementación que funcione, pero que no resuelva realmente la necesidad.

Por eso considero que dedicar tiempo a definir los requerimientos y revisarlos con ayuda de la IA es una de las partes más importantes del proceso.

También he comprobado que la inteligencia artificial puede ayudar a descubrir entidades, relaciones y funcionalidades que quizá no había contemplado inicialmente. Esto no significa que debamos aceptar todas sus propuestas, sino utilizarlas como una segunda perspectiva que enriquezca nuestro análisis.

Por otro lado, hay aspectos de mi proceso que quiero mejorar:

Revisar con mayor profundidad los artefactos SDD. Hasta ahora he confiado bastante en la revisión general que realiza Kiro. Me gustaría dedicar más tiempo a comprobar que las especificaciones y tareas reflejen correctamente los requisitos originales.No es un pretexto pero, un motivo de porqué no he dedicado tiempo a revisar los artefactos de SDD es porque el tiempo que tengo disponible para entregar el sistema solicitado no es tan amplio como antes de la era de la IA.

Validar la arquitectura del código. Aunque defino las tecnologías y algunas reglas, todavía puedo establecer criterios más precisos sobre la organización interna de los proyectos.

Mejorar la trazabilidad de los cambios. Los documentos independientes de ajustes me han resultado prácticos, pero mantener las especificaciones actualizadas permitiría conservar una mejor relación entre lo que se solicitó y lo que finalmente se implementó.

Fortalecer la validación de seguridad. Indicar a Kiro que siga recomendaciones de OWASP es un buen punto de partida, pero no sustituye una revisión de seguridad más sistemática. Es un aspecto que merece atención independiente de las pruebas funcionales.

No considero que estos puntos invaliden mi experiencia actual. Al contrario, forman parte de lo que he aprendido al incorporar estas herramientas a un proceso de desarrollo real.

Conclusión: la IA desarrolla, pero las decisiones siguen siendo nuestras

El desarrollo guiado por especificaciones me ha permitido replantear la forma en que abordo la construcción de aplicaciones empresariales.

Antes de escribir código, dedico tiempo a estructurar los requisitos, definir los roles, describir los flujos de trabajo y revisar las necesidades del sistema. Después utilizo herramientas como Copilot y Kiro para encontrar inconsistencias, enriquecer el diseño y transformar esa documentación en una estructura de trabajo que facilite la implementación.

Kiro se encarga de buena parte del desarrollo, pero eso no significa que pueda desentenderme del resultado. Al final de cuentas, es muy cierto lo que ya se dice, cuando el sistema falle, la responsabilidad no será de la IA, será del humano que utilizó la IA, a quien corran, si las cosas van muy pero muuuuuy mal, será a Ángel Vera, no a Kiro.

Sigo definiendo las reglas de negocio, tomando decisiones sobre la base de datos, estableciendo las tecnologías, probando los procesos y revisando las correcciones.

También sigo encontrando aspectos que necesitan intervención, especialmente en la presentación visual y en algunos detalles de comportamiento.

Quizá la principal diferencia no está en que ahora una IA escriba el código por mí, sino en que he comenzado a utilizarla dentro de un proceso más estructurado.

Y eso cambia la manera de trabajar.

No le entregué a una IA la responsabilidad de desarrollar una aplicación; fui construyendo un proceso para que me ayudara a transformar mis requisitos en software funcional.


Referencias para profundizar

Estas son algunas fuentes oficiales que complementan los temas abordados en el artículo:

  • Kiro — Specs: documentación sobre el desarrollo guiado por especificaciones en Kiro.
  • Kiro — Models: información sobre los modelos disponibles y su utilización.
  • OWASP Top 10: referencia sobre los principales riesgos de seguridad en aplicaciones web.
  • Curso SDD Udemy: un curso que me ayudó mucho a entender el tema de SDD.

The post De un documento técnico a una aplicación: mi experiencia con SDD usando Kiro appeared first on TecnImagIA.

]]>
https://tecnimagia.com/spec-driven-development-kiro-documento-aplicacion/feed/ 0
De la fotografía al vídeo generado por IA: experimentando con Google Flow https://tecnimagia.com/de-la-fotografia-al-video-generado-por-ia-experimentando-con-google-flow/ https://tecnimagia.com/de-la-fotografia-al-video-generado-por-ia-experimentando-con-google-flow/#respond Sat, 17 Oct 2026 06:42:18 +0000 https://tecnimagia.com/?p=119 De la fotografía al vídeo generado por IA. Esto es lo que inteno realizar en esta ocasión, tomar una fotografía de mí, y convertirla en un vídeo corto usando Google Flow.

The post De la fotografía al vídeo generado por IA: experimentando con Google Flow appeared first on TecnImagIA.

]]>
De los dedos de más al vídeo cinematográfico

Cuando comenzó el auge de la inteligencia artificial generativa, el público general empezó a utilizarla para crear imágenes de todo tipo. Muchas personas buscaban resultados realistas, aunque no era raro encontrarse con personajes que tenían doce dedos en las manos o, si la cosa se complicaba, dieciocho dedos repartidos entre tres manos. La IA todavía tenía algunos problemas con la anatomía humana.

También hubo una explosión de imágenes con estilos artísticos muy variados: personajes al estilo de Los Simpson, reinterpretaciones inspiradas en Studio Ghibli, animaciones con estética Disney y muchas otras variantes. De pronto, cualquiera podía experimentar con estilos visuales que antes requerían conocimientos de ilustración, herramientas especializadas o bastante trabajo manual.

Pero la generación de imágenes era solo una parte de lo que estaba por venir.

Poco después comenzó a cobrar protagonismo la generación de vídeo mediante inteligencia artificial. La idea parecía sencilla: describir una escena mediante un prompt —una instrucción escrita para el modelo— y dejar que la herramienta generara el vídeo.

Los primeros resultados podían ser bastante surrealistas. Un ejemplo que se volvió famoso fue el vídeo de Will Smith comiendo espagueti, que se convirtió en una referencia recurrente para mostrar las limitaciones de los primeros modelos de generación de vídeo. La escena resultaba extraña, los movimientos eran poco naturales y la representación de las manos y el rostro parecía salida de una pesadilla digital.

Puedes encontrar más información sobre este fenómeno en la entrada de Wikipedia dedicada a la prueba de Will Smith comiendo espaguetis.

Desde 2023 hasta octubre de 2026, la evolución ha sido considerable. Los modelos actuales pueden producir escenas con movimientos más naturales, iluminación convincente, mayor coherencia visual y resultados que, en determinadas condiciones, se acercan a la estética de una producción cinematográfica profesional.

Esto no significa que todos los vídeos generados por IA tengan calidad de Hollywood ni que hayan desaparecido los errores. Sin embargo, el salto tecnológico es evidente. El experimento de Will Smith comiendo espagueti se ha utilizado precisamente como punto de comparación entre distintas generaciones de modelos, mostrando cuánto ha cambiado esta tecnología en pocos años.

Hoy existen plataformas que permiten generar clips breves a partir de texto o imágenes, algunas con modalidades gratuitas y otras mediante suscripciones o sistemas de créditos. Las diferencias están en la calidad, la duración, el control sobre la escena, las herramientas de edición y, por supuesto, el coste de cada intento.

De la fotografía al vídeo: mi primer experimento con Google Flow

Mi relación con la creación de imágenes viene principalmente de la fotografía. Aunque también he trabajado con vídeo, mi experiencia se ha concentrado más en la elaboración de time-lapses: secuencias construidas a partir de numerosas fotografías que después se procesan y ensamblan para crear un vídeo.

Es decir, estoy acostumbrado a partir de imágenes reales y trabajar con ellas, pero no tanto a pedirle a un modelo de inteligencia artificial que invente el movimiento que existe entre dos instantes.

Actualmente pago un plan de Google AI que me da acceso a Google Flow, una herramienta de Google orientada a la creación de vídeos mediante inteligencia artificial. Así que decidí aprovechar la oportunidad para experimentar y descubrir qué podía hacer con ella.

Puedes conocer la herramienta en su sitio oficial: Google Flow.

Para mi primera prueba decidí utilizar una fotografía mía. La idea era sencilla: convertir esa imagen estática en una breve secuencia en la que apareciera moviéndome para preparar la cámara y fotografiar un paisaje al atardecer.

El resultado que muestro a continuación no es perfecto. De hecho, debo recordar que soy un principiante en este campo y que este es uno de los resultados que obtuve después de varios intentos. No elegí el primer vídeo generado, sino uno de los que consideré suficientemente decentes como para mostrarlo.

Este fue el resultado de mi experimento:

Lo ideal habría sido que la herramienta respetara la fotografía original y generara un movimiento continuo y natural, como si la cámara hubiera grabado la escena en lugar de fotografiarla. Sin embargo, el resultado presenta algunos detalles que llaman la atención.

La transición inicial no quedó bien resuelta. Además, durante el movimiento cambiaron elementos de mi vestimenta y del equipo que llevaba: la chamarra, la mochila e incluso la pequeña botella de agua que sostenía.

Son detalles que quizá podrían pasar inadvertidos en una escena fantástica o en un vídeo deliberadamente surrealista, pero que resultan evidentes cuando el objetivo es animar una fotografía real conservando sus elementos originales.

Como fotógrafo, me interesa precisamente ese aspecto: no basta con que el movimiento sea atractivo. También importa que los objetos, las formas y los detalles de la imagen mantengan su coherencia a lo largo de la secuencia.

El prompt: describir una escena no siempre es suficiente

Esta fue la instrucción que utilicé en mi último intento:

A primera vista, la instrucción parece suficientemente clara. Describo las acciones que quiero que realice el fotógrafo, indico hacia dónde debe mirar, especifico cómo debe mover la cámara y solicito un cambio de iluminación para simular la hora dorada.

Sin embargo, después de ver el resultado, encuentro varios aspectos que podría mejorar.

1. Demasiadas acciones en una sola secuencia. Soltar una botella, mover una mano, girar la cabeza, rotar el cuerpo, levantar la cámara y cambiar la iluminación son varias instrucciones concentradas en un clip muy breve. El modelo debe decidir cómo distribuirlas en el tiempo y cómo relacionarlas entre sí.

2. Falta de precisión temporal. No indiqué qué debía suceder al principio, en la parte intermedia y al final del vídeo. Una descripción por etapas podría ayudar a establecer una secuencia más clara, aunque no garantiza que el modelo la siga exactamente.

3. No definí suficientemente qué debía permanecer sin cambios. Pedí cuidar los detalles, pero podría haber especificado expresamente que se conservaran la chamarra, la mochila, la botella, la cámara y las proporciones del cuerpo, evitando modificaciones innecesarias.

4. La iluminación y el movimiento se mezclaron en la misma instrucción. Quería cambiar la luz diurna por una iluminación cálida de atardecer, pero también pedía varios movimientos corporales. Tal vez convenga experimentar con instrucciones más simples para entender qué controla mejor el modelo.

Hay una última cuestión: pedir que no haya errores no significa que el modelo pueda evitarlos. Una instrucción como «no dejes efectos raros» expresa perfectamente lo que deseo como usuario, pero no constituye una garantía técnica de que el resultado será correcto.

Una posible versión mejor estructurada de mi prompt sería la siguiente:

Anima la fotografía de referencia conservando la identidad del fotógrafo, su vestimenta, la mochila, la cámara, la botella de agua y los demás elementos visibles. Mantén la composición y la perspectiva originales, sin introducir objetos nuevos ni modificar los existentes.

El fotógrafo comienza sosteniendo la botella de agua y mirando hacia el frente. Después, deposita la botella fuera del encuadre de forma natural, gira la cabeza hacia la izquierda para contemplar el paisaje y, a continuación, orienta lentamente el cuerpo en esa dirección. Finalmente, levanta la cámara fotográfica hasta el rostro y encuadra el paisaje como si fuera a tomar una fotografía.

La iluminación evoluciona gradualmente desde la luz diurna original hacia una cálida luz de hora dorada, con tonos anaranjados naturales sobre el paisaje y el fotógrafo. Mantén un movimiento corporal continuo, una anatomía natural y una cámara estable. Evita deformaciones, cambios de vestuario, alteraciones del equipo fotográfico y transiciones bruscas.

Esta segunda versión intenta separar mejor la conservación de los elementos originales, la secuencia de acciones y el cambio de iluminación. Es una propuesta para una prueba posterior, no un prompt que haya validado todavía mediante nuevas generaciones.

Además, hay una limitación importante: un prompt mejor redactado puede ayudar, pero no elimina por sí solo las limitaciones del modelo. También influyen la imagen de referencia, el modo de generación, la duración del clip y las funciones de control disponibles.

Google Flow y el modelo utilizado

Para realizar esta prueba utilicé Veo 3.1, en la variante Quality, con la opción x1.

Modelos Google Flow

La configuración importa porque las distintas variantes y herramientas no ofrecen necesariamente las mismas funciones ni consumen la misma cantidad de créditos. Por eso conviene revisar el modelo seleccionado y el coste que muestra la interfaz antes de cada generación.

En mi caso, opté por Quality y x1 para hacer la prueba. No obstante, no sería correcto concluir, a partir de un solo experimento, que esa configuración produce siempre mejores o peores resultados que las demás.

También hay que distinguir entre la calidad de generación y el control creativo. Un modelo puede producir una imagen visualmente atractiva y, aun así, modificar elementos que el usuario quería conservar.

La documentación oficial de Google Flow describe las funciones compatibles con sus modelos. Estas capacidades cambian con el tiempo, por lo que conviene consultar la documentación actualizada al realizar nuevas pruebas.

Mi espacio de trabajo en Google Flow

Como evidencia de que apenas estoy empezando a experimentar con esta herramienta, comparto también una captura de mi espacio de trabajo.

Todavía no hay demasiado contenido en él. Mi intención no es presumir de una biblioteca de producciones que aún no existe, sino mostrar un poco de la interfaz con la que estoy aprendiendo a trabajar.

Como sucede con otras herramientas creativas, conocer los controles disponibles es solo una parte del aprendizaje. La otra consiste en comprender cómo interpretar las instrucciones, qué limitaciones tiene el modelo y qué ajustes pueden acercarnos al resultado que buscamos.

Herramientas para empezar a generar vídeos con IA

Google Flow no es la única alternativa. Existen distintas plataformas para experimentar con generación de vídeo, algunas con acceso gratuito limitado y otras con planes de pago.

La siguiente lista es un punto de partida para investigar, no un ranking de calidad. Los modelos, los créditos disponibles y las condiciones de uso cambian con frecuencia.

1. Google Flow

https://flow.google.com

Permite generar vídeos a partir de texto e imágenes, además de ofrecer herramientas para trabajar con escenas y recursos visuales. Es la plataforma utilizada en este experimento.

Google dispone de una modalidad gratuita y de planes de pago. La disponibilidad concreta de los modelos y las funciones depende del plan, la región y las condiciones vigentes.

2. Kling AI

https://kling.ai

Es una plataforma de generación de imágenes y vídeos que también ofrece funciones relacionadas con el movimiento y la animación de imágenes de referencia.

Puede ser interesante para quienes quieren explorar cómo transformar una imagen estática en una escena en movimiento. Su acceso gratuito y los créditos disponibles deben comprobarse en la cuenta y el momento de uso.

3. Hailuo AI

https://hailuoai.video

Ofrece generación de vídeo mediante inteligencia artificial, incluyendo la creación a partir de imágenes. Su modalidad gratuita tiene limitaciones de resolución, créditos y marcas de agua, por lo que no debe confundirse con el acceso a todas las capacidades de los modelos de pago.

4. Pika

https://pika.art

Está orientada a la creación y transformación de contenido visual mediante IA. Incluye herramientas para generar vídeos y aplicar efectos o modificaciones creativas.

Es importante revisar sus condiciones actuales: la existencia de una opción para registrarse gratuitamente no implica necesariamente disponer de créditos gratuitos recurrentes para generar vídeos.

Antes de elegir cualquiera de estas plataformas, recomiendo comprobar cuatro aspectos: cuántos créditos ofrece, cuánto cuesta cada generación, qué resolución permite descargar y si añade una marca de agua. También es conveniente revisar las condiciones de uso comercial si se pretende publicar el material con fines profesionales.

Próximas pruebas: aprender a controlar el resultado

Esta primera experiencia me deja varias ideas para continuar experimentando.

En lugar de intentar conseguir una escena compleja desde el principio, me interesa realizar pruebas más controladas. Por ejemplo, generar un movimiento sencillo de cabeza, animar una fotografía de paisaje o pedir un desplazamiento de cámara sin modificar al sujeto.

Después podría aumentar gradualmente la complejidad y comparar los resultados. También quiero probar distintas redacciones del prompt, observar cómo se comporta el modelo cuando se le pide conservar los elementos originales y averiguar qué herramientas ofrecen un mayor control sobre el movimiento.

Otra posibilidad es comparar los resultados obtenidos con diferentes modelos, manteniendo la misma imagen de referencia y una instrucción equivalente. Esto ayudaría a distinguir, hasta donde sea posible, qué diferencias proceden del modelo y cuáles de la forma de plantear la generación.

No se trata únicamente de conseguir un vídeo bonito. Me interesa comprender el proceso y aprender qué puedo hacer para acercarme al resultado que tengo en mente.

Conclusión: la herramienta no sustituye al aprendizaje

Como mencioné antes, realicé varios intentos antes de elegir el vídeo que acompaña este artículo. Los anteriores quedaron peor y preferí no utilizarlos como muestra. Soy novato, pero no conformista: no me voy con el primer resultado si considero que todavía no es suficientemente decente como para mostrarlo.

Quiero dejar claro que este experimento no demuestra que Veo 3.1 sea incapaz de generar una secuencia mejor. Lo que demuestra es que, con mi nivel actual de experiencia y las instrucciones que utilicé, todavía no he conseguido el resultado que buscaba.

La inteligencia artificial generativa abre posibilidades interesantes para fotógrafos, diseñadores, creadores de contenido y muchas otras personas. Sin embargo, disponer de una herramienta potente no significa dominarla automáticamente. Saber describir una escena, planificar sus movimientos, reconocer los errores y aprender de cada intento sigue siendo importante.

En fotografía, estamos acostumbrados a pensar en la composición, la luz, la perspectiva y el instante que queremos capturar. Al generar vídeo mediante IA, algunos de esos conocimientos siguen siendo útiles, pero aparece un desafío adicional: conseguir que los elementos de la imagen se mantengan coherentes a lo largo del tiempo.

Y ahí es donde comienza mi aprendizaje.

Este ha sido solo el primer experimento que considero suficientemente interesante para compartir. Mi intención es continuar probando Google Flow y otras herramientas, documentar los resultados y mostrar tanto los aciertos como los errores que vaya encontrando.

Porque, si algo he aprendido durante estos primeros intentos, es que la ignorancia se puede eliminar. Lo que hace falta es experimentar, observar, corregir y volver a intentarlo.

Y eso es precisamente lo que pienso hacer.

The post De la fotografía al vídeo generado por IA: experimentando con Google Flow appeared first on TecnImagIA.

]]>
https://tecnimagia.com/de-la-fotografia-al-video-generado-por-ia-experimentando-con-google-flow/feed/ 0
¿Recuerdas tu primera vez? https://tecnimagia.com/recuerdas-tu-primera-vez/ https://tecnimagia.com/recuerdas-tu-primera-vez/#comments Mon, 12 Oct 2026 01:38:41 +0000 https://tecnimagia.com/?p=62 Mi primera aplicación desarrollada con IA comenzó como un experimento sencillo y terminó cambiando mi manera de entender el desarrollo de software. Esta es la historia de aquella sorpresa, del salto al desarrollo profesional con agentes de programación y de por qué no quiero perder la emoción de seguir aprendiendo.

The post ¿Recuerdas tu primera vez? appeared first on TecnImagIA.

]]>
Hay momentos en los que descubres algo que cambia tu manera de ver las cosas. No necesariamente porque sea perfecto, ni porque lo entiendas por completo desde el primer momento, sino porque, de repente, te das cuenta de que algo que creías lejano, complicado o reservado para unos cuantos, ahora está a tu alcance…., ah, y no, no me refiero al despertar sexual que muchos vivimos en algún momento de nuestras vidas.

Para mí, uno de esos momentos llegó cuando descubrí que podía pedirle a una inteligencia artificial que desarrollara software por mí.

Y no, no fue precisamente como lo imaginaba.

El primer encuentro: ¿de verdad puede hacer eso?

Todo comenzó cuando un compañero del trabajo me habló de una herramienta de Google llamada Antigravity. Me contó un poco de lo que podía hacer y, como buen informático al que le hablan de algo nuevo, llegué a casa con la curiosidad a tope.

La descargué, la instalé en mi computadora personal y empecé a explorarla. Abrí sus apartados, revisé sus opciones e intenté entender cómo funcionaba aquello. Revisé los modelos que podía usar, aprendí lo suficiente sobre la manera de interactuar con la herramienta y decidí hacer una prueba rápida.

Quería algo sencillo: una aplicación tipo control de gastos, con datos almacenados localmente y sin complicarme con .NET, bases de datos ni arquitecturas elaboradas. Puro HTML, JavaScript y CSS.

Así que describí lo que quería y le di la indicación de comenzar.

Entonces ocurrió algo que, aunque hoy me parece cada vez más habitual, en aquel momento me dejó completamente sorprendido.

Antigravity empezó a generar la estructura, los archivos, a escribir código y a mostrarme información sobre las acciones que iba realizando. Yo observaba la pantalla con una mezcla de curiosidad y escepticismo. Veía cómo avanzaba, pero una parte de mí seguía pensando: «Está bien, pero vamos a ver qué termina haciendo».

Hasta que llegó el mensaje de que había terminado.

Fui a la carpeta donde había guardado el proyecto, busqué el archivo index.html y lo abrí en el navegador. Y ahí estaba. Una aplicación que hacía lo que le había pedido.

¿Era una maravilla del desarrollo de software? No. ¿Estaba perfectamente diseñada? Tampoco. ¿Había entendido todos los detalles que tenía en la cabeza? Ni de lejos.

Pero funcionaba. Y, para ser justos, funcionaba hasta donde mi pobre y raquítico prompt le había permitido entender lo que yo quería. Me quedé mirando aquella aplicación con auténtico asombro.

Una herramienta de software, apoyada en modelos de inteligencia artificial, había creado otra herramienta de software prácticamente sin que yo tuviera que escribir una sola línea de código.

Yo había descrito una necesidad y había observado cómo se convertía en archivos, en código que podía ejecutar en mi computadora.

En ese momento entendí, aunque todavía no sabía explicarlo bien, que estaba ante algo diferente. No era simplemente un autocompletado de código de toda la vida, ni una herramienta que me sugiriera cómo resolver un problema. Era otra forma de trabajar.

Y apenas estaba empezando.

El entusiasmo del principiante y el regreso del ingeniero

Después aprendí que lo que había hecho aquella primera noche tenía nombre: vibe coding.

Había descrito una idea, había dejado que la inteligencia artificial generara el código y había comprobado el resultado sin detenerme demasiado a definir una arquitectura, documentar requisitos o establecer criterios rigurosos de calidad.

Lo acepto: fue mi primera aplicación desarrollada mediante vibe coding. Y fue una experiencia fantástica (aunque no tanto como el despertar aquél que mencioné al inicio).

Pero soy ingeniero. Me dedico al desarrollo de software, al análisis de sistemas y a la administración de tecnologías. Sé que una aplicación que funciona en una prueba rápida no es necesariamente una aplicación que esté preparada para utilizarse en un entorno real.

Así que, después de aquella primera experiencia, hice lo que probablemente habría hecho desde el principio si hubiera abordado el proyecto como un desarrollo profesional.

La segunda vez: ahora sí, vamos a trabajar

Volví a Antigravity, pero esta vez con un propósito muy diferente.

Esta vez no quería experimentar simplemente con una herramienta. Quería comprobar hasta dónde podía llegar utilizándola para desarrollar un sistema real para mi trabajo.

Ya no se trataba de pedirle una aplicación sencilla y esperar a ver qué ocurría. Volví a mis documentos de análisis. Definí los requerimientos, las vistas, las tablas, la base de datos y el stack tecnológico. Organicé las ideas, establecí las reglas y preparé un documento técnico que describía qué debía construir el sistema y cómo esperaba que se implementara.

Al término del proceso de análisis y documentación, tenía el documento técnico, con una idea mucho más clara de lo que necesitaba y una serie de condiciones que debía respetar. Le proporcioné esta documentación a Antigravity.

No quería que inventara una arquitectura sobre la marcha ni que eligiera las tecnologías que le parecieran más cómodas. Necesitaba un sistema desarrollado con .NET Core, utilizando MVC, con sus modelos, controladores y vistas; con un diseño institucional, reglas de seguridad y una estructura coherente con los estándares que utilizamos en el trabajo.

Para ello, incorporé instrucciones y una skill que ayudaran a orientar la implementación hacia esas decisiones. Revisamos juntos el documento, afinamos indicaciones y corregimos los aspectos que todavía no estaban suficientemente definidos. En aquel momento aún no conocía el concepto de Spec-Driven Development (SDD), algo que descubriría días después y que me ayudaría a entender mejor cómo estructurar este tipo de trabajo.

Cuando consideré que teníamos una base suficientemente sólida, llegó el momento de dar la indicación:

Empieza a programar.

Y volví a sentir aquella sorpresa de la primera noche, pero multiplicada. Vi cómo se creaba la carpeta del proyecto, cómo aparecían los controladores, los modelos y las vistas, y cómo se iban integrando funcionalidades que, trabajando de la manera tradicional, me habrían llevado horas o incluso días hacer.

No estaba observando fragmentos de código aislados. Estaba viendo cómo tomaba forma una aplicación con una estructura que yo mismo había definido y unas tecnologías que había elegido deliberadamente.

Me quedé pegado al monitor durante todo el proceso, siguiendo los avances, revisando lo que aparecía y tratando de asimilar la velocidad a la que se estaba construyendo el sistema. En un par de horas, aproximadamente el 60% del desarrollo inicial estaba hecho.

¿Estaba listo para entrar en producción? Por supuesto que no.

Y esta distinción es importante.

Una cosa es generar una gran cantidad de código y otra muy distinta es tener un sistema probado, seguro, consistente y preparado para que sus usuarios trabajen con él. Todavía había funcionalidades que ajustar, errores que detectar, comportamientos que corregir y decisiones que revisar.

Pero la base estaba ahí. Y se había construido a una velocidad que, hasta entonces, me habría parecido difícil de imaginar.

Veinte días frente a dos o tres meses

El sistema terminó tomando alrededor de veinte días de trabajo para llegar a una versión funcional que pudiera presentar.

Veinte días.

Mi estimación inicial, desarrollándolo de la manera tradicional, habría sido de dos o tres meses como mínimo.

No pretendo presentar esta comparación como una regla universal. Cada proyecto es diferente, y los resultados dependen de la complejidad, los requisitos, la calidad esperada y el trabajo de revisión necesario. Pero, en mi caso, la diferencia fue lo suficientemente grande como para cambiar mi perspectiva sobre el desarrollo de software.

La inteligencia artificial no había eliminado la necesidad de analizar, decidir, probar o corregir. Había cambiado radicalmente la velocidad con la que podía transformar mis decisiones en una implementación concreta.

Y eso tiene un valor enorme porque, cuando trabajas en desarrollo, sabes que escribir código es solo una parte del trabajo. Antes hay que entender el problema, identificar las necesidades, diseñar una solución y tomar decisiones que condicionarán todo lo que venga después.

Y después hay que comprobar que lo construido realmente resuelve el problema. La IA puede ayudarte en muchas de esas etapas, pero no convierte automáticamente una descripción ambigua en un sistema impecable.

De hecho, mi primera aplicación me enseñó algo muy sencillo: si das instrucciones pobres, puedes obtener un resultado funcional, pero limitado. Y mi segunda experiencia me demostró que una mejor preparación, acompañada de indicaciones claras y una revisión constante, puede producir resultados mucho más útiles.

La diferencia no estaba únicamente en la herramienta. También estaba en cómo yo había aprendido a utilizarla.

¿El mérito es mío o de la inteligencia artificial?

Esta es una pregunta que me he hecho más de una vez. Después de todo, yo no escribí manualmente buena parte del código que terminó formando el sistema. Fue la inteligencia artificial la que generó archivos, implementó funciones y propuso soluciones.

Entonces, ¿qué parte del mérito me corresponde? Creo que la respuesta está en entender que mi trabajo no desapareció. Cambió de lugar.

Yo hice el análisis, definí los requerimientos, seleccioné las tecnologías, establecí la estructura, preparé las instrucciones y fui tomando decisiones durante el desarrollo. También tuve que revisar los resultados, detectar comportamientos incorrectos, solicitar correcciones y comprobar que las funcionalidades respondieran a lo que necesitaba.

La IA se encargó de buena parte de la implementación que, de otra manera, yo habría tenido que escribir línea por línea.

Y sí, eso significa que ahora puedo dedicar menos tiempo a determinadas tareas de programación y más a definir qué hay que construir, cómo debe funcionar y cómo comprobar que lo hace correctamente. Pero sería un error creer que, porque una IA genera código, ya no necesitamos entenderlo.

Todavía tengo mucho que aprender. Necesito dedicar más tiempo a revisar el código generado, comprender las decisiones que hay detrás de él y asegurarme de que la solución sea mantenible y segura. No basta con que la aplicación funcione cuando la probamos; también hay que entender qué sucede cuando algo falla, cuando cambian los requisitos o cuando aparecen situaciones que no habíamos previsto.

La productividad sin criterio puede llevarnos a construir más rápido algo que no deberíamos haber construido así. Por eso, mi objetivo no es convertirme en alguien que escribe menos código sin saber qué está pasando. Quiero convertirme en un ingeniero capaz de aprovechar estas herramientas, dirigirlas correctamente y evaluar con criterio el trabajo que producen.

No quiero dejar de entender el software que desarrollo. Quiero tener la capacidad de desarrollar más y mejores soluciones sin que la escritura manual de cada línea sea necesariamente el centro de mi trabajo.

Mi compañero de código

Este ha sido mi primer año trabajando con inteligencia artificial de esta manera, integrándola de forma activa en el desarrollo de software. Y, sinceramente, creo que nunca lo olvidaré.

Todavía recuerdo aquella primera aplicación de control de gastos, la carpeta con los archivos generados y el momento en que abrí el index.html en el navegador. Era algo sencillo, incluso rudimentario, pero representaba una posibilidad que hasta entonces no había experimentado de esa manera.

Después llegó el desarrollo del sistema real, la documentación técnica, las instrucciones, las herramientas, las skills y el descubrimiento de nuevas metodologías para trabajar con agentes de programación.

He pasado de experimentar con una idea sencilla a utilizar estas herramientas para afrontar proyectos con requisitos y expectativas reales. Y apenas estoy empezando a comprender todo lo que puedo hacer con ellas.

Quiero aprender más, mejorar mi manera de trabajar, revisar mejor el código y conocer las metodologías que permiten desarrollar sistemas de forma más ordenada y profesional. Quiero entender mejor esa especie de magia que ocurre cuando un agente convierte una descripción en una estructura de archivos, clases, funciones y vistas.

Y también quiero aprender a colaborar mejor con ese compañero de código que, aunque no sustituye mi criterio ni asume mi responsabilidad, puede ayudarme a llegar mucho más lejos.

Porque la inteligencia artificial no tiene que ser una competencia entre el ser humano y la máquina. Al menos, en mi experiencia, ha sido una oportunidad para combinar lo que sé hacer con capacidades que antes no tenía a mi alcance de esa manera.

Y quiero aprovecharla.

¿Recuerdas tu primera vez?

Quizá tú también recuerdes el primer momento en que utilizaste una herramienta de inteligencia artificial y te quedaste sorprendido por lo que era capaz de hacer.

Tal vez fue cuando respondió una pregunta que llevabas tiempo intentando resolver, cuando generó una imagen a partir de una descripción, cuando te ayudó a escribir algo que no sabías cómo empezar o cuando creó un programa que nunca habrías imaginado terminar tan rápido.

Puede que, como me ocurrió a mí, tu primera reacción fuera una mezcla de incredulidad, entusiasmo y curiosidad. Con el tiempo, esa sorpresa se vuelve más cotidiana. Aprendes a formular mejores instrucciones, descubres las limitaciones, identificas los errores y dejas de maravillarte cada vez que la herramienta produce un resultado.

Empiezas a utilizarla como parte de tu trabajo.

Pero no quiero perder de vista aquella primera sensación. Quiero recordar lo que sentí al abrir mi primera aplicación y descubrir que realmente funcionaba. Quiero conservar esa curiosidad, seguir aprendiendo y no dar por sentado lo que hoy estas herramientas hacen posible.

Porque, más allá de la velocidad, los modelos o las nuevas tecnologías que aparezcan, lo verdaderamente importante será lo que seamos capaces de aprender y construir con ellas.

Ahora te toca a ti: ¿recuerdas tu primera vez con la inteligencia artificial?

¿Cuál fue esa experiencia que te hizo pensar: «Un momento… ¿de verdad puede hacer esto»?

Me encantará leerte en los comentarios.


Este artículo forma parte de mi experiencia personal aprendiendo a trabajar con inteligencia artificial, agentes de programación y nuevas formas de desarrollar software. No pretendo tener todas las respuestas; precisamente, este espacio nace para seguir explorando, aprendiendo y compartiendo lo que vaya descubriendo.

The post ¿Recuerdas tu primera vez? appeared first on TecnImagIA.

]]>
https://tecnimagia.com/recuerdas-tu-primera-vez/feed/ 1