Capítulo 8

Ingeniería de Prompts para LLM y Coding

8.0 Objetivo del capítulo

Al finalizar este capítulo serás capaz de:

• Comprender el papel de los LLM modernos en el desarrollo de software.
• Diseñar prompts específicos para programación, arquitectura y mantenimiento. [web:164][web:169]
• Elegir la herramienta adecuada según el tipo de tarea (investigación, diseño, implementación, automatización). [web:161][web:162]
• Combinar varias IA dentro de un mismo flujo de trabajo profesional.
• Analizar repositorios completos y generar documentación con asistentes como Claude Code y Cursor. [web:160][web:169]
• Diseñar arquitecturas, depurar código, refactorizar proyectos y documentar software usando distintos LLM.
• Incorporar metodologías reutilizables al PromptBook Profesional, dentro de la sección Coding/.

No vamos a hacer una comparativa superficial de herramientas, sino a construir una metodología que te ayude a seleccionar y combinar asistentes de IA según el problema. Las recomendaciones se basan en documentación y análisis recientes de Anthropic, Cursor, Perplexity, OpenAI y Microsoft. [web:160][web:164][web:161][web:162]

Nota
Piensa en tus asistentes de IA como miembros de un equipo de desarrollo: cada uno tiene fortalezas, responsabilidades y límites. Tu trabajo como desarrollador es coordinarlos.

---

8.1 La IA como compañero de desarrollo

Más que un editor de código

En un entorno moderno, un desarrollador ya no trabaja únicamente con un editor de código tradicional. Plataformas como Cursor, Claude Code y GitHub Copilot han convertido el IDE en un entorno “AI-first”, donde la escritura de código, la navegación por repositorios y la refactorización se apoyan en modelos de lenguaje que entienden el contexto del proyecto. [web:161][web:164][web:171]

Cursor 2.0 y posteriores, por ejemplo, integran un modelo propietario (Composer) optimizado para trabajar sobre grandes bases de código, ejecutar múltiples agentes en paralelo y manejar tareas complejas como refactorizaciones masivas o generación de pruebas. [web:161][web:162][web:165] Claude Code, por su parte, ofrece un entorno donde el modelo puede leer repositorios completos, ejecutar herramientas y usar MCP para conectarse a servicios como GitHub, bases de datos o sistemas de archivos. [web:160][web:166][web:173]

graph TD
  DEV[Desarrollador] --> IDE[IDE con IA]
  IDE --> LLM[Modelos de lenguaje]
  LLM --> TAREAS[Arquitectura, Codigo, Refactor, Docs]
  TAREAS --> DEV

En este diagrama, el IDE con IA actúa como puente entre el desarrollador y los modelos. La IA no sustituye tu rol, pero sí expande tu capacidad para explorar código, probar ideas y mantener proyectos complejos. [web:161][web:164]

[Ilustración: Un escritorio de desarrollo con varias ventanas abiertas: editor de código, consola, panel de IA con chat sobre el repositorio, documentación técnica. El desarrollador revisa cambios propuestos por la IA antes de aceptarlos.]

El papel del LLM como asistente profesional

Los LLM se convierten en:

• Exploradores de código: buscan funciones, patrones, dependencias y problemas potenciales en repositorios grandes. [web:164][web:169]
• Generadores y revisores: escriben nuevas funciones, corrigen errores, sugieren refactorizaciones y revisan PRs. [web:161][web:170]
• Diseñadores de arquitectura: ayudan a proponer estructuras de módulos, servicios y flujos de datos, especialmente cuando se combinan con contexto del proyecto. [web:172]
• Documentadores: crean y mantienen documentación técnica, wikis y guías basadas en el código y los comentarios existentes. [web:169]

Curiosidad
Algunas organizaciones ya tratan a los agentes de IA como “miembros virtuales del equipo”, con tareas asignadas en sistemas de tickets y flujos de revisión similares a los de desarrolladores humanos. [web:161][web:154]

Conclusión de la sección: la IA se ha convertido en un compañero de desarrollo que opera dentro del IDE, los repositorios y la documentación. Comprender su rol te permite diseñar mejores prompts y flujos de trabajo, en lugar de limitarte a pedir “codigo” de forma aislada. [web:161][web:164]

---

8.2 Claude

Claude (especialmente a través de Claude Code) está orientado a trabajar con repositorios completos, herramientas externas y flujos de agente. Anthropic documenta patrones avanzados para análisis de código, subagentes y uso de MCP para escalar a sistemas reales. [web:160][web:166][web:172]

Fortalezas

• Manejo de grandes contextos y repositorios extensos, con capacidad para leer múltiples archivos y sintetizar información. [web:169]
• Integración con herramientas mediante MCP (Model Context Protocol), permitiendo que Claude interactúe con GitHub, bases de datos, sistemas de archivos y otros servicios como si fueran “extensiones”. [web:166][web:173]
• Patrones avanzados de agentes y subagentes para dividir tareas de desarrollo en pasos coordinados (por ejemplo, diseño de arquitectura, implementación y documentación). [web:172][web:173]

Proyectos grandes y análisis de repositorios

DataCamp muestra ejemplos de usar Claude Code para construir agentes que leen repositorios completos y generan wikis automáticos en GitHub. [web:169] Con los agentes y herramientas apropiadas, Claude puede:

• Mapear la estructura de un proyecto.
• Identificar módulos clave y dependencias.
• Generar documentación multiarchivo (por ejemplo, docs/ o una wiki).

Ejemplo de prompt para análisis de arquitectura:

Actua como arquitecto de software.

Objetivo:
Analizar la arquitectura de este repositorio y producir un resumen de alto nivel.

Contexto:
El proyecto es una aplicacion web Full Stack con frontend en React, backend en Node.js y base de datos en PostgreSQL.

Formato:
Incluye:
- diagrama textual de capas (frontend, API, base de datos);
- descripcion de los modulos principales;
- puntos de extension recomendados;
- posibles riesgos arquitectonicos.

Evaluacion:
El resumen debe ayudar a un nuevo desarrollador a entender el proyecto en menos de 10 minutos.

Refactorización y documentación

Claude Code y los patrones de Anthropic se centran en refactorizaciones guiadas y generación de documentación detallada. [web:172][web:169]

Ejemplo de prompt para refactor:

Actua como desarrollador senior.

Objetivo:
Refactorizar este modulo para mejorar legibilidad y separacion de responsabilidades.

Contexto:
El modulo actualmente mezcla logica de negocio y acceso a datos.

Formato:
Propon:
1. una nueva estructura de archivos;
2. un ejemplo de como dividir funciones;
3. comentarios sobre implicaciones en pruebas.

Evaluacion:
La propuesta debe mantener la funcionalidad original y facilitar pruebas unitarias.

| Uso con Claude Code       | Fortalezas                                   |
|---------------------------|----------------------------------------------|
| Analisis de repositorios  | Vision global de proyectos grandes           |
| Arquitectura              | Sintesis de capas y dependencias             |
| Refactorizacion           | Propuestas estructuradas y comentadas        |
| Documentacion             | Wikis y docs basadas en codigo existente     |

[Ilustración: Una vista conceptual de un repositorio con ramas y archivos, y al lado un panel donde Claude genera un mapa de arquitectura y documentación.]

Buenas prácticas
Usa Claude para tareas que requieran entendimiento global del proyecto: arquitectura, documentación y refactorización amplia. Documenta en tu PromptBook qué tipo de prompts te funcionan mejor para cada caso. [web:172][web:169]

Conclusión de la sección: Claude es especialmente fuerte en tareas de análisis profundo, arquitectura y documentación de repositorios amplios. Diseñar prompts claros para esos objetivos convierte al modelo en un socio estratégico para tu base de código. [web:160][web:172]

---

8.3 Perplexity

Perplexity se posiciona como un asistente de investigación técnica y preguntas complejas, capaz de combinar LLM con búsqueda en la web, documentación oficial y fuentes actualizadas. [web:151] Para desarrollo de software, su rol ideal es investigador técnico, más que generador directo de código.

Investigación técnica y documentación oficial

Perplexity puede:

• Encontrar documentación oficial de APIs, frameworks y servicios (Firebase, Cloudflare, GitHub, etc.). [web:151]
• Comparar tecnologías (por ejemplo, distintos ORM, frameworks front-end, soluciones de autenticación) con fuentes y enlaces. [web:151]
• Buscar patrones arquitectónicos recientes, ejemplos de RAG y casos de uso con IA. [web:147][web:154]

Ejemplo de prompt para investigación:

Objetivo:
Investigar opciones actuales para autenticacion en aplicaciones web Full Stack con React y Node.js.

Contexto:
El proyecto usa Firebase para datos y Cloudflare para despliegue.

Formato:
Presenta:
- lista de opciones (Firebase Auth, Auth0, soluciones de Cloudflare, etc.);
- ventajas y desventajas de cada enfoque;
- enlaces a documentacion oficial y guias tecnicas.

Evaluacion:
La respuesta debe incluir al menos 3 fuentes oficiales y resaltar consideraciones de seguridad.

Comparativas y validación de información

Perplexity es útil para validar afirmaciones sobre tecnologías, versiones, límites de servicios y recomendaciones de buenas prácticas, siempre contrastando fuentes. [web:151][web:139]

| Uso con Perplexity      | Fortalezas                                   |
|-------------------------|----------------------------------------------|
| Investigacion tecnica   | Acceso a docs oficiales y articulos          |
| Comparativas            | Analisis de opciones y trade-offs            |
| Deep Research           | Sintesis de multiples fuentes                |
| Validacion de info      | Enlaces y fuentes para fact checking         |

[Ilustración: Una ventana de navegador con resultados de Perplexity mostrando documentación de varias tecnologías, resaltando enlaces oficiales y resúmenes comparativos.]

Consejo
Usa Perplexity antes de tomar decisiones arquitectonicas o de seleccionar tecnologias. Documenta en Perplexity/Investigacion.md los prompts que mejor te ayudan a aclarar el panorama tecnológico de un proyecto.

Conclusión de la sección: Perplexity es tu asistente de investigación técnica y validación. No compite directamente con un IDE, sino que complementa tu trabajo ofreciendo contexto, comparativas y enlaces que luego alimentarás en tus prompts de coding. [web:151][web:147]

---

8.4 Cursor

Cursor es un IDE que integra múltiples modelos (incluyendo Composer, Claude, GPT y otros) y organiza la experiencia de programación alrededor de agentes en lugar de simples autocompletados. [web:161][web:162][web:164]

Integración con el editor y contexto del proyecto

Composer funciona dentro del editor y tiene acceso semántico al código, permitiendo:

• Buscar funciones y clases relevantes.
• Proponer cambios en múltiples archivos con vista de diffs combinados. [web:171][web:170]
• Ejecutar comandos, pruebas y scripts dentro de un entorno controlado.

Los agentes de Cursor pueden operar sobre copias aisladas del código (work trees, máquinas remotas) y ejecutar tareas en paralelo, lo que permite probar múltiples soluciones y elegir la mejor. [web:161][web:165][web:168]

Composer, agentes y desarrollo asistido

Documentación y análisis recientes resaltan:

• Composer como modelo propio optimizado para coding, rápido y capaz de manejar código complejo. [web:161][web:164]
• Agent Mode para flujos orientados a tareas (por ejemplo, “agregar soporte para X”, “refactorizar Y”). [web:164]
• Integración con MCP para conectar agentes con herramientas externas (por ejemplo, TestSprite para QA, GitHub, navegadores). [web:168]

Ejemplo de prompt en Cursor (Composer) para una tarea de desarrollo:

Objetivo:
Agregar una API REST para gestionar tareas en una aplicacion Node.js existente.

Contexto:
El proyecto ya tiene configurado Express y una base de datos MongoDB. Necesitamos endpoints CRUD para tareas.

Formato:
Pide a Composer que:
- encuentre los archivos donde se configuran rutas y modelos;
- proponga nuevos endpoints en un archivo de rutas;
- incluya validacion basica y manejo de errores;
- genere pruebas basicas para los endpoints.

Evaluacion:
Revisa los diffs que Composer propone y ajusta cualquier detalle antes de aceptar cambios.

| Uso con Cursor          | Fortalezas                                   |
|-------------------------|----------------------------------------------|
| Desarrollo asistido     | Generacion de codigo en contexto             |
| Refactorizaciones       | Cambios multiarchivo con diff combinado      |
| Agentes                 | Tareas paralelas y flujos complejos          |
| MCP y herramientas      | Integracion con QA, navegadores y servicios  |

[Ilustración: Una captura conceptual de Cursor mostrando un panel de agentes, el código modificado y un panel de diffs donde el desarrollador revisa y acepta cambios.]

Buenas prácticas
Define tareas con claridad (OCRFE) cuando uses agentes en Cursor. Cuanto más claro sea el objetivo y el contexto, mejor trabajará Composer y los agentes sobre tu código. [web:164][web:171]

Conclusión de la sección: Cursor es tu entorno de implementación y mantenimiento. Sus agentes y Composer convierten el IDE en un espacio donde los prompts se traducen directamente en cambios sobre el código, bajo tu supervisión. [web:161][web:164]

---

8.5 Codex

Aunque OpenAI ha evolucionado más allá del producto “Codex” original, el concepto de AI coding assistants integrados en herramientas como GitHub Copilot y Azure OpenAI sigue vigente: modelos especializados en generación y modificación de código, integrados en editores y plataformas. [web:147][web:170]

Automatización y generación de código

Los descendientes conceptuales de Codex se centran en:

• Generar funciones y bloques de código a partir de descripciones en lenguaje natural.
• Completar patrones conocidos (por ejemplo, uso de APIs de Firebase, Cloudflare Workers, GitHub Actions). [web:170]
• Automatizar tareas repetitivas (plantillas de pruebas, scripts de despliegue, configuraciones CI/CD).

Ejemplo de prompt para generación de código (en un entorno tipo Copilot/Codex):

// Objetivo:
// Implementar una funcion en Node.js que lea datos desde Firebase Firestore
// y los exporte a un archivo CSV en Cloud Storage.
// Contexto:
// Ya existe una configuracion de Firebase en este proyecto.
// Formato:
// La funcion debe manejar errores, registrar eventos en consola
// y aceptar parametros para la coleccion y el nombre de archivo.

Modificación de proyectos y revisión

Integrado con GitHub y CI/CD, un asistente estilo Codex puede:

• Proponer cambios en PRs (por ejemplo, mejoras de rendimiento, simplificación de código). [web:170]
• Generar scripts de automatización (tareas de build, despliegue, pruebas). [web:171]

| Uso estilo Codex        | Fortalezas                                   |
|-------------------------|----------------------------------------------|
| Generacion de codigo    | Funciones y patrones conocidos rapidamente   |
| Automatizacion          | Scripts y pipelines CI/CD                    |
| Revision                | Comentarios sobre PRs y sugerencias         |

[Ilustración: Una vista de GitHub donde un asistente de IA sugiere cambios en un pull request, incluyendo comentarios en línea y recomendaciones de refactorización.]

Nota
En tu PromptBook, trata “Codex” como categoría para prompts orientados a generación y automatización de código, independientemente del modelo específico que uses (Copilot, GPT integrado en el editor, etc.).

Conclusión de la sección: el patrón Codex agrupa asistentes orientados a generación puntual y automatización dentro del flujo de desarrollo. Son ideales para tareas concretas, scripts y bloques de código, complementando herramientas más contextuales como Cursor y Claude. [web:147][web:170]

---

8.6 Diseñando prompts para programación (OCRFE)

Para sacar el máximo provecho de estos asistentes, necesitas prompts bien diseñados para programación usando el framework OCRFE: Objetivo, Contexto, Rol, Formato, Evaluación. [web:31]

Arquitectura

Objetivo:
Diseñar la arquitectura de una aplicacion Full Stack con React, Node.js, Firebase y Cloudflare.

Contexto:
La aplicacion gestionara proyectos de estudiantes, con autenticacion y panel de administracion.

Rol:
Actua como arquitecto de software con experiencia en aplicaciones educativas.

Formato:
Describe:
- capas principales (frontend, backend, servicios externos);
- patrones de comunicacion (REST, WebSockets);
- decisiones de almacenamiento;
- diagrama textual de componentes.

Evaluacion:
La propuesta debe considerar seguridad basica, escalabilidad y facilidad de mantenimiento.

Revisión de código y depuración

Objetivo:
Revisar y depurar una funcion que procesa pagos en una aplicacion Node.js.

Contexto:
La funcion integra con una API externa de pagos y esta generando errores intermitentes.

Rol:
Actua como desarrollador senior especializado en integraciones de APIs.

Formato:
Analiza el codigo, identifica posibles puntos de fallo, propone cambios y explica cada recomendacion.

Evaluacion:
La revision debe incluir al menos 3 puntos concretos de mejora y sugerencias de pruebas para validar el comportamiento.

Documentación

Objetivo:
Generar documentacion tecnica para el modulo de autenticacion de la aplicacion.

Contexto:
El modulo incluye registro, login, recuperacion de contraseña y verificacion por correo.

Rol:
Actua como redactor de documentacion tecnica.

Formato:
Crea un archivo Markdown con secciones: vision general, endpoints, flujos de usuario, consideraciones de seguridad.

Evaluacion:
La documentacion debe permitir a un nuevo desarrollador integrar cambios sin romper el flujo de autenticacion.

Refactorización y optimización

Objetivo:
Refactorizar un servicio de envio de correos para mejorar rendimiento y claridad.

Contexto:
Actualmente se usa un proveedor externo (por ejemplo, SendGrid) con logica mezclada en varios archivos.

Rol:
Actua como desarrollador senior.

Formato:
Propon una nueva estructura de servicio, extrae configuraciones y crea un ejemplo de pruebas unitarias.

Evaluacion:
La propuesta debe reducir duplicacion y facilitar cambios de proveedor en el futuro.

Generación de pruebas

Objetivo:
Generar pruebas unitarias para el servicio de tareas de la aplicacion.

Contexto:
El servicio gestiona CRUD de tareas, con validacion de campos y estados.

Rol:
Actua como ingeniero de QA.

Formato:
Crea ejemplos de pruebas con Jest (o framework equivalente), cubriendo casos normales y edge cases.

Evaluacion:
Las pruebas deben cubrir al menos 80% de las rutas principales del servicio.

| Tipo de tarea        | Enfoque OCRFE                                   |
|----------------------|--------------------------------------------------|
| Arquitectura         | Objetivo y contexto claros, diagrama textual     |
| Revision / debug     | Rol tecnico, formato analitico, criterios de mejora |
| Documentacion        | Formato Markdown, secciones definidas            |
| Refactorizacion      | Objetivo de calidad, propuestas y evaluacion     |
| Pruebas              | Rol de QA, casos cubiertos, metricas de cobertura|

[Ilustración: Una tarjeta de diseño de prompt con campos OCRFE rellenos para una tarea de refactorización, mostrando cómo el desarrollador piensa antes de invocar al asistente.]

Buenas prácticas
Usa OCRFE como estándar para todos tus prompts de programación. Esto facilita replicar flujos entre distintas herramientas (Claude, Cursor, Codex) sin perder claridad.

Conclusión de la sección: diseñar prompts profesionales para programación significa especificar objetivos, contexto, rol, formato y criterios de éxito. OCRFE te da un marco reutilizable que funciona con cualquier asistente de IA. [web:31]

---

8.7 Diseñando un flujo profesional con múltiples IA

Ahora vamos a combinar las herramientas en un flujo profesional como el siguiente:

Perplexity → Investigación

Claude → Arquitectura y documentación

Cursor → Implementación y mantenimiento

Codex (o asistente de código) → Automatización puntual

Desarrollador → Validación, integración y decisión final

graph TD
  PXP[Perplexity - Investigacion] --> CLAUDE[Claude - Arquitectura y Docs]
  CLAUDE --> CURSOR[Cursor - Implementacion]
  CURSOR --> CODEX[Codex/Copilot - Automatizacion]
  CODEX --> DEV[Desarrollador - Validacion]
  DEV --> PROD[Proyecto en produccion]

Cuándo utilizar cada herramienta

• Perplexity: al inicio, para aclarar el entorno tecnológico, revisar documentación oficial y comparar opciones (Firebase vs Supabase, Cloudflare Workers vs otras plataformas, etc.). [web:151]
• Claude: una vez decidido el stack, para analizar repositorios, diseñar arquitectura, generar documentación y proponer refactorizaciones estructurales. [web:169][web:172]
• Cursor: durante la implementación y el mantenimiento continuo, aprovechando Composer y agentes para escribir código, realizar cambios y coordinar tareas complejas dentro del IDE. [web:164][web:168]
• Codex/assistant de código: para generación rápida de funciones, scripts y pruebas en puntos concretos del flujo (por ejemplo, crear una Cloudflare Worker, una regla de Firebase o un script de despliegue en GitHub Actions). [web:170][web:171]
• Tú, como desarrollador: en cada paso, revisas, aceptas diffs, decides qué propuestas adoptar y cómo integrar los cambios en el proyecto real.

| Herramienta     | Momento ideal de uso                      |
|-----------------|--------------------------------------------|
| Perplexity      | Antes de diseñar, durante investigacion   |
| Claude          | Arquitectura, analisis, documentacion     |
| Cursor          | Implementacion, refactor, debug           |
| Codex/Copilot   | Generacion puntual y automatizacion       |
| Desarrollador   | Validacion y decisiones finales           |

[Ilustración: Un diagrama de flujo con cajas etiquetadas como Perplexity, Claude, Cursor, Codex y Desarrollador, mostrando una ruta principal pero con caminos alternativos entre ellas.]

Dato relevante
Artículos sobre flujos RAG y agentes señalan que no existe una única combinación válida de herramientas; lo importante es que tu flujo sea explícito, repetible y documentado. [web:147][web:154]

Conclusión de la sección: diseñar un flujo profesional implica decidir qué asistente se usa para qué fase y documentar esa decisión en tu PromptBook. Así conviertes el uso de IA en un proceso arquitectónico, no en una serie de acciones improvisadas. [web:161][web:147]

---

8.8 Construyendo la biblioteca profesional de Coding

Finalmente, vamos a integrar todo en la sección Coding/ de tu PromptBook Profesional. [web:40]

Estructura de la carpeta Coding/

PromptBook/
  Coding/
    Claude/
      Arquitectura.md
      Refactor.md
      Debug.md
      Documentacion.md

    Perplexity/
      Investigacion.md
      Tecnologias.md
      Comparativas.md
      DocumentacionOficial.md

    Cursor/
      Desarrollo.md
      Composer.md
      Agentes.md
      ProyectoCompleto.md

    Codex/
      Automatizacion.md
      Revision.md
      GeneracionCodigo.md

    FlujosTrabajo.md

• En Claude/Arquitectura.md, documenta prompts OCRFE que uses para analizar y diseñar la estructura de proyectos. [web:169][web:172]
• En Claude/Refactor.md, guarda ejemplos de refactorizaciones amplias (por capas, servicios, dominios).
• En Claude/Debug.md, incluye prompts para localizar bugs complejos usando contexto del repositorio.

• En Claude/Documentacion.md, almacena plantillas para generar wikis, README avanzados y guías técnicas.

• En Perplexity/Investigacion.md, guarda prompts para investigar stacks, servicios, límites de APIs y tendencias.

• En Perplexity/Tecnologias.md, documenta comparativas específicas (por ejemplo, distintos proveedores de hosting o bases de datos).
• En Perplexity/Comparativas.md, organiza prompts de análisis multicriterio.

• En Perplexity/DocumentacionOficial.md, almacena instructivos para localizar y leer documentación oficial de cada tecnología.

• En Cursor/Desarrollo.md, guarda prompts y estrategias para tasks frecuentes (agregar features, corregir bugs, modificar rutas).

• En Cursor/Composer.md, documenta cómo defines tareas para Composer con claridad.
• En Cursor/Agentes.md, describe flujos donde usas varios agentes en paralelo para tareas grandes. [web:161][web:165]

• En Cursor/ProyectoCompleto.md, registra experiencias de trabajo con proyectos full stack completos.

• En Codex/Automatizacion.md, almacena prompts para scripts de CI/CD, tareas de build y despliegue.

• En Codex/Revision.md, guarda ejemplos de revisión automatizada de código en PRs.

• En Codex/GeneracionCodigo.md, documenta patrones recurrentes (por ejemplo, handlers de APIs, validadores, clientes de servicios).

• En FlujosTrabajo.md, describe tus flujos profesionales con múltiples IA (como el de Perplexity → Claude → Cursor → Codex → Desarrollador) y cualquier variación que utilices en distintos tipos de proyecto.

graph TD
  PB[PromptBook] --> COD[Coding/]
  COD --> CLD[Claude/]
  COD --> PXP[Perplexity/]
  COD --> CUR[Cursor/]
  COD --> CDX[Codex/]
  COD --> FT[FlujosTrabajo.md]

Este diagrama representa la arquitectura del PromptBook para Coding, donde cada herramienta tiene su espacio de prompts, ejemplos y metodologías, conectados por los flujos de trabajo documentados. [web:40]

[Ilustración: Una vista conceptual de un “PromptBook de desarrollo” con pestañas para Claude, Perplexity, Cursor y Codex, mostrando que el desarrollador tiene una biblioteca organizada de estrategias para cada herramienta.]

Buenas prácticas
Versiona tus prompts igual que versionas tu codigo. Usa comentarios para indicar fecha, contexto y resultados observados. Con el tiempo, tu biblioteca se convertira en un asset tan valioso como tus repositorios.

Conclusión de la sección: la biblioteca profesional de Coding en tu PromptBook es el lugar donde tu experiencia con IA se vuelve tangible y reutilizable. No solo tendrás código, sino también conocimiento explícito sobre cómo trabajas con múltiples asistentes de IA. [web:40]

---

Práctica guiada

Durante este capítulo, te proponemos las siguientes actividades para convertir la teoría en práctica:

1. Diseñar prompts para arquitectura

1. En Claude/Arquitectura.md, diseña al menos dos prompts OCRFE para analizar y proponer arquitecturas de aplicaciones Full Stack (por ejemplo, React + Node + Firebase + Cloudflare).
2. Ejecuta estos prompts en Claude Code y anota en el mismo archivo qué propuestas te resultaron más útiles.

2. Diseñar prompts para debug

1. En Claude/Debug.md y Cursor/Desarrollo.md, crea prompts para analizar errores complejos (por ejemplo, fallos intermitentes en integraciones de APIs o problemas de rendimiento en consultas a bases de datos).
2. Usa agentes de Cursor para ejecutar pruebas y revisar cambios propuestos, documentando la experiencia en Cursor/ProyectoCompleto.md.

3. Diseñar prompts para documentación

1. En Claude/Documentacion.md, diseña una plantilla para generar documentación de módulos clave de tu proyecto (por ejemplo, autenticación, gestión de tareas, APIs externas).
2. Genera documentación con Claude y ajusta los prompts según la calidad de la salida.

4. Diseñar prompts para refactorización

1. En Claude/Refactor.md y Cursor/Desarrollo.md, construye prompts para refactorizar servicios o componentes específicos, indicando objetivos claros de legibilidad, separación de responsabilidades y pruebas.
2. Aplica los cambios en un proyecto de ejemplo y registra resultados.

5. Comparar resultados entre herramientas

1. Elige una tarea concreta (por ejemplo, crear un endpoint nuevo o refactorizar un módulo) y prueba versiones de prompts con Claude, Cursor y tu asistente estilo Codex.
2. En FlujosTrabajo.md, compara resultados, tiempos y calidad, anotando en qué contexto prefieres cada herramienta.

6. Construir un flujo de trabajo profesional

1. Describe en FlujosTrabajo.md al menos dos flujos profesionales distintos: uno para proyectos nuevos y otro para mantenimiento de proyectos existentes.
2. Integra en esos flujos los pasos de investigación con Perplexity, diseño con Claude, implementación con Cursor y automatización con Codex.

Consejo
Trata estos ejercicios como el inicio de tu “manual de desarrollo asistido por IA”. Cada proyecto futuro debería beneficiarse de lo que documentes hoy en tu PromptBook.

---

8.9 Resumen

En este capítulo has aprendido a ver los LLM y asistentes de IA como parte de un ecosistema profesional de desarrollo de software. Comenzamos definiendo el rol de la IA como compañero de desarrollo dentro del IDE y los repositorios, y luego exploramos fortalezas y usos de Claude (arquitectura, refactorización, documentación), Perplexity (investigación técnica y validación), Cursor (implementación y agentes dentro del editor) y Codex/assistentes de código (generación y automatización puntual). [web:160][web:161][web:164][web:169]

Diseñamos prompts para tareas clave (arquitectura, debug, documentación, refactorización, pruebas) usando OCRFE, asegurando que tus instrucciones sean claras, contextuales y evaluables. [web:31][web:164] A continuación, construimos un flujo profesional que combina investigación, diseño, implementación y automatización, resaltando que no existe una combinación única, pero sí flujos que deben ser explícitos y documentados. [web:147][web:161]

Finalmente, integraste todo en la sección Coding/ de tu PromptBook, con subcarpetas para Claude, Perplexity, Cursor y Codex, además de FlujosTrabajo.md para describir tus metodologías. [web:40] Esto convierte tu experiencia con IA en desarrollo de software en una biblioteca reutilizable y versionable, alineada con prácticas modernas de ingeniería.

Nota
En capítulos posteriores, extenderás estas ideas a otros dominios como productividad y generación multimedia, pero la lógica que has aprendido aquí —seleccionar herramientas según tareas, diseñar prompts OCRFE y documentar flujos— seguirá siendo tu base.

Conclusión general del capítulo: la Ingeniería de Prompts para LLM y Coding te permite pasar de “usar IA para escribir código” a diseñar sistemas complejos donde múltiples asistentes colaboran contigo en investigación, arquitectura, implementación y mantenimiento. Tu PromptBook Profesional se convierte en el plano de esa colaboración. [web:161][web:164]

---

Bibliografía

• Anthropic. “Agent SDK overview – Claude Code.” Documentación sobre agentes y patrones avanzados en Claude Code. https://code.claude.com/docs/en/agent-sdk/overview [web:160]
• Anthropic. “Connect Claude Code to tools via MCP.” Guía sobre Model Context Protocol y conexión de Claude a herramientas externas. https://code.claude.com/docs/en/mcp [web:166]
• Anthropic / DataCamp. “Claude Opus 4.5 Tutorial: Build a GitHub Wiki Agent.” Ejemplo de uso de Claude Code para analizar repositorios y generar documentación. https://www.datacamp.com/tutorial/claude-opus-4-5-tutorial [web:169]
• Anthropic. “Claude Code Advanced Patterns: Subagents, MCP, and Scaling to Real Codebases.” Documento sobre patrones avanzados de agentes y escalabilidad. [web:172]
• Cursor. “Composer Overview – learn-cursor.com.” Documentación sobre Composer, Agent Mode y contexto en Cursor. https://learn-cursor.com/en/docs/composer [web:164]
• Cursor. “Cursor 2.0 ships 8‑agent IDE – Composer‑1 delivers 4× faster loops.” Analisis de la arquitectura multiagente de Cursor 2.0. https://ai-primer.com/en/engineer/reports/2025-10-29 [web:161]
• Cursor. “Cursor 3 Deep Dive: Agents + Composer Review 2026.” Articulo sobre evolucion de agentes, MCP y rutas de modelos. https://www.digitalapplied.com/blog/cursor-3-deep-dive-agents-composer-review-2026 [web:162]
• DeployHQ. “Cursor 2026: Composer, Agent Mode, MCP & Background Agent.” Guía de configuracion y uso avanzado de Cursor. https://www.deployhq.com/guides/cursor [web:163]
• YouTube. “Cursor IDE 2.0 Just Changed the game (Composer Model + 8 Agents!).” Video analisis de agentes y Composer en Cursor. https://www.youtube.com/watch?v=VleadRCL_6E [web:165]
• YouTube. “Cursor 2.0 Explained: Composer Model, Multi-Agent Support, Voice Coding.” Video de demostracion sobre Composer y agentes. https://www.youtube.com/watch?v=8fFhuMHDrts [web:168]
• YouTube. “Cursor 2.0 IDE Review: AI Composer, Multi-Agent Coding & Pricing Explained.” Review completo de Cursor 2.0. https://www.youtube.com/watch?v=iwHBQiPSH2M [web:170]
• Manuals.plus. “Cursor 2.0: Introducing Composer AI Agent and Enhanced IDE Features.” Documento resumen de capacidades de Cursor 2.0. https://manuals.plus/video/a22d446e1f214ff0677b1b482b33fbe3e77dd1d28b4d1ff4946b9bd813cae351 [web:171]
• Perplexity / ChatAI Guide. “ChatGPT tutorial for academic research.” Tutorial sobre uso de asistentes de IA en investigacion tecnica y academica. https://chatai.guide/tutorials/chatgpt-tutorial-research/ [web:151]
• Microsoft Learn. “RAG and Generative AI – Azure AI Search.” Documentacion sobre patrones RAG y grounding de LLM. https://learn.microsoft.com/en-us/azure/search/retrieval-augmented-generation-overview [web:147]
• Microsoft DevBlogs. “How we built Ask Learn, the RAG-based knowledge service.” Caso de estudio de sistema RAG empresarial. https://devblogs.microsoft.com/engineering-at-microsoft/how-we-built-ask-learn-the-rag-based-knowledge-service/ [web:154]
• Dair.ai. “Prompt Engineering Guide.” Repositorio con recursos de Ingeniería de Prompts aplicables a coding y otros dominios. https://github.com/dair-ai/Prompt-Engineering-Guide [web:40]
• DigitalCortexAI. “Cursor 2.0 & Composer: The Dawn of Agent-Powered Coding.” Articulo sobre agentes y workflows en Cursor. https://medium.com/@DigitalCortexAI/cursor-2-0-composer-the-dawn-of-agent-powered-coding-51e7a32dbf5c [web:174]
• YouTube. “I Let Claude Manage My GitHub Repo (Honest Setup Guide | MCP).” Video sobre uso de MCP para conectar Claude Code con GitHub. https://www.youtube.com/watch?v=enRbqWlA-_I [web:167]
• YouTube. “Claude Code just Built me an AI Agent Team (Claude Code + Skills + MCP).” Video sobre agentes colaborativos con Claude Code. https://www.youtube.com/watch?v=0J2_YGuNrDo [web:173]