Muchas personas me han preguntado últimamente:
“¿Cómo comienzo en el mundo de la Inteligencia Artificial, la programación y la creación de agentes?”
Así que decidí escribir la respuesta más completa que pudiera.
No pretendo que esta sea la única ruta. Es simplemente la ruta que, con lo que sé hoy, 1 de octubre de 2026, recomendaría a alguien que quiere comenzar desde cero y llegar al punto en el que pueda construir sus propias aplicaciones con Inteligencia Artificial.
Y quiero comenzar con algo que para mí es fundamental:
No necesitas aprender todo antes de comenzar a construir.
De hecho, creo exactamente lo contrario.
La mejor manera de aprender este mundo es construyendo cosas pequeñas, equivocándote, preguntándole a la IA, corrigiendo y volviendo a construir.
En mi caso, la Inteligencia Artificial se ha convertido en un gran maestro.
He tomado cursos, leído documentación, visto videos y estudiado tecnología durante muchos años. Todo eso sigue siendo valioso. Pero pocas herramientas educativas me han permitido aprender con la velocidad con la que hoy puedo aprender teniendo al lado una IA a la que puedo preguntarle:
“No entendí esto. Explícamelo de otra manera.”
“Ponme un ejemplo.”
“Ahora hazlo más difícil.”
“Déjame intentarlo.”
“No continúes hasta que yo lo haya entendido.”
Eso cambia radicalmente la forma de aprender.
Esta es la ruta que recomiendo.
0. Antes de comenzar: cambia la forma de aprender
Hay una idea que atraviesa toda esta guía:
No utilices la IA solamente para que haga cosas por ti. Utilízala para que te enseñe a hacerlas.
Son dos usos completamente diferentes.
Puedes decir:
“Hazme una aplicación en Python.”
Y probablemente obtendrás código.
Pero también puedes decir:
“Quiero aprender Python construyendo una aplicación sencilla. Actúa como profesor. Explícame cada decisión. Avancemos paso a paso. No continúes hasta que yo confirme que entendí.”
La segunda aproximación construye algo mucho más importante que una aplicación:
construye conocimiento.
1. Comprende qué es realmente un LLM
Antes de crear aplicaciones con Inteligencia Artificial considero casi obligatorio comprender, al menos conceptualmente, qué es un Large Language Model — LLM.
No tienes que convertirte en investigador de Machine Learning.
Pero sí deberías comprender conceptos como:
- tokens,
- ventana de contexto,
- probabilidades,
- temperatura,
- prompt,
- alucinaciones,
- entrenamiento,
- inferencia,
- embeddings,
- modelos fundacionales.
Y, sobre todo, comprender una idea:
Un LLM no es una base de datos que “conoce la respuesta”. Es fundamentalmente un sistema probabilístico que genera una continuación plausible a partir del contexto recibido.
Eso explica muchas de sus fortalezas.
Y también muchas de sus limitaciones.
Para comenzar recomiendo ver este video:
No pases demasiado rápido por esta etapa.
Cuando entiendes aproximadamente qué ocurre detrás de un LLM, comienzas a utilizarlo de una manera completamente diferente.
2. Aprende Prompt Engineering
El siguiente paso es aprender a comunicarse correctamente con estos modelos.
Es decir: Prompt Engineering.
Puede parecer que esto perderá importancia porque los modelos cada vez entienden mejor nuestras intenciones.
En cierta forma es verdad.
Pero existe una habilidad más profunda que probablemente seguirá siendo muy importante:
aprender a expresar claramente una intención, proporcionar contexto, definir restricciones y describir cómo reconocer una buena respuesta.
Eso sirve para conversar con ChatGPT.
Pero también sirve para programar con agentes, desarrollar software con IA, construir automatizaciones y crear sistemas agénticos.
Un buen prompt debería enseñarte a pensar en:
- Rol: quién quiero que sea la IA.
- Contexto: qué necesita saber.
- Objetivo: qué quiero lograr.
- Restricciones: qué puede y qué no puede hacer.
- Criterios de éxito: cómo sé que la respuesta es buena.
- Formato: cómo quiero recibir la respuesta.
- Ejemplos: qué significa para mí una respuesta correcta.
Por ejemplo:
Rol: Actúa como arquitecto de software senior.
Contexto: Estoy construyendo una aplicación de citas médicas con React y Python.
Objetivo: Ayúdame a identificar los requerimientos funcionales.
Restricciones: El sistema inicialmente no tendrá pagos ni integración con EPS.
Proceso: Hazme preguntas antes de proponer la arquitectura.
Formato: Organiza los requerimientos por épicas e historias de usuario.
Eso ya es mucho más poderoso que decir:
“Créame una aplicación de citas.”
¿Dónde aprender Prompt Engineering?
Tienes muchas opciones.
Puedes hacer un curso en Udemy, buscar cursos y tutoriales en YouTube o utilizar directamente ChatGPT, Claude o Gemini como profesor.
Mi recomendación es combinar las tres cosas.
Pero no estudies prompting durante tres meses.
Aprende los fundamentos y comienza a utilizarlo inmediatamente en proyectos reales.
3. Después aparecen tres caminos
Una vez tienes esas dos bases —comprender aproximadamente los LLM y saber interactuar con ellos— aparecen varios caminos.
Yo los organizaría así:
- Vibe Coding: construir aplicaciones conversando con la IA.
- Spec-Driven Development: construir software mediante especificaciones explícitas.
- Desarrollo de aplicaciones y agentes de IA: comenzar a programar directamente soluciones con LLM, RAG, tools y agentes.
No son caminos excluyentes.
De hecho, recomiendo recorrer los tres.
4. Camino 1: aprende Vibe Coding
El llamado Vibe Coding consiste, simplificando mucho, en construir software mediante una conversación con una Inteligencia Artificial.
Describes lo que quieres.
La IA genera código.
Ves el resultado.
Corriges.
Refinas.
Repites.
Las herramientas cambian muy rápidamente, así que probablemente cuando leas este artículo existan otras.
A octubre de 2026, algunas herramientas que vale la pena explorar son:
Especialmente para alguien que está comenzando, estas herramientas son impresionantes porque reducen muchísimo la barrera de entrada.
Ejercicio: construye una aplicación de citas médicas
Por ejemplo, dile inicialmente a ChatGPT:
Quiero construir una aplicación sencilla para gestionar citas médicas.
Actúa como analista de producto.
Ayúdame a definir los requerimientos funcionales mínimos para una primera versión.
No programes todavía.
Quiero máximo 8 funcionalidades.
La IA probablemente te propondrá cosas como:
- crear pacientes,
- crear médicos,
- consultar disponibilidad,
- agendar una cita,
- cancelar una cita,
- consultar agenda,
- modificar una cita,
- visualizar próximas citas.
Toma esos requerimientos y llévalos a Lovable, Google AI Studio o la herramienta que quieras experimentar.
Pero aquí viene una recomendación importante:
No intentes construir toda la aplicación en un solo prompt.
Trabaja mediante incrementos pequeños.
Primero crea la pantalla principal.
Después pacientes.
Después médicos.
Después agenda.
Después citas.
Después persistencia.
Después autenticación, si realmente la necesitas.
Ese hábito de construir mediante cambios pequeños será increíblemente útil cuando pases a sistemas más grandes.
Aprende también qué hay detrás
No te conformes con que la aplicación “funcione”.
Pregúntale a la IA:
- ¿Dónde está el frontend?
- ¿Qué framework está utilizando?
- ¿Dónde están los datos?
- ¿Existe una base de datos?
- ¿Cómo se autentican los usuarios?
- ¿Dónde se almacenan las credenciales?
- ¿Cómo se despliega?
- ¿Qué riesgos de seguridad existen?
Aunque al comienzo entiendas solamente el 30 %, ya estás aprendiendo.
5. Camino 2: aprende Spec-Driven Development
Después del Vibe Coding recomiendo dar un paso adicional.
En lugar de pedir:
“Construye esto.”
aprendes primero a definir:
“Esto es exactamente lo que quiero construir.”
Ahí aparece el Spec-Driven Development — SDD.
La idea me parece especialmente poderosa en un mundo donde producir código será cada vez más barato.
Si la IA puede producir muchísimo código, entonces aumenta el valor de especificar correctamente:
- qué problema queremos solucionar,
- qué comportamiento esperamos,
- qué restricciones existen,
- cómo vamos a verificarlo,
- qué arquitectura utilizaremos,
- qué pruebas demostrarán que funciona.
Dos proyectos que recomiendo explorar son:
Con Spec Kit, por ejemplo, el flujo básico se puede entender conceptualmente como:
Constitution → Specification → Plan → Tasks → Implementation → Validation
Eso obliga a pensar antes de generar código.
Pero no estudies SDD leyendo cincuenta páginas primero
Mi recomendación es exactamente la contraria.
Apréndelo construyendo.
Este fue el tipo de prompt que utilicé para aprender:
¿Quieres aprender Spec-Driven Development? No le pidas a la IA que te lo explique. Pídele que te enseñe mientras construyes algo.
Quiero aprender Spec-Driven Development usando Spec Kit:
https://github.com/github/spec-kit
Tengo GitHub Copilot y Visual Studio Code.
Construyamos un sistema de alquiler de vehículos con React, Python y CSV.
Solo 8 funcionalidades.
Sin login.
Actúa como mi profesor.
Quiero comprender por qué hacemos cada paso.
Avancemos paso a paso.
No continúes hasta que yo confirme.
Ese pequeño cambio es importantísimo.
No estás diciendo:
“Explícame Spec-Driven Development.”
Estás diciendo:
“Enséñame Spec-Driven Development mientras desarrollamos software.”
Para mí esa es una de las mejores formas de utilizar la IA como maestro.
6. Instala un entorno básico de desarrollo
Si quieres continuar hacia aplicaciones de IA más sofisticadas, en algún momento deberías sentirte cómodo con un entorno de desarrollo.
No necesitas convertirte inmediatamente en ingeniero senior.
Pero sí necesitas una pequeña caja de herramientas.
Yo recomendaría:
Personalmente trabajo mucho con Visual Studio Code.
Y, para comenzar con Python, usaría una versión moderna compatible con las librerías que quieras explorar. Python 3.11 y 3.12 siguen siendo versiones cómodas para muchos ejercicios y frameworks, aunque obviamente debes revisar siempre los requerimientos actuales de cada proyecto.
7. Aprende solamente el Python que necesites
Aquí tengo una opinión que probablemente molestará a algunos puristas.
No esperaría a “aprender Python completamente” para empezar a crear aplicaciones con IA.
Python es enorme.
No necesitas saberlo todo.
Probablemente yo utilizo conscientemente una fracción relativamente pequeña de todo lo que Python puede hacer.
La IA escribe buena parte del código.
Pero eso no significa que puedas ignorarlo completamente.
Necesitas comprender, al menos:
- variables,
- strings,
- listas,
- diccionarios,
- condicionales,
- ciclos,
- funciones,
- clases de manera básica,
- módulos,
- manejo de errores,
- archivos,
- entornos virtuales,
- instalación de paquetes con pip o herramientas equivalentes.
Eso lo puedes aprender mediante un curso básico de Python.
Puedes hacerlo en:
Pero nuevamente:
aprende construyendo.
8. Reto 1: llama tu primer LLM desde Python
Este es, para mí, el primer gran reto técnico.
Debes lograr que un programa Python envíe una pregunta a un modelo y reciba una respuesta.
Punto.
Nada más.
Algo conceptualmente así:
Usuario ↓ Python ↓ LLM ↓ Respuesta
Puedes utilizar un modelo local mediante:
o utilizar APIs externas como:
Cuando consigas enviar:
“Explícame qué es Business Agility.”
desde Python y recibir una respuesta, habrás dado un paso conceptual enorme.
Porque ya no estás usando ChatGPT.
Estás construyendo software que utiliza Inteligencia Artificial.
9. Reto 2: construye una API con FastAPI
El siguiente paso es aprender cómo convertir ese pequeño programa en un servicio.
Para eso recomiendo:
FastAPI es una excelente forma de construir APIs con Python.
Puedes pedirle a la IA:
Quiero aprender FastAPI.
Ayúdame a construir una API pequeña en Python que reciba una noticia y utilice un LLM para extraer cinco ideas principales.
Quiero utilizar buenas prácticas.
Explícame cada archivo.
Avancemos paso a paso.
No continúes hasta que confirme cada paso.
O puedes construir una API que:
- convierta requerimientos en historias de usuario,
- analice un RFP e identifique riesgos,
- resuma documentos,
- clasifique comentarios de clientes,
- extraiga compromisos de una reunión,
- proponga lugares turísticos entre dos puntos,
- analice retrospectivas ágiles.
El objetivo todavía no es construir algo revolucionario.
El objetivo es comprender la arquitectura:
Frontend ↓ API ↓ Python / FastAPI ↓ LLM
10. Reto 3: aprende embeddings
Después necesitas comprender uno de los conceptos más importantes para muchas aplicaciones modernas de IA:
los embeddings.
Una forma sencilla de entenderlos es pensar que transformamos contenido —por ejemplo textos— en representaciones numéricas que permiten comparar significado.
Eso permite resolver problemas fascinantes.
Ejercicio recomendado
Supongamos que tienes:
- 20 hojas de vida,
- una descripción de un cargo.
Construye una aplicación que utilice embeddings para identificar cuáles hojas de vida son semánticamente más cercanas al perfil buscado.
No uses palabras exactas solamente.
Compara significado.
Cuando entiendas ese ejercicio habrás comprendido una pieza fundamental de:
- búsqueda semántica,
- sistemas de recomendación,
- RAG,
- memoria semántica,
- recuperación de información.
11. Reto 4: aprende RAG
Después de embeddings, el siguiente concepto que considero fundamental es:
RAG — Retrieval-Augmented Generation.
La idea general es muy poderosa.
En lugar de preguntarle directamente al modelo:
“¿Cuál es la política de vacaciones de mi empresa?”
primero buscas la información relevante en tus documentos.
Después esa información se entrega al modelo como contexto.
Conceptualmente:
Pregunta ↓ Búsqueda ↓ Documentos relevantes ↓ LLM ↓ Respuesta fundamentada
Ese patrón aparece constantemente en aplicaciones empresariales.
Construye algo pequeño
Toma cinco documentos PDF.
Construye una aplicación que permita preguntar sobre ellos.
Pero no te conformes con obtener una respuesta.
Pregúntate:
- ¿recuperé los fragmentos correctos?
- ¿cuántos fragmentos recuperé?
- ¿la respuesta realmente está soportada por los documentos?
- ¿qué pasa cuando la respuesta no está en los documentos?
- ¿cómo podría medir la calidad del sistema?
Ahí comienzas a entrar realmente en ingeniería de sistemas de IA.
12. Reto 5: aprende a utilizar Tools
Hasta ahora el modelo básicamente piensa y responde.
Pero un sistema mucho más interesante aparece cuando el modelo puede hacer cosas.
Por ejemplo:
- consultar una base de datos,
- llamar una API,
- buscar información,
- crear un archivo,
- consultar un calendario,
- enviar un correo,
- ejecutar una función Python.
Esas capacidades suelen implementarse mediante tools o funciones que el modelo puede decidir utilizar.
Ese es uno de los saltos conceptuales más importantes.
Pasas de:
IA que responde.
a:
IA que puede actuar sobre un sistema.
13. Reto 6: aprende MCP
Después recomiendo estudiar:
MCP — Model Context Protocol.
MCP busca estandarizar la forma en que aplicaciones basadas en modelos pueden conectarse con herramientas, datos y servicios externos.
Si vas a trabajar seriamente con agentes, vale la pena comprenderlo.
Documentación:
https://modelcontextprotocol.io/
Tu ejercicio puede ser muy sencillo:
Construye o utiliza un servidor MCP con una herramienta sencilla y haz que un cliente o agente pueda descubrirla y ejecutarla.
No importa que el ejemplo sea trivial.
Lo que importa es comprender el protocolo.
14. Ahora sí: comprende qué es un agente
Después de recorrer lo anterior, finalmente la palabra agente comienza a tener mucho más sentido.
Una explicación simplificada podría ser:
┌─────────────┐
│ LLM │
│ Cerebro │
└──────┬──────┘
│
┌─────────┼─────────┐
↓ ↓ ↓
Memoria Tools Contexto
│ │
└────┬────┘
↓
Acción
Yo lo explicaría inicialmente así:
Un agente combina un modelo, instrucciones, contexto, memoria y herramientas para perseguir un objetivo mediante una secuencia de decisiones y acciones.
No es solamente un chatbot.
Puede observar.
Puede decidir.
Puede utilizar herramientas.
Puede revisar resultados.
Puede volver a intentarlo.
Puede mantener estado.
Y ahí empieza la parte realmente interesante.
15. Aprende LangChain y especialmente LangGraph
Cuando llegues a este punto, tiene mucho más sentido estudiar frameworks como:
Mi recomendación es no comenzar aprendiendo el framework de memoria.
Primero entiende:
- LLM,
- prompts,
- embeddings,
- RAG,
- tools,
- estado,
- agentes.
Después LangGraph tiene mucho más sentido.
Porque entiendes qué problema está resolviendo.
Y no solamente cómo copiar código de un tutorial.
16. Reto 7: crea tu primer agente
Construye algo realmente pequeño.
Por ejemplo:
Agente analista de RFP.
El agente recibe un RFP y puede:
- leer el documento,
- identificar requisitos,
- buscar información adicional utilizando una herramienta,
- detectar riesgos,
- generar preguntas para el cliente,
- crear un resumen ejecutivo.
Eso ya te obliga a combinar muchas de las piezas anteriores.
17. Reto 8: crea una red de agentes
Después puedes dar el siguiente salto:
sistemas multiagente.
En lugar de tener un agente intentando hacerlo todo, puedes experimentar con agentes especializados.
Por ejemplo:
Orquestador
│
┌────────────┼────────────┐
↓ ↓ ↓
Investigador Analista Revisor
│ │ │
└────────────┼────────────┘
↓
Resultado
Para experimentar con esto puedes utilizar:
n8n resulta especialmente interesante cuando quieres combinar agentes con automatización visual, APIs y servicios empresariales.
LangGraph es particularmente interesante cuando necesitas controlar mediante código el estado, las transiciones y la orquestación de sistemas agénticos.
18. Después vienen los Skills
El ecosistema está evolucionando tan rápidamente que continuamente aparecen nuevos patrones.
Uno de ellos es encapsular conocimiento, instrucciones y capacidades reutilizables en skills que los agentes pueden utilizar dependiendo de la tarea.
No comenzaría por ahí.
Pero cuando ya comprendas agentes, tools, MCP y orquestación, empieza a explorar:
- skills,
- subagentes especializados,
- memoria,
- guardrails,
- observabilidad,
- evaluaciones,
- tracing,
- sistemas multiagente.
19. Algo que no puedes olvidar: seguridad
Cuando comiences a programar con APIs, nunca pongas tus API keys directamente en el código que subes a GitHub.
Aprende desde el comienzo a utilizar:
- variables de entorno,
- archivos
.env, .gitignore,- gestores de secretos cuando llegues a producción.
Y mientras estés aprendiendo evita utilizar datos personales, historias clínicas, credenciales reales o información sensible.
Utiliza datos sintéticos.
20. La ruta completa
Si tuviera que resumir toda la jornada, sería aproximadamente esta:
1. Comprender qué es un LLM
↓
2. Prompt Engineering
↓
3. Vibe Coding
↓
4. Spec-Driven Development
↓
5. Python básico
↓
6. Consumir un LLM desde Python
↓
7. FastAPI
↓
8. Embeddings
↓
9. RAG
↓
10. Tools
↓
11. MCP
↓
12. Agentes
↓
13. LangGraph / n8n
↓
14. Sistemas multiagente
↓
15. Skills, evaluaciones y observabilidad
21. Una propuesta de ocho semanas
No necesitas dedicar un año a esto antes de construir algo interesante.
Una persona disciplinada puede recorrer esta ruta inicial en aproximadamente uno o dos meses.
Semana 1
LLM + Prompt Engineering.
Semana 2
Vibe Coding. Construye dos aplicaciones pequeñas.
Semana 3
Spec-Driven Development con Spec Kit u OpenSpec.
Semana 4
Python + llamadas a APIs + FastAPI.
Semana 5
Embeddings + búsqueda semántica.
Semana 6
RAG.
Semana 7
Tools + MCP + primer agente.
Semana 8
LangGraph o n8n + pequeño sistema multiagente.
Si tienes tiempo y disciplina, probablemente puedas hacerlo incluso más rápido.
Pero no conviertas esto en una carrera.
El objetivo no es terminar ocho semanas.
El objetivo es que al terminar puedas decir:
“Entiendo las piezas y soy capaz de construir con ellas.”
22. El secreto: proyectos pequeños
Creo que uno de los errores más comunes cuando comenzamos en este mundo es intentar construir inmediatamente:
“Una plataforma inteligente multiagente con RAG, memoria, visión artificial, blockchain, Kubernetes y probablemente café automático.”
No.
Haz cosas ridículamente pequeñas.
Un script.
Una API.
Una pantalla.
Un embedding.
Un documento.
Una tool.
Un agente.
Después combínalos.
La complejidad debe aparecer como consecuencia del aprendizaje, no como requisito para comenzar.
23. Utiliza la IA como profesor
Esta quizás sea mi recomendación más importante.
No preguntes solamente:
“¿Cómo funciona RAG?”
Pregunta:
Quiero aprender RAG construyendo una aplicación pequeña.
Tengo conocimientos básicos de Python.
Actúa como profesor de ingeniería de software e Inteligencia Artificial.
Construiremos una aplicación que permita hacer preguntas sobre cinco documentos PDF.
Quiero entender cada decisión.
Explícame solamente lo necesario para realizar el siguiente paso.
Hazme preguntas para comprobar que comprendí.
No continúes hasta que yo confirme.
Ese prompt cambia completamente la experiencia.
24. No necesitas saberlo todo
Este mundo se está moviendo demasiado rápido.
No existe una persona que conozca todas las librerías, todos los modelos, todos los frameworks y todas las técnicas.
Y probablemente esa no sea siquiera una meta razonable.
La habilidad importante es otra:
aprender rápidamente cosas nuevas, comprender los principios y saber utilizar la IA para acelerar ese aprendizaje.
Hoy utilizamos unas herramientas.
Dentro de seis meses utilizaremos otras.
Dentro de tres años probablemente buena parte del desarrollo de software se parecerá muy poco al desarrollo de software que conocíamos hace una década.
Por eso intenta aprender los conceptos que sobreviven a las herramientas:
- cómo describir un problema,
- cómo especificar comportamiento,
- cómo dividir problemas grandes,
- cómo diseñar sistemas,
- cómo probarlos,
- cómo evaluar resultados probabilísticos,
- cómo reducir incertidumbre,
- cómo construir sistemas confiables.
Conclusión
Si hoy alguien me preguntara:
“Jorge, ¿cómo comienzo en Inteligencia Artificial?”
mi respuesta no sería:
“Haz seis cursos.”
Sería:
Construye ocho cosas.
Construye una conversación con un LLM.
Construye una aplicación mediante vibe coding.
Construye una pequeña aplicación mediante SDD.
Construye una API.
Construye una búsqueda con embeddings.
Construye un RAG.
Construye un agente.
Construye una pequeña red de agentes.
Y utiliza la Inteligencia Artificial como compañero y como profesor durante todo el proceso.
Probablemente en uno o dos meses sabrás muchísimo más de lo que imaginas hoy.
Y, sobre todo, habrás adquirido algo mucho más importante que conocer una herramienta específica:
habrás aprendido a aprender en la era de la Inteligencia Artificial.
Eso, en mi opinión, es la verdadera superpotencia.
Recursos mencionados
- GitHub Spec Kit: https://github.com/github/spec-kit
- OpenSpec: https://github.com/Fission-AI/OpenSpec
- Visual Studio Code: https://code.visualstudio.com/
- Python: https://www.python.org/
- FastAPI: https://fastapi.tiangolo.com/
- Ollama: https://ollama.com/
- Groq: https://console.groq.com/
- Google AI Studio: https://ai.google.dev/aistudio
- Lovable: https://lovable.dev/
- v0: https://v0.dev/
- LangChain: https://python.langchain.com/
- LangGraph: https://langchain-ai.github.io/langgraph/
- n8n: https://n8n.io/
- Model Context Protocol: https://modelcontextprotocol.io/
- Udemy: https://www.udemy.com/
- YouTube: https://www.youtube.com/
Publicado originalmente el 1 de octubre de 2026. Este ecosistema cambia extremadamente rápido; algunas herramientas, modelos o interfaces probablemente habrán cambiado cuando leas este artículo o mientras lo lees😮. Los principios, sin embargo, deberían sobrevivir bastante más tiempo.
