Diferencias

Muestra las diferencias entre dos versiones de la página.

--- cursos:sdd:presentacion [2026/11/02 12:12] – Precisa qué compara la prueba de Scott Logic claude
+++ cursos:sdd:presentacion [2026/11/02 15:04] (actual) – Añade patrones agénticos antes de guardarraíles deterministas claude
@@ Línea 1: / Línea 1: @@
-====== Cómo se programa con IA: 10 ideas ======
+====== Cómo se programa con IA ======
-===== 1. Tú haces la arquitectura, la IA escribe el código =====
+===== 1. Se programa en OpenCode, no en un IDE =====
-La IA es una máquina de implementar: funciona cuando ya has tomado las decisiones difíciles. Multiplica lo que sabes, no lo sustituye.
+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.
-[[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.
+[[cursos:sdd:03-opencode|OpenCode]]: instalarlo y conectar proveedores.
-===== 2. El diseño detallado, antes que el código =====
+===== 2. OpenCode se mete dentro de Orca o herdr =====
-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.
+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.
-[[https://www.martinfowler.com/articles/reduce-friction-ai/design-first-collaboration.html|Design-First Collaboration]]: los cinco niveles de diseño.
+[[cursos:sdd:03-herdr#orcahacia_un_ide_de_agentes|herdr y Orca comparados]]: qué tiene cada uno.
-===== 3. El prompt se puede ignorar, la arquitectura no =====
+===== 3. Precios: API o suscripción =====
-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.
+  * **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.
-[[https://www.infoq.com/articles/skeleton-architecture|Skeleton Architecture]]: el esqueleto lo pones tú, el tejido la IA.
+Por API, en dólares por millón de //tokens// de entrada, en OpenRouter con el proveedor oficial (2 de noviembre de 2026):
-===== 4. Una tarea pequeña cada vez =====
+^ 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 |
-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.
+Por suscripción, en dólares al mes:
-[[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.
+^ 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 |
-===== 5. Guardarraíles deterministas =====
+{{:cursos:sdd:precios-planes.jpeg?600}}
-La IA no da dos veces el mismo resultado, sus comprobaciones sí tienen que darlo. El agente las lanza en su bucle y corrige hasta que pasan:
+[[https://openrouter.ai/models|OpenRouter]]: los precios actualizados de cada modelo y proveedor.
-  * **JUnit**: que hace lo que tiene que hacer.
+===== 4. Skills y MCP =====
-  * **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.
+  * **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.
-===== 6. SDD, ¿realmente funciona? =====
+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:
@@ Línea 47: / Línea 98: @@
 [[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?
-===== 7. ¿Es necesario conocer un framework? =====
+===== 9. SDD centrado en la arquitectura =====
-Sus conceptos sí, porque sin ellos no puedes revisar lo que sale. Su API de memoria no: eso lo pone el agente, con la documentación de la versión que usas.
+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.
-[[cursos:sdd:09-mcp#context7|Context7]]: la documentación actual de cada librería, dentro del agente.
+  * ''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.
-===== 8. Skills y agentes =====
+Su punto débil: nadie escribe los criterios de aceptación de cada funcionalidad.
-  * **Skill**: cómo se hace una tarea en tu equipo. Aquí va el conocimiento.
+[[cursos:sdd:10-spec-driven-development#sdd_centrado_en_la_arquitectura|SDD centrado en la arquitectura]]: la explicación completa.
-  * **Agente**: quién la hace, con qué herramientas y cuándo para.
-Casi todo son //skills//: en un proyecto real, 28.211 líneas de //skills// y 134 de agentes.
+==== Tú haces la arquitectura, la IA escribe el código ====
-[[cursos:sdd:08-skills|Skills]]: cómo se escriben.
+La IA es una máquina de implementar: funciona cuando ya has tomado las decisiones difíciles. Multiplica lo que sabes, no lo sustituye.
-===== 9. OpenCode y los precios =====
+[[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.
-OpenCode es de código abierto, habla con cualquier proveedor y recién instalado ya funciona con modelos gratuitos. Para trabajar en serio, un plan de pago fijo: sale mucho más barato que pagar por //token//.
+==== El diseño detallado, antes que el código ====
-{{:cursos:sdd:precios-planes.jpeg?600}}
+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.
-[[cursos:sdd:03-opencode|OpenCode]]: instalarlo y conectar proveedores.
+[[https://www.martinfowler.com/articles/reduce-friction-ai/design-first-collaboration.html|Design-First Collaboration]]: los cinco niveles de diseño.
-===== 10. Orca o herdr: varios agentes a la vez =====
+==== El prompt se puede ignorar, la arquitectura no ====
-Los dos 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.
+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.
-[[cursos:sdd:03-herdr#orcahacia_un_ide_de_agentes|herdr y Orca comparados]]: qué tiene cada uno.
+[[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.