Uso correcto vs Uso incorrecto de la IA en general y en el desarrollo de software

Como ya debes saber, soy creador de contenido, y me gusta compartir recursos enfocados principalmente en programación. Con el auge de la inteligencia artificial, algunas personas pueden tener una idea errada sobre cómo uno trabaja o incluso preguntarse si todavía tiene sentido crear este tipo de contenido.

Eso es precisamente lo que quiero abordar en este artículo.

¿La IA lo resuelve todo?

Quiero dejar claro algo: si la IA solucionara todo, incluyendo la programación, entonces plataformas como YouTube ya habrían desaparecido. Porque si todo se resuelve preguntándole a la IA, ¿para qué buscar tutoriales o documentación? Y lo mismo aplica para Google. Sin embargo, ambas plataformas siguen vigentes y creciendo.

La realidad es que la IA debe verse como una herramienta más, no como la solución absoluta. Plataformas como YouTube o Google pueden quedarse cortas en algunos aspectos; ahí es donde una IA puede ayudarte. Pero para temas más amplios o genéricos, muchas veces no es la mejor opción. O al menos no como primera ni única opción.

Ejemplo de mal uso de la IA

En un podcast del canal Romu, uno de los expertos respondía una inquietud parecida: “¿La IA dejará sin trabajo a los departamentos de marketing digital?”. Su respuesta fue muy acertada, y me la apropio para este tema: si una persona sin conocimientos en marketing (o en nuestro caso, en programación) intenta usar la IA para generar resultados, lo que obtendrá será, probablemente, un desastre.

La IA no está para reemplazar el conocimiento, sino para potenciarlo.

Buenas prácticas al usar la IA

Aquí algunas buenas prácticas que sigo y recomiendo:

1. Usa la IA como una segunda opinión. Yo la uso como si fuera una segunda persona a quien consulto algo. Si sugiere una solución, la analizo, la adapto y la ajusto a mis necesidades.
2. Haz preguntas específicas. En lugar de pedir “una app responsiva que sea amigable con el SEO”, es mejor preguntar: “¿Cómo mejorar la estructura de este componente responsivo en Vue para hacerlo más accesible?”.
3. Entiende lo que estás pidiendo. Si no sabes qué estás consultando, no podrás evaluar si la respuesta es buena, mala o peligrosa.
4. Nunca dejes que la IA decida por ti. Tú debes guiarla, no al revés.

Sobre el comentario recibido

El comentario al que me refiero decía algo así como: “¿Y si le paso el libro completo a la IA, me haría dicha solución planteada por ti?”.

Creo que lo que quiso decir es que si él le da a la IA el libro completo que yo estoy creando, ¿acaso le va a producir la solución completa que yo propongo? Entiéndase: cree que todo este libro y curso que estoy desarrollando lo hace la IA por mí. Lo cual está muy lejos de la realidad.

Yo estoy construyendo este recurso a partir de mi experiencia personal. Llevo más de 10 años desarrollando software, y ahora estoy armando un curso sobre cómo construir una tienda en línea con Laravel y Livewire, aplicando buenas prácticas desde el inicio.

Por ejemplo, en la integración con PayPal, estoy dividiendo la funcionalidad en módulos:

1. Un trait que hace la conexión directa.
2. Una clase genérica para manejar múltiples pasarelas de pago.
3. Una clase específica del producto, en este caso libros.

Toda esta estructura modular solo se puede crear si entiendes realmente lo que estás haciendo. Puedes apoyarte en la IA para pequeñas dudas, como: “¿Cómo modularizar mejor esta parte?”, pero si le dices simplemente: “Hazme una tienda online con Laravel”, lo más probable es que te devuelva un código desactualizado, poco escalable y mal estructurado.

Como usar correctamente la IA vs incorrecto, Opinión y Ejemplo

Este video lo grabo porque quería, como quien dice, afianzar un poquito la idea que te comentaba anteriormente: una persona hizo una crítica, en la que insinuaba que yo generaba todo mi contenido con IA. Muchas personas hacen eso: generan todo su contenido con inteligencia artificial.

Quiero, como quien dice, dar un ejemplo de eso y compartir un poco más mi opinión, porque sé que para algunos puede resultar algo abstracto. Así que aquí va un poco más de contexto.

Cómo uso la IA

Aquí tengo un prompt que estoy utilizando. A ver, es muy sencillo. No te estoy diciendo que yo sea un experto en IA ni nada por el estilo.

También depende de lo que tú quieras hacer. A veces no hay que complicarse tanto; al menos, esa es mi opinión.

Pero bueno, como te digo, esto es solo un ejemplo. No es el uso que le doy al 100% a la IA, y punto.

Supongamos que quiero redactar algo, por ejemplo, sobre cómo usar la IA de forma ética, y quiero dar mi opinión. Una forma es preguntarle directamente a la IA que genere ese contenido, por ejemplo, para una publicación.

Ahí podría decirle: 

“Hazme una publicación de tantas líneas o palabras sobre el uso correcto de la IA”. Incluso podría especificarle que trate ciertos puntos, que incluya características o ejemplos.

Mientras más específico seas, más detallada será la respuesta. Pero aún así, el problema que yo veo es que, aunque le des un buen prompt, te va a devolver un contenido muy similar al que le generaría a otra persona que pregunte algo parecido. Aunque varíes el prompt, el resultado será bastante genérico.

El uso que yo considero correcto

Para mí, el uso correcto de la IA es como asistente, no como generador completo de contenido.
No que genere un contenido desde cero sin un motivo claro, aunque le des un prompt. Sino que te ayude a dar formato, corregir, mejorar. Eso es precisamente como yo lo uso.

Yo le paso lo que llamo “la fuente” y a partir de ahí le pido que lo mejore.

Entonces, como te decía, es muy distinto pedirle a la IA que te cree todo el contenido, por más bonito que sea el prompt, a usarla como yo lo hago:
por ejemplo, tengo tal código, tal texto, y le pido que lo mejore en base a cierta condición. Eso es lo que hago.

En mi caso, por cuestiones que creo bastante entendibles, yo suelo llevar estos videos a formato post.
Por eso, cuando hago las actualizaciones de la semana, siempre te digo que tiene un equivalente en el blog.

No sé si este video en particular lo lleve a post, porque hay algunos que no valen mucho la pena. Pero cuando es sobre codificación, por ejemplo, sí le pido a la IA que me traduzca todo lo que digo en el video hablado a texto escrito.

Copio y pego ese texto aquí en ChatGPT y le digo tal cual: “Mejora la redacción del bloque de texto. Coloca títulos, comas, puntos, acentuaciones y todo lo demás”.

Cuando el texto es transcrito desde lo hablado, normalmente no tiene buena puntuación. Queda hecho un desastre.
Entonces le pido que no me cambie demasiado la redacción, solo que me la adapte un poco si detecta errores o cosas que yo haya dicho mal. Esa es la flexibilidad que le doy.

También podría decirle que no me cambie nada. Depende de cómo lo quieras usar.

En mi caso, me gusta así. Ese es mi prompt, y con eso me lo genera perfectamente.

Este trabajo yo antes lo hacía a mano, pero como siempre ando con poco tiempo, claramente ChatGPT lo hace en segundos. Solo le paso el bloque de texto y listo.

Puedes ver el resultado final, esta publicación fue mejorada en base a lo comentado en la misma.

Me separa los puntos, reconoce bien el texto, lo acomoda. Para mí, este es un buen uso de la IA: como asistente para dar formato, ubicar errores, y demás.

Un mal uso de la IA

Un mal uso de la IA, como decía esa persona en su crítica, sería decirle: “Genérame todo el contenido”.

Eso es muy distinto a lo que hago yo. Aunque el prompt esté bien hecho, si le pides que te cree todo desde cero, lo que estás haciendo es repetir eso tanto en el video como en la publicación, y copiar tal cual el texto generado.

En mi caso, por más que use mis palabras habladas, lo que hace la IA es darle formato y mejorarlo un poquito. Pero el contenido es completamente mío.

Como NO usar la IA al momento de programar

Voy a sacar a colación algunos puntos, sin ningún problema personal contra el autor de la publicación. Solo critico su idea, ya que considero que no es correcta en base a la siguiente afirmación:
 

ÚLTIMA HORA: Construí una app completa de reservas para espacios de coworking en menos de 15 minutos.

Un solo prompt. Sin código. Sin equipo de desarrollo.

Solo una app funcional con pago integrado.

El autor comenta que, en menos de 15 minutos, generó una aplicación completa de reservas, con todo lo que esto implica. Lo hizo usando un único prompt.

Aquí ya se ve el problema: en lugar de crear un prompt con contexto y detalles, usó lo que yo llamo un prompt vago. Lo correcto sería, por ejemplo, pedirle a la IA que primero cree los tests para dar más contexto, crear un ecosistema estable y evitar que el resultado cambie demasiado.

Sin embargo, este autor usó un solo prompt, sin código previo, sin equipo de desarrollo, y en apenas 15 minutos (incluyendo el tiempo de escritura y de generación automática).

Aspectos técnicos cuestionables

Esto es un claro ejemplo de lo que no se debe hacer:

• Uso de prompts vagos.
• Generación de aplicaciones completas sin supervisión humana real.
• Ausencia de revisión de código.

La IA debe ser un copiloto, no el piloto. Como GitHub Copilot indica en su nombre, el programador eres tú, y la IA solo asiste. Es tu responsabilidad supervisar el código y asegurarte de que sea funcional, seguro y actualizado.

El código generado por IA puede:

• Estar desactualizado.
• Usar librerías o frameworks obsoletos.
• Presentar incompatibilidades y fallos inesperados.
• No seguir buenas prácticas, generando vulnerabilidades.

Que una aplicación "se vea bonita" no significa que sea funcional. Sin revisión, es como trabajar con una caja negra: no sabes lo que hay dentro.

Comparación con plantillas

Esto me recuerda a cuando antes se usaban templates. Por ejemplo, en Flutter puedes encontrar miles de plantillas en internet. Si no sabes programar, puedes comprarlas y luego presumir de haber hecho una aplicación, cuando en realidad solo la descargaste y configuraste mínimamente.

Al menos en las plantillas de pago, el código suele estar revisado por programadores y seguir estándares. Con la IA no hay esa garantía, y a mayor tamaño del proyecto, mayor riesgo de errores.

El problema de ese tipo de contenido

Este tipo de publicaciones no solo generan confusión, sino que alimentan el mito de que "la programación está muerta". En realidad, lo que hacen es buscar likes y vender servicios, aparentando ser expertos en IA cuando hacen lo contrario a lo que recomiendan expertos reales, como el jefe de Google Chrome.

En mi opinión, este tipo de contenido es tóxico para la comunidad.

Usar la IA como Programador: Un fragmento de Código vale mas que mil palabras

¿Se puede programar solo con IA?

La pregunta se repite mucho en foros y redes: ¿vale la pena aprender a programar si existe la IA? La respuesta corta es sí, sigue siendo indispensable. La IA puede generar bloques de código, pero sin entender la lógica detrás, todo se convierte en una caja negra. En mi caso, lo comprobé cuando pedí ayuda a ChatGPT para un modelo en Django Admin: la solución parecía correcta, pero al probarla no funcionaba. Ahí entendí que si no sabes programar, no puedes validar lo que la IA te devuelve.

La ilusión de la "caja negra"

Muchos creen que basta con describir lo que quieren y la IA hará todo. Eso puede servir para prototipos rápidos, pero es peligroso depender solo de eso. Si no sabes leer ni adaptar el código, cualquier error puede bloquearte.

Por qué seguir aprendiendo código es indispensable

Saber programar te permite corregir, adaptar y mejorar lo que la IA genera. Además, sin ese conocimiento, no sabrías ni qué pedirle ni cómo validar las respuestas.

Ventajas y riesgos de usar IA para programar

Lo que sí hace bien la IA en programación

• Generar ejemplos rápidos de código.
• Explicar funciones o librerías desconocidas.
• Acelerar la curva de aprendizaje en un nuevo framework.

En mi experiencia, un fragmento de código bien dado a la IA es como oro: "un fragmento de código vale más que mil palabras".

Errores comunes y limitaciones

• La IA se puede equivocar con detalles técnicos.
• No siempre entiende el contexto completo.
• Puede dar soluciones más complejas de lo necesario (como me pasó en Django).

En resumen: la IA no sustituye al criterio humano.

El rol del programador frente a la inteligencia artificial

De traductor de ideas a validador de código

El papel del programador cambia: antes escribíamos todo desde cero; ahora también revisamos y adaptamos lo que propone la IA. La habilidad clave es saber evaluar.

El criterio humano como última palabra

Un fragmento de código vale más que mil palabras

Cuando quiero una solución precisa, no me limito a escribir: “hazme un CRUD en Django”. Prefiero pasarle código y añadir una breve explicación. Así la respuesta parte de un contexto sólido.

Yo lo vi claro cuando comparé varias IAs. La diferencia no estuvo tanto en la calidad de la respuesta, sino en mi capacidad de decidir cuál solución tenía sentido.

Para programar, usualmente uso la IA presentando un bloque de código  seguido de una breve explicación de lo que quiero:

@admin.register(Payment) 
class PaymentAdmin(admin.ModelAdmin): 
   list_display = ('id', 'user', 'orderId', 'price') 
   
class Payment(models.Model): 
   content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE) 
   object_id = models.PositiveIntegerField() 
   paymentable = GenericForeignKey('content_type', 'object_id') 

Tengo un campo generic, pero en Django ADmin solamente quiero que peuda ser de tipo Product o Book

Esto para mi es clave ya que, le doy mucho contexto mediante el código y le digo que es lo que quiero que me resuelva.

Para mí, una frase clave aquí es: “un fragmento de código vale más que mil palabras”.

Por eso, en vez de explicarle todo, simplemente le pasé:

• El código principal del PaymentItem.
• La relación que estaba usando.
• Una breve explicación de lo que quería.

Este tipo de prompts casi siempre me funciona.

La solución que me dio fue usar un método interno de Django Admin para modificar estos campos. Me explicó bien la lógica, pero no funcionó, porque el tipo de dato devuelto no era el correcto. En vez de simplificar, complicó más la consulta:

def formfield_for_foreignkey(self, db_field, request, **kwargs):
    if db_field.name == "content_type":
        allowed_models = [Product, Book]
        allowed_cts = ContentType.objects.get_for_models(*allowed_models).values()
        kwargs["queryset"] = ContentType.objects.filter(id__in=[ct.id for ct in allowed_cts])
    return super().formfield_for_foreignkey(db_field, request, **kwargs)

De aquí saco varias conclusiones:

• ChatGPT no es perfecto. Puede equivocarse incluso con consultas sencillas.
• La IA es un asistente, no una solución mágica. Hay que evaluar lo que devuelve y adaptarlo.
• El prompt importa. Un código bien puesto vale más que muchas explicaciones.
• Tienes que saber programar. Si no entiendes lo que pides, ¿cómo vas a validar la respuesta?.
• Siempre hay que emplear más de una herramienta (IA en este ejemplo).

Esto es la clave para mi en el uso de la IA como una herramienta y el mejor uso que le podemos dar como desarrolladores es que, primero nosotros sepamos programar para exprimir e mejor resultado

Muchos que generan apps en segundos con IA no saben realmente qué está pasando en el código.
Eso es peligroso porque ven todo como una caja negra.

Comparación con otras IA: Gemini y Perplexity

Le pasé el mismo prompt y me devolvió una solución que al principio no entendí bien. Creaba un atributo adicional con reglas, cosa que no me convencía. Después noté que sí lo aplicaba al modelo, pero igual la sintaxis no me gustó o no la había entendido al inicio:

limit = Q(app_label='your_app_name', model='product') | Q(app_label='your_app_name', model='book')
content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE, limit_choices_to=limit)

Un problema de Gemini: no guarda tan bien el contexto. Con ChatGPT puedo decirle “que es limit” y lo entiende. Gemini, en cambio, muchas veces no conecta con lo dicho antes y me hizo una explicación de que era limit en el SQL, que no tenía nada que ver con la consulta inicial…

Después fui a Perplexity, que casi nadie menciona, y fue la más acertada.
Su respuesta fue justo lo que yo necesitaba:

content_type = models.ForeignKey(
        ContentType,
        on_delete=models.CASCADE,
        limit_choices_to=Q(app_label='mi_app', model='product') | Q(app_label='mi_app', model='book')
    )

Necesitaba limitar un campo genérico en mi modelo Payment para que solo aceptara Product o Book. Le pasé el código y pedí ayuda. ChatGPT me dio una opción con formfield_for_foreignkey que no funcionó del todo. Gemini me ofreció otra, pero perdió el hilo del contexto. Finalmente, Perplexity me devolvió justo lo que necesitaba con limit_choices_to. Ese contraste me demostró que usar varias IA en paralelo es clave.

Comparativa práctica: ChatGPT vs Gemini vs Perplexity en programación

ChatGPT: bueno en contexto, pero se equivoca

Ventaja: entiende cuando le das seguimiento a una conversación.
Problema: puede dar soluciones erróneas que parecen correctas.

Gemini: pierde continuidad

Ventaja: respuestas rápidas y concisas.
Problema: al preguntarle por "limit", me respondió sobre SQL, sin relación con el caso de Django. Pierde el contexto.

Perplexity: la sorpresa más útil

Ventaja: sugiere respuestas más ajustadas y con documentación.
En mi caso, fue la que dio la solución correcta al problema del ForeignKey.

Moralejas finales

De todo esto me quedo con 5 puntos:

• Un fragmento de código vale más que mil palabras, ya que, podemos pasarle el contexto de lo que queremos y la respuesta estará basada en este código.
• Saber programar es indispensable. Sin eso, no sabrás ni qué pedir ni cómo validar y con esto, pasarle el código del punto 1.
• No te cases con una sola IA. Usa varias, compáralas y cruza resultados.
• El criterio humano es lo que marca la diferencia.
• En programación, la IA es una gran ayuda, pero la última palabra siempre la tiene el desarrollador.
• No casarse con una sola IA
  • Cada herramienta tiene fortalezas y debilidades. Usarlas en paralelo permite contrastar.
• Saber programar primero
  • La base sigue siendo el conocimiento humano. Sin él, la IA es solo ruido.
• Usar la IA como copiloto, no como piloto
  • La mejor combinación es cuando tú decides el rumbo y la IA acelera el proceso.

Vibe coding y 5000 Apps VULNERABLES!

El auge de la inteligencia artificial ha facilitado que personas sin conocimientos técnicos avanzados en ingeniería de software intenten desarrollar y lanzar aplicaciones profesionales a producción. Sin embargo, este enfoque introduce riesgos críticos de seguridad informática si se delega la construcción del software por completo en la IA sin un criterio técnico de supervisión.

Una investigación reciente detectó más de 5,000 aplicaciones y sitios web vulnerables expuestos en internet debido a deficiencias estructurales en el código generado por IA y a errores básicos en la configuración del despliegue.

1. El Vector de Ataque: Indexación y Exposición de Entornos Temporales

El problema de seguridad no se origina mediante técnicas complejas de intrusión (hacking), sino a través del uso estratégico de motores de búsqueda como Google o Bing.

Las plataformas de desarrollo rápido y entornos en la nube (como Replit o Netlify) permiten alojar aplicaciones de forma automática, generando URLs provisionales para la fase de pruebas. El riesgo crítico surge cuando estas direcciones temporales son indexadas por los buscadores debido a la ausencia de configuraciones preventivas:

• Ausencia de directivas de indexación: Un desarrollador con conocimientos web implementa de forma estándar un archivo robots.txt para instruir a los motores de búsqueda qué secciones o entornos provisionales no deben ser indexados. Las personas que carecen de formación técnica omiten este paso básico.
• Búsquedas indexadas de alto valor: Los atacantes realizan consultas estructuradas en los buscadores intentando localizar subdominios de plataformas de despliegue (netlify.app, replit.dev, etc.) asociados a términos financieros o corporativos clave como "comisiones", "ventas", "inventario" o "médico".

       MÉTODO DE EXPOSICIÓN Y RASTREO DE ENTORNOS
       
[ Usuario sin criterio ] ---> Genera App con IA ---> Despliegue Automático (Netlify)
                                                             |
                                                             v
[ Rastreador de Google ] <--- URL Indexada de forma pública <--- Sin robots.txt
          |
          v
[ Auditoría del Atacante ] ---> Búsqueda en Google ("site:netlify.app ventas") ---> Acceso a la Data

2. Las Limitaciones de los Prompts Genéricos y los Sesgos de la IA

La Inteligencia Artificial no actúa de forma autónoma ni posee la responsabilidad de auditar el contexto de seguridad; genera estrictamente el código que el usuario solicita.

Cuando una persona sin bases de programación interactúa con un modelo de lenguaje, tiende a utilizar instrucciones ejecutivas masivas e imprecisas, tales como: "Diseña un sistema para gestionar un hospital" o "Crea una aplicación de inventario".

Este enfoque de interacción directa genera múltiples inconvenientes:

Pérdida de Calidad por Densidad

A mayor cantidad de requerimientos simultáneos en una sola instrucción (prompt), menor será la precisión y la calidad del código devuelto por el modelo.

Falta de Descomposición Modular

Un ingeniero de software posee el criterio para fragmentar el desarrollo de una aplicación compleja en múltiples tareas atómicas y especializadas. Un usuario no técnico carece de la lógica necesaria para dividir los procesos en pasos manejables, imposibilitando la optimización incremental del sistema.

Patrones y Sesgos Predictivos

Debido a la naturaleza de los modelos de lenguaje, ante peticiones genéricas, la IA suele estructurar soluciones con los parámetros mínimos viables. Esto incluye la creación de sistemas de autenticación débiles, credenciales quemadas en el código fuente (hardcoded) o estructuras predecibles (como contraseñas maestras del tipo 123456). Los atacantes conocen estos sesgos algorítmicos y los explotan de forma masiva al localizar las aplicaciones expuestas.

3. Consecuencias del Despliegue Inseguro y Fugas de Información

Las auditorías realizadas sobre estas URLs expuestas revelaron fugas masivas de bases de datos y archivos privados en producción, comprometiendo activos críticos como:

• Cuadrantes de turnos hospitalarios y expedientes de datos médicos.
• Presentaciones de planes estratégicos de empresas.
• Registros de usuarios completos con nombres, apellidos y números telefónicos.
• Historiales de conversaciones privadas con chatbots corporativos.

El acceso a estos entornos no solo representa una fuga de información privada regulada por normativas internacionales, sino que permite a usuarios malintencionados tomar el control administrativo de la aplicación y bloquear el acceso a los creadores originales debido a la falta de validación de privilegios en el backend.

Diez trucos para escribir mejores prompts IA

Cómo escribir los mejores prompts y lograr que la IA haga lo que necesitas

En este video quiero compartir algunas recomendaciones que considero muy importantes. Estos 10 trucos no son solo para ChatGPT, sino también para cualquier otra IA que funcione de manera similar, como Gemini, Claude, Perplexity, etc.

1. Ser concreto y dar contexto

Estos dos puntos van muy de la mano. Mientras más detallada y clara sea la instrucción que le des a la IA, mejor será la respuesta. No seas como cierto “experto” que analizamos en otro video (no es hate, solo análisis), donde comentaba que generó una aplicación en 15 minutos.

Si quieres una aplicación de notas, especifica que tenga título, descripción, posibilidad de subir imágenes, etc. Cuanto más contexto, mejor.

2. Haz cambios parciales

Recomiendo trabajar en iteraciones pequeñas. Por ejemplo, si quieres agregar una validación, indícale exactamente qué quieres:

• Una clase de request en Laravel.
• O añadir la validación en el controlador, con cierta longitud, reglas, etc.
• Así evitas que la IA divague demasiado y obtienes resultados más cercanos a lo esperado.

3. Define el formato de salida

Aunque hablo principalmente de código, también puedes pedir otros formatos: lista, tabla, esquema, paso a paso, etc.

4. Usa ejemplos

Es una de las mejores prácticas. En programación, si ya tienes una clase o estructura, pásasela a la IA y dile que la adapte a otro lenguaje o framework.
Yo, por ejemplo, lo hice en un curso de Django: tomaba clases de Laravel y pedía que las tradujera a Django. Esto me daba una base sólida desde la cual partir.

Lo mismo aplica si quieres generar imágenes u otro contenido: mientras más ejemplos, mejor.

5. Establece el rol

Hoy en día los modelos suelen inferir el rol automáticamente (periodista, programador, etc.), pero si no obtienes la respuesta que quieres, indícale explícitamente que actúe como tal.

6. Controla la extensión

Si quieres un resumen breve, o un texto largo, indícalo con claridad. Palabras, caracteres o párrafos: la extensión es parte del control del resultado.

7. Reformula cuando sea necesario

Si el resultado no es el esperado, simplemente replantea el prompt.

8. Haz preguntas abiertas

No siempre necesitas una respuesta cerrada. A veces lo que buscas es una lista de ideas, alternativas o lluvia de ideas.

9. Indica restricciones

Si quieres usar ciertas tecnologías, frameworks o lenguajes, dilo claramente. Si no, la IA usará lo que “considere mejor” y quizá no sea lo que buscas.

Por eso es clave que tengamos conocimientos básicos de lo que pedimos. Recuerda: el piloto eres tú, la IA es solo la herramienta.

10. Combina creatividad y precisión

Varía el prompt cuando lo veas necesario. Experimenta.

FAQs

• ¿Es recomendable aprender a programar si existe la IA?
  • Sí, porque sin conocimientos básicos no puedes validar ni adaptar lo que la IA genera.
• ¿Qué IA es mejor para programar: ChatGPT, Gemini o Perplexity?
  • Depende del caso. ChatGPT es bueno en contexto, Gemini es más limitado y Perplexity sorprendió por su precisión.
• ¿Se puede programar sin saber código usando solo IA?
  • Puedes, pero no deberías. Te quedarás atado a una caja negra sin capacidad de validar.
• ¿Qué riesgos tiene depender demasiado de la IA en programación?
  • Errores no detectados, código innecesariamente complejo y dependencia total de la herramienta.
• ¿Cómo escribir buenos prompts para programar con IA?
  • Usa fragmentos de código, da contexto y pide explicaciones paso a paso.

Conclusión

La democratización del desarrollo mediante herramientas de Inteligencia Artificial debe ir acompañada de un proceso de capacitación técnica. La IA es un excelente asistente de automatización y refactorización, pero requiere que el operador posea criterios de arquitectura, diseño de pruebas y seguridad informática.

Directrices para un Desarrollo Seguro con IA:
Desarrollo Incremental: Evitar la generación de bloques de código masivos. Dividir la lógica en funciones específicas, validar el resultado de cada fragmento y escribir pruebas automatizadas unitarias para certificar su comportamiento.

Implementación de Agentes de Control: Diseñar flujos de desarrollo donde un agente o modelo alternativo audite la calidad, el rendimiento y las posibles brechas de seguridad del código generado en la primera iteración.

Formación Técnica de Base: Es indispensable adquirir conocimientos mínimos de infraestructura web, protocolos de autenticación y seguridad antes de trasladar cualquier proyecto a un entorno de producción accesible por internet.

Entonces, volviendo a la pregunta inicial: ¿vale la pena seguir haciendo estos recursos? Por supuesto. No solo vale la pena, sino que es más importante que nunca enseñar cómo usar correctamente estas nuevas herramientas, como la IA, dentro de un flujo de trabajo profesional y enfocado en buenas prácticas.

Aquí no se trata de que la IA lo haga todo. Se trata de cómo tú, con tu conocimiento, la diriges para obtener resultados útiles y valiosos.

El uso de la IA en la programación y la falta de confianza en su código

Prácticamente todos los desarrolladores utilizan inteligencia artificial en su día a día, pero muy pocos confían plenamente en el código que genera. 

La IA dejó de ser una promesa de futuro para convertirse en una herramienta imprescindible del presente. Utilizada de forma correcta, permite agilizar la implementación, reducir tiempos y facilitar la descomposición de tareas complejas o repetitivas.

El problema principal surge cuando no realizamos peticiones precisas. Al solicitar algo demasiado general o extenso, la IA elegirá de forma arbitraria una de las múltiples vías posibles. Para evitar esto, conviene dividir las solicitudes en tareas pequeñas y muy bien especificadas. Sin embargo, aun con el mejor prompt, siempre debe existir una etapa de revisión.

Supervisión humana frente al enfoque de «Harness Engineering»

Existe un debate sobre cómo debe realizarse la validación del código generado. Robert C. Martin («Uncle Bob»), autor del libro Clean Code, afirmó recientemente que revisar manualmente cada línea de código elimina gran parte de la productividad ganada al usar agentes de programación. Su postura plantea que, cuanto menos intervenga el factor humano en la generación y revisión, más rápido se puede avanzar, siempre y cuando se implementen las capas de control automatizadas correspondientes —concepto conocido como Harness Engineering—.

Esta metodología consiste en definir reglas, pruebas y límites estrictos para que la propia IA valide su trabajo antes de aplicar los cambios. Sin embargo, este enfoque requiere un consumo masivo de tokens. Un caso documentado demostró cómo un agente consumió un plan de $100 dólares sin lograr completar la tarea asignada. Por lo tanto, si bien es una alternativa eficiente para ciertos flujos, resulta costosa. Para la mayoría de los proyectos convencionales, la revisión humana sigue siendo la opción más viable y equilibrada.

Sistemas complejos y limitaciones de la IA

Incluso referentes de la industria señalan las fallas de estos modelos. La mano derecha de Linus Torvalds afirmó que cerca de un tercio de los resultados generados por IA son erróneos o potencialmente perjudiciales para la base de código. Esto se debe a que, cuanto más específico o complejo es el desarrollo, peores suelen ser los resultados del modelo.

Las herramientas de IA responden bien ante patrones comunes, pero fallan cuando se enfrentan a casos de nicho o librerías poco extendidas. Por ejemplo, al solicitar una refactorización para la generación de archivos EPUB en un entorno backend, la IA cometió errores básicos en la estructura del constructor. Al existir menos volumen de entrenamiento para ese tipo de tareas específicas en comparación con un flujo estándar, la probabilidad de alucinación o error aumenta considerablemente.

El nuevo rol del desarrollador: de programador a orquestador

El propio Linus Torvalds ha comentado que actualmente apenas escribe código de forma habitual: su función principal consiste en supervisar las contribuciones creadas y decidir qué cambios integrarse. Ha pasado a ser, esencialmente, un orquestador.

Este cambio refleja la evolución del perfil técnico. Nuestra función principal nunca ha sido redactar líneas de código de manera mecánica, sino diseñar soluciones a medida siguiendo buenas prácticas de arquitectura. Con la llegada de la IA, el desarrollador asume un rol similar al de un director o líder técnico.

Esto no significa que saber programar haya dejado de ser necesario; al contrario, resulta indispensable. El pensamiento crítico, la capacidad de guiar a la herramienta de forma precisa y la habilidad para auditar el código generado exigen un conocimiento profundo de los fundamentos de la programación.

La importancia de SABER programar: Estrategia de prompts y evitar que la IA rompa tu código

A continuación, analizaremos un flujo de trabajo práctico para construir un módulo de valoraciones (ratings) utilizando asistencia por inteligencia artificial. Este módulo funciona como un CRUD donde los usuarios pueden consultar y gestionar las valoraciones de un recurso específico.

Para lograrlo, se implementó una relación polimórfica en Laravel utilizando los campos ratable_id y ratable_type. Esta estructura permite vincular las valoraciones de forma dinámica a múltiples entidades del sistema, como cursos y libros, con la flexibilidad de extenderlo a nuevos recursos en el futuro.

Este ejemplo sirve para ilustrar un punto fundamental: la importancia de poseer fundamentos sólidos de programación al momento de integrar código generado por IA. Aunque la herramienta facilita la escritura inicial, el desarrollador debe evaluar si la arquitectura propuesta se alinea con la estructura y las buenas prácticas del proyecto.

Flujo de trabajo y diseño de prompts estructurados

Para abordar un cambio de esta magnitud —que involucra la creación del modelo, las migraciones, los puntos de entrada de la API REST, los controladores y las pruebas unitarias— es recomendable mantener un hilo de conversación enfocado únicamente en el desarrollo del proyecto.

Un flujo de trabajo eficiente consta de las siguientes etapas:

• Definición del alcance: Explicar a la IA qué módulos se van a construir y cuáles son las entidades involucradas.
• Especificación del contexto técnico: Indicar la estructura exacta de la base de datos, los estándares de nomenclatura y los paquetes instalados (por ejemplo, el manejo de traducciones o módulos de localización).
• Generación de la propuesta: Solicitar un plan de ejecución antes de aplicar cambios directamente en el código.

Por favor, implementa la funcionalidad backend para el módulo de calificaciones polimórficas (Ratings/Reviews) en nuestra aplicación Laravel 13 siguiendo estrictamente las guías de nuestro archivo `AGENTS.md`.

### Requisitos Funcionales y De Arquitectura

1. **Migración:**
   - Crear la tabla `ratings` (o `reviews`).
   - Campos necesarios:
     - `id`
     - `title` (string, nullable o required según considere mejor el diseño)
     - `user_id` (foreign key constreñida a `users`, con borrado en cascada)
     - `description` (text)
     - `rating` (tinyInteger o unsignedTinyInteger, limitado a un rango de 1 a 5)
     - `edited_at` (timestamp, nullable) para registrar cuando la reseña ha sido modificada por el usuario
     - Relación polimórfica: `rateable_id` y `rateable_type` (puedes usar `$table->morphs('rateable')`)
     - Timestamps estándar de Laravel (`created_at`, `updated_at`)

2. **Modelo y Traits (`app/Models/Rating.php`):**
   - Crear el modelo `Rating` usando PHP 8 attributes para los campos asignables/ocultos si aplica (`#[Fillable]`, etc.).
   - Definir la relación polimórfica `rateable(): MorphTo`.
   - Definir la relación `user(): BelongsTo`.
   - Añadir el trait `HasFactory` con la anotación `@use` en la PHPDoc.
   - Declarar explicitamente los tipos de retorno y parámetros en todos los métodos.
   - Crear también el Factory (`RatingFactory`) y el Seeder correspondiente.

3. **Integración en Modelos Existentes (`Book` y `Tutorial`):**
   - Añadir la relación polimórfica `ratings(): MorphMany` en `app/Models/Book.php` y `app/Models/Tutorial.php`.
   - Incluir un método o trait auxiliar para obtener el promedio de calificación rápidamente si resulta conveniente.

4. **Controladores y API Routes (`app/Http/Controllers/Api/v1/`):**
   - Crear el controlador API correspondiente para gestionar el CRUD de calificaciones.
   - Las rutas deben ubicarse en `routes/api/v1/` y responder a endpoints versionados.
   - Toda validación de entrada debe realizarse mediante `Validator::make()` dentro de clases de acción o usando traits dedicados en `app/Concerns/`.
   - Las respuestas deben envolverse o estructurarse usando Eloquent API Resources (`app/Http/Resources/RatingResource.php`).
   - Al editar una calificación, se debe actualizar automáticamente el campo `edited_at` con la fecha/hora actual (`now()`).

5. **Localización e i18n:**
   - Todos los mensajes de respuesta, validaciones o textos dirigidos al usuario devueltos desde el servidor deben traducirse e incluirse exclusivamente en archivos dentro de la carpeta `lang/`.

6. **Pruebas (Pest):**
   - Crear la suite de pruebas en `tests/Feature/RatingTest.php` usando Pest (`php artisan make:test --pest RatingTest`).
   - Cobertura necesaria: creación de calificación para un libro/tutorial, validación del rango 1-5, edición registrando `edited_at`, borrado y consulta del promedio.

### Reglas Estrictas a Seguir:
- Aplica formato con Laravel Pint (`vendor/bin/pint --format agent`).
- Todos los métodos deben llevar tipos de retorno y parámetros explícitos.
- Usa bloques PHPDoc para documentación donde corresponda.
- NUNCA hagas push ni sincronices cambios con GitHub.
- Ejecuta las pruebas Pest pertinentes antes de dar por finalizada la tarea.

Definir con precisión el contexto evita la necesidad de recurrir a ejecuciones masivas de agentes autónomos que consumen un volumen elevado de tokens. Mantener el rol de revisor humano permite controlar el diseño del sistema, comprender la evolución de la base de código y evitar la desconexión con la arquitectura de la aplicación.

Integración en el frontend con Vue.js

Tras completar la capa del backend, se procede a la integración en la interfaz de usuario utilizando Vue.js. Al proporcionarle a la IA la lista exacta de archivos que componen la vista (componentes, gestores de rutas y archivos de traducción), la herramienta puede generar las peticiones HTTP y los elementos reactivos sin hardcodear rutas ni omitir claves de localización.

Por ejemplo, en la vista del recurso se evalúa el estado del usuario: si no ha adquirido el libro o curso, el formulario de valoración no se despliega. Si ya está registrado, la interfaz habilita la visualización y edición de las estrellas y la reseña correspondiente.

Por favor, crea la interfaz frontend en Vue 3 para el módulo de calificaciones/reseñas en la app de la academia, siguiendo estrictamente las reglas de `AGENTS.md`.

### Requisitos Frontend:

1. **Componentes a crear (`resources/js/vue/components/ratings/`):**
   - `RatingWidget.vue`: Componente reutilizable con el selector de 1 a 5 estrellas, campos de texto `title` y `description`, botón de guardar/editar y listado de reseñas existentes.
   - `RatingModal.vue`: Modal emergente que envuelve el `RatingWidget` para vistas compactas.

2. **Ubicación e Integración:**
   - **Vista de Cursos:** Añadir la pestaña `VALORACIONES` en la barra de navegación del reproductor de clases e integrar `RatingWidget.vue`.
   - **Vista de Libros:** Añadir el botón `⭐ Valorar libro` debajo de la portada (junto a "Ver adentro" y "Más opciones") que active el `RatingModal.vue`.

3. **Verificación de Compra / Acceso:**
   - Solo mostrar el formulario de reseña si el usuario autenticado ha comprado el recurso actual (`is_purchased` o mediante la API). Si no lo ha comprado, mostrar únicamente las valoraciones públicas.
   - Si el usuario ya dejó una reseña, cargar sus datos previos en el formulario, permitir la edición y enviar la petición correspondiente actualizando la fecha de edición.

4. **Reglas de Código y Estilos:**
   - Usar Vue 3 Composition API con `<script setup>`.
   - **Endpoints:** Definir OBLIGATORIAMENTE todas las URLs de la API en `resources/js/vue/config/api.js` dentro del objeto `API_URLS` (ej: `API_URLS.RATINGS`). Prohibido hardcodear URLs en componentes.
   - **i18n / Traducciones:** Todos los textos de la interfaz deben usarse mediante `$t('key')` y ser añadidos a los archivos de idioma en `resources/js/vue/locales/`.
   - **Estilos:** Tailwind CSS v4 integrando el tema oscuro (`dark:`) de la aplicación.

5. **Lógica de Estado:**
   - Manejar peticiones HTTP mediante Axios (o Pinia store si aplica) con estados de carga (`loading`), manejo de errores y notificaciones de éxito.

Optimizaciones finales y refactorización del código generado

Aunque la IA genere código funcional, suele pecar de ser excesivamente verbosa o redundante, agregando condicionales innecesarios por no conocer el contexto global de la aplicación. A continuación, se analiza un caso típico de refactorización sobre un controlador:

// Código redundante generado por IA
$user = $this->getUser($request);

if (!$user) {
    return response()->json(['message' => 'Unauthenticated'], 401);
}

if ($rating->user_id !== $user->id) {
    return response()->json(['message' => 'Unauthorized'], 403);
}

En este escenario, si el método getUser() está respaldado por mecanismos de autenticación como Laravel Sanctum o la gestión de sesiones nativa, y la ruta ya cuenta con el middleware de protección correspondiente, la verificación manual de $user === null resulta redundante.

Aplicando las capacidades del ORM Eloquent, el flujo se puede simplificar drásticamente limitando la consulta directamente a los recursos que pertenecen al usuario autenticado:

// Refactorización optimizada
$user->ratings()->where('id', $ratingId)->update([
    'score' => $request->input('score'),
    'review' => $request->input('review'),
]);

Reducir la cantidad de bloques condicionales no solo mejora la legibilidad, sino que simplifica el mantenimiento del sistema a largo plazo. Mantener una base de código magra y expresiva sigue siendo responsabilidad directa del desarrollador.