logongas

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== Cómo se programa con IA ======

===== 1. Se programa en OpenCode, no en un IDE =====

El agente vive en la terminal y trabaja sobre la carpeta del proyecto. Tú le pides, él edita y lanza órdenes. Es de código abierto y habla con cualquier proveedor.

[[cursos:sdd:03-opencode|OpenCode]]: instalarlo y conectar proveedores.

===== 2. OpenCode se mete dentro de Orca o herdr =====

Son el «IDE» de hoy: ejecutan tus agentes, cada uno en su //worktree//, y avisan de cuál te necesita. Usa **Orca**, que además deja revisar y comentar el //diff//. **herdr** si quieres quedarte en la terminal.

[[cursos:sdd:03-herdr#orcahacia_un_ide_de_agentes|herdr y Orca comparados]]: qué tiene cada uno.

===== 3. Precios: API o suscripción =====

  * **API**: se paga por //token//. Para probar o para un uso puntual.
  * **Suscripción**: pago fijo con límite de uso. Para trabajar a diario: sale mucho más barata.

Por API, en dólares por millón de //tokens// de entrada, en OpenRouter con el proveedor oficial (2 de noviembre de 2026):

^ Modelo ^  Entrada ^
| Claude Haiku 5.5 (hasta 100.000 //tokens// de entrada) |  0,10 |
| DeepSeek V4.1 Flash |  0,15 |
| Claude Haiku 5.5 (a partir de 100.000) |  0,50 |
| GLM 5.3 |  1,40 |
| Kimi K3.1 Pro |  2 |
| Claude Sonnet 5.5 |  2 |
| Claude Opus 5.5 |  4 |
| Claude Fable 5.1 |  10 |

Por suscripción, en dólares al mes:

^ Plan ^  Precio ^ Modelos ^
| OpenCode Go |  10 y 40 | Modelos abiertos: Kimi, DeepSeek, GLM... |
| GLM Coding Plan |  18, 72 y 160 | GLM |
| Kimi |  19, 39, 99 y 199 | Kimi |
| Claude |  20, 100 y 200 | Haiku, Sonnet, Opus |

{{:cursos:sdd:precios-planes.jpeg?600}}

[[https://openrouter.ai/models|OpenRouter]]: los precios actualizados de cada modelo y proveedor.

===== 4. Skills y MCP =====

  * **Skill**: cómo se hace una tarea en tu equipo. Solo ocupa contexto cuando la tarea encaja.
  * **MCP**: herramientas nuevas: el navegador, la base de datos, la documentación actual. Ocupa contexto siempre, así que conecta solo los que uses.

Empieza por las //skills//: son ficheros de texto.

[[cursos:sdd:02-conceptos-basicos#que_usar_para_cada_problema|Qué usar para cada problema]]: el problema que tienes y la pieza que lo resuelve.

===== 5. El contexto =====

Es todo lo que ve el modelo, y se le manda entero en cada turno. Cuanto más lleno, peor trabaja y más cuesta.

  * **No pases del 40 % de la ventana.**
  * **Una tarea, una sesión**: al cambiar de tarea, ''/clear''.
  * **Lo fijo, corto**: ''AGENTS.md'' se carga siempre.

[[cursos:sdd:02-conceptos-basicos#el_contexto|El contexto]]: qué entra y cómo se llena.

===== 6. Agentes =====

Un subagente hace un trozo del trabajo en **su propia ventana de contexto** y devuelve un resumen. Sirve para lo que leería demasiado o para revisar sin fiarse de quien implementó.

La //skill// dice cómo se hace; el agente, quién lo hace y cuándo para. Casi todo son //skills//: en un proyecto real, 28.211 líneas de //skills// y 134 de agentes.

[[cursos:sdd:07-agentes|Agentes]]: cómo se escribe uno.

===== 7. ¿Hace falta conocer el framework o el lenguaje? =====

La IA los conoce mejor que tú: la sintaxis y la API las pone ella. El problema es que **hay que revisar el código**, y no puedes revisar lo que no entiendes. Hay que conocerlos lo suficiente para leerlos y juzgarlos, no para escribirlos de memoria.

[[cursos:sdd:09-mcp#context7|Context7]]: la documentación actual de cada librería, dentro del agente.

===== 8. SDD: especificar antes de programar =====

«Hay que poder exportar los pedidos» esconde cinco decisiones, y el agente las toma solo y sin avisar. SDD las saca a documentos antes del código, y esos documentos son la entrada del agente. **Entre fase y fase, una persona aprueba.**

^ Documento ^ Qué contesta ^
| ''requirements.md'' | El QUÉ: qué tiene que pasar y cómo se comprueba |
| ''design.md'' | El CÓMO: arquitectura, modelo de datos, decisiones |
| ''tasks.md'' | El plan: pasos pequeños y verificables |

[[cursos:sdd:10-spec-driven-development|Spec-driven development]]: el flujo completo.

==== ¿Realmente funciona? ====

No como dogma. La prueba de Scott Logic: Spec Kit frente a su forma habitual, con incrementos pequeños y prompts sencillos:

^ ^ Agente ^ Revisión humana ^ Markdown ^ Código ^
| Con Spec Kit | 33 min | 3,5 h | 2.577 líneas | 689 líneas |
| Sin especificación | 8 min | 24 min | 0 | 1.000 líneas |

Especifica lo que no cabe en una frase, y que la especificación sea corta: lo que vale es el diseño, no el volumen de //markdown//.

[[https://blog.scottlogic.com/2025/11/26/putting-spec-kit-through-its-paces-radical-idea-or-reinvented-waterfall.html|Putting Spec Kit through its paces]]: ¿idea radical o cascada reinventada?

===== 9. SDD centrado en la arquitectura =====

Variante de SDD: el documento principal no describe cada funcionalidad, sino la **estructura del sistema**: fronteras, interfaces, responsabilidades y decisiones técnicas. Tú defines la arquitectura y la IA la implementa.

  * ''VISION.md'' y ''ARCHITECTURE.md'' en el repositorio: el contexto de cada tarea.
  * Tareas pequeñas, abarcables en una sola interacción.
  * Cada resultado se valida con tests y contra la arquitectura.

Su punto débil: nadie escribe los criterios de aceptación de cada funcionalidad.

[[cursos:sdd:10-spec-driven-development#sdd_centrado_en_la_arquitectura|SDD centrado en la arquitectura]]: la explicación completa.

==== Tú haces la arquitectura, la IA escribe el código ====

La IA es una máquina de implementar: funciona cuando ya has tomado las decisiones difíciles. Multiplica lo que sabes, no lo sustituye.

[[https://meshintelligence.substack.com/p/the-architecture-first-approach|The Architecture-First Approach]]: visión, arquitectura, tareas pequeñas y una implementación cada vez.

==== El diseño detallado, antes que el código ====

Si le dejas, decide él el alcance, los componentes y las interfaces. Se acuerda de lo abstracto a lo concreto: capacidades, componentes, interacciones y contratos. Hasta entonces, ni una línea de código.

[[https://www.martinfowler.com/articles/reduce-friction-ai/design-first-collaboration.html|Design-First Collaboration]]: los cinco niveles de diseño.

==== El prompt se puede ignorar, la arquitectura no ====

Tú escribes el esqueleto (clases base, contratos, seguridad, gestión de errores) y la IA rellena los huecos. No puede saltarse lo que no controla.

[[https://www.infoq.com/articles/skeleton-architecture|Skeleton Architecture]]: el esqueleto lo pones tú, el tejido la IA.

==== Una tarea pequeña cada vez ====

Se pide un trozo, se prueba y se sigue. Si sale mal, no le pidas que lo deshaga: vuelve al último punto bueno y empieza una sesión nueva con más límites.

[[https://replit.discourse.group/t/pair-programming-with-replits-ais/33|Pair programming con la IA]]: el ciclo de planificar, implementar, probar y volver atrás.

===== 10. Patrones agénticos =====

Le pides algo a la IA y lo hace mal. Le dices que lo revise y encuentra el error. ¿WTF? La IA es así y hay que vivir con ello. Programar con IA es saber trabajar con ella para que funcione bien, y para eso hay una serie de patrones:

^ Patrón ^ En qué consiste ^
| Planificador-Ejecutor | Uno hace el plan y se revisa antes de tocar nada |
| Ejecutor-Revisor | Uno hace el trabajo y otro lo revisa con criterios claros |
| Adversarios | Uno intenta romper lo que ha hecho el otro |
| Razonador-Refutador | Uno propone la causa de un fallo y otro intenta desmontarla |
| Best-of-N | Varios intentos, y se queda el mejor |

Empieza por lo más simple: cada patrón añade coste y tiempo.

[[cursos:sdd:05-patrones-agenticos|Patrones agénticos]]: todos, con su ejemplo.

===== 11. Guardarraíles deterministas =====

Como no se acaba de confiar en la IA, se añade software determinista: da siempre el mismo resultado. El agente lo lanza en su bucle y corrige hasta que pasa:

  * **JUnit**: que hace lo que tiene que hacer.
  * **ArchUnit**: que respeta la arquitectura.
  * **Métricas**: cobertura, complejidad ciclomática, CRAP.

[[cursos:sdd:15-herramientas-deterministas|Herramientas deterministas]]: SonarQube, Snyk y cómo meterlas en el bucle.