Convierte Kilo Code en una herramienta gobernada y no en un experimento individual
Aumenta productividad sin renunciar a calidad técnica Kilo puede acelerar análisis, implementación, debugging, testing y documentación, pero solo aporta valor si se integra con Git, tests, pull requests y revisión humana. La formación enseña a aprovechar velocidad sin aceptar cambios opacos ni soluciones superficiales.
1
Mejora la seguridad en el uso
Personaliza el temario al 100% para tu equipo
Diseñamos una formación a medida utilizando los documentos y flujos de trabajo reales de tu empresa.
Nueva Plataforma de E-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje
Acceso a las grabaciones
Los alumnos podrán revisar las sesiones grabadas para repasar conceptos clave, recuperar explicaciones concretas o reforzar aquellos contenidos que necesiten después de la clase en directo.
Recursos formativos
Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.
Confirmación de asistencia
La plataforma permite registrar y confirmar la asistencia de los participantes, facilitando el seguimiento de la formación y la gestión documental necesaria para la bonificación FUNDAE.
Programa formativo
Temario del curso
Encuentra todo el temario del curso aquí.
Temario
Situar Kilo Code dentro del ecosistema de agentes de desarrollo y diferenciarlo de autocompletadores, chats genéricos y asistentes integrados simples.
Comprender qué significa trabajar con un agente capaz de leer, buscar, editar, ejecutar comandos, delegar tareas y conectarse a herramientas externas.
Identificar escenarios donde Kilo Code aporta valor real: análisis de repositorios, implementación guiada, refactorización, debugging, testing y documentación.
Reconocer situaciones donde el uso del agente debe limitarse por riesgo, incertidumbre, datos sensibles, impacto productivo o falta de contexto suficiente.
Diferenciar productividad aparente y mejora real de ingeniería, evitando medir únicamente líneas generadas o velocidad de escritura.
Analizar cómo cambian las responsabilidades del desarrollador cuando delega tareas en un agente IA que puede modificar código y lanzar comandos.
Revisar el equilibrio entre autonomía del agente, revisión humana, permisos, políticas internas y validación mediante tests o CI/CD.
Conectar Kilo Code con prácticas profesionales de Git, pull requests, code review, arquitectura, seguridad, documentación y despliegue.
Establecer una terminología común sobre agentes, subagentes, skills, workflows, MCP, contexto, permisos, modelos y proveedores.
Preparar un mapa de aprendizaje para pasar de uso individual básico a implantación gobernada en equipos de desarrollo.
Situar Kilo Code dentro del ecosistema de agentes de desarrollo y diferenciarlo de autocompletadores, chats genéricos y asistentes integrados simples.
Comprender qué significa trabajar con un agente capaz de leer, buscar, editar, ejecutar comandos, delegar tareas y conectarse a herramientas externas.
Identificar escenarios donde Kilo Code aporta valor real: análisis de repositorios, implementación guiada, refactorización, debugging, testing y documentación.
Reconocer situaciones donde el uso del agente debe limitarse por riesgo, incertidumbre, datos sensibles, impacto productivo o falta de contexto suficiente.
Diferenciar productividad aparente y mejora real de ingeniería, evitando medir únicamente líneas generadas o velocidad de escritura.
Analizar cómo cambian las responsabilidades del desarrollador cuando delega tareas en un agente IA que puede modificar código y lanzar comandos.
Revisar el equilibrio entre autonomía del agente, revisión humana, permisos, políticas internas y validación mediante tests o CI/CD.
Conectar Kilo Code con prácticas profesionales de Git, pull requests, code review, arquitectura, seguridad, documentación y despliegue.
Establecer una terminología común sobre agentes, subagentes, skills, workflows, MCP, contexto, permisos, modelos y proveedores.
Preparar un mapa de aprendizaje para pasar de uso individual básico a implantación gobernada en equipos de desarrollo.
Tema 1: Kilo Code en la ingeniería asistida por IA: alcance, límites y criterios de adopción profesional
Situar Kilo Code dentro del ecosistema de agentes de desarrollo y diferenciarlo de autocompletadores, chats genéricos y asistentes integrados simples.
Comprender qué significa trabajar con un agente capaz de leer, buscar, editar, ejecutar comandos, delegar tareas y conectarse a herramientas externas.
Identificar escenarios donde Kilo Code aporta valor real: análisis de repositorios, implementación guiada, refactorización, debugging, testing y documentación.
Reconocer situaciones donde el uso del agente debe limitarse por riesgo, incertidumbre, datos sensibles, impacto productivo o falta de contexto suficiente.
Diferenciar productividad aparente y mejora real de ingeniería, evitando medir únicamente líneas generadas o velocidad de escritura.
Analizar cómo cambian las responsabilidades del desarrollador cuando delega tareas en un agente IA que puede modificar código y lanzar comandos.
Revisar el equilibrio entre autonomía del agente, revisión humana, permisos, políticas internas y validación mediante tests o CI/CD.
Conectar Kilo Code con prácticas profesionales de Git, pull requests, code review, arquitectura, seguridad, documentación y despliegue.
Establecer una terminología común sobre agentes, subagentes, skills, workflows, MCP, contexto, permisos, modelos y proveedores.
Preparar un mapa de aprendizaje para pasar de uso individual básico a implantación gobernada en equipos de desarrollo.
Tema 2: Instalación y primer arranque en VS Code, JetBrains y CLI
Instalar Kilo Code en VS Code diferenciando la extensión actual basada en runtime compartido y la extensión VSCode Legacy cuando aparezca en entornos existentes.
Preparar el plugin o integración en IDEs JetBrains para equipos que trabajan con IntelliJ IDEA, PyCharm, WebStorm u otros entornos corporativos.
Configurar Kilo CLI para trabajar desde terminal, ejecutar sesiones interactivas, lanzar tareas headless y utilizar comandos operativos.
Revisar diferencias prácticas entre trabajar desde IDE, CLI, sesiones locales, Agent Manager y posibles flujos cloud.
Validar que el runtime embebido, servidor local, permisos del IDE y acceso a red funcionan correctamente en equipos corporativos.
Resolver incidencias de instalación relacionadas con extensiones bloqueadas, proxy, certificados, rutas, permisos de usuario o políticas de IT.
Preparar una instalación limpia para proyectos nuevos y una instalación compatible con repositorios ya existentes.
Documentar pasos de instalación para que el departamento de sistemas pueda replicar el entorno en aulas, equipos o escritorios virtuales.
Establecer criterios para decidir si el alumno trabajará con VS Code, JetBrains, CLI o una combinación de superficies.
Comprobar que Kilo puede abrir el proyecto, leer archivos, acceder al repositorio y ejecutar acciones básicas bajo supervisión.
Tema 3: Configuración inicial, autenticación y estructura de `kilo.jsonc`
Entender el papel de `kilo.jsonc` como configuración portable para proveedores, modelos, permisos, MCP, agentes y opciones del entorno.
Diferenciar configuración global en `~/.config/kilo/kilo.jsonc` y configuración de proyecto en `kilo.jsonc` o `.kilo/kilo.jsonc`.
Configurar Kilo desde la interfaz de Settings y desde archivo, revisando cuándo conviene cada enfoque.
Utilizar el propio agente para modificar configuración con seguridad, revisando siempre qué archivo cambia y qué valores introduce.
Separar preferencias personales, estándares de equipo y restricciones corporativas para evitar configuraciones contradictorias.
Proteger claves API, tokens y credenciales evitando incluir secretos en archivos versionados o configuraciones compartidas.
Usar variables de entorno cuando sea necesario referenciar credenciales sin exponerlas en repositorios o exportaciones de settings.
Exportar e importar configuración para acelerar despliegues internos, revisando antes cualquier dato sensible incluido en el archivo.
Validar el esquema de configuración y resolver errores de JSONC, rutas incorrectas, modelos inexistentes o permisos mal definidos.
Crear una configuración base corporativa preparada para extenderse por proyecto sin perder control central.
Tema 4: Proveedores de IA, modelos, BYOK, Kilo Gateway y modelos locales
Comparar opciones de inferencia: Kilo Gateway, Kilo Pass, BYOK con proveedores externos, Auto Free y modelos locales.
Configurar claves propias de proveedores como Anthropic, OpenAI, Google, Azure, AWS Bedrock u otros autorizados por la organización.
Incorporar modelos locales mediante Ollama o LM Studio cuando el equipo prioriza control, privacidad o pruebas internas.
Definir criterios de selección de modelo según tarea: planificación, edición masiva, análisis de código, debugging, documentación o explicación.
Utilizar Auto Model con criterio, entendiendo cuándo delegar en enrutamiento automático y cuándo fijar un modelo concreto.
Medir coste por tarea, consumo de tokens, repeticiones, contexto cargado y calidad del resultado para evitar gasto invisible.
Diseñar políticas de proveedores permitidos, modelos bloqueados, límites de uso y criterios de aprobación en entornos empresariales.
Evaluar diferencias entre modelos frontier, balanced, free y locales desde la perspectiva de coste, autonomía, precisión y latencia.
Preparar configuraciones por equipo donde arquitectura, desarrollo, QA y documentación pueden necesitar modelos distintos.
Documentar decisiones de modelo para que el uso de Kilo sea explicable, auditable y ajustable con el tiempo.
Tema 5: Agentes incorporados, modos de trabajo y selección según tarea
Comprender el concepto de agente como persona especializada con comportamiento, permisos, herramientas y estilo de respuesta propio.
Utilizar agentes de planificación para analizar requisitos, diseñar cambios, evaluar alternativas y preparar estrategias antes de tocar código.
Aplicar agentes de código para implementar, modificar, refactorizar y ejecutar cambios bajo criterios de revisión y validación.
Recurrir a agentes de depuración cuando existen errores, logs, trazas, fallos de tests o comportamientos difíciles de localizar.
Emplear agentes de consulta para entender código, documentación o decisiones sin permitir modificaciones innecesarias.
Evitar el uso indiscriminado de un único agente para cualquier tarea, especialmente cuando la acción requiere seguridad o solo lectura.
Revisar la transición desde el enfoque Legacy de modos hacia la plataforma actual basada en agentes personalizables.
Establecer reglas internas para seleccionar agente según riesgo, complejidad, impacto, urgencia y tipo de repositorio.
Combinar sesiones de planificación, implementación y revisión sin mezclar instrucciones contradictorias en una misma conversación.
Diseñar una guía rápida de uso para que el equipo sepa cuándo utilizar Ask, Plan, Code, Debug o agentes personalizados.
Tema 6: Permisos granulares, auto-approval y control de acciones peligrosas
Configurar permisos con valores `allow`, `ask` y `deny` para controlar lectura, edición, búsqueda, comandos, subagentes, web y MCP.
Revisar por qué autoaprobar acciones puede acelerar el trabajo pero también provocar pérdida de datos, corrupción de archivos o ejecución peligrosa.
Definir permisos seguros para tareas de exploración donde el agente solo puede leer, buscar y resumir sin modificar el repositorio.
Crear políticas diferenciadas para edición de archivos, comandos `bash`, acceso a directorios externos y uso de herramientas conectadas.
Gestionar aprobaciones en tiempo de ejecución entendiendo cuándo permitir una acción concreta y cuándo convertirla en regla permanente.
Utilizar patrones de permisos para permitir comandos habituales de test o linting mientras se bloquean operaciones destructivas.
Diseñar configuraciones por perfil: desarrollador individual, reviewer, QA, DevOps, documentación, seguridad y onboarding.
Controlar el permiso `doom_loop` para evitar que el agente continúe insistiendo tras fallos repetidos sin supervisión humana.
Revisar permisos MCP con nombres de herramienta y comodines, evitando autorizar servidores completos sin entender cada capacidad.
Construir una matriz de permisos corporativa que equilibre productividad, seguridad, trazabilidad y responsabilidad profesional.
Tema 7: Contexto de proyecto con `AGENTS.md`, instrucciones globales y reglas por directorio
Crear un `AGENTS.md` en la raíz del repositorio para definir arquitectura, estilo, testing, seguridad, naming y restricciones de proyecto.
Diferenciar instrucciones globales, instrucciones de proyecto, prompts por agente y reglas por directorio según prioridad y alcance.
Utilizar `AGENTS.md` por subdirectorio en monorepos, backends, frontends, librerías, infraestructura o documentación con normas específicas.
Evitar instrucciones vagas como “escribe buen código” sustituyéndolas por reglas concretas, verificables y adaptadas al equipo.
Incorporar estándares de arquitectura, patrones permitidos, librerías aprobadas, criterios de seguridad y comandos de validación.
Proteger `AGENTS.md` frente a modificaciones accidentales, tratándolo como configuración crítica de comportamiento del agente.
Migrar contenido antiguo de Memory Bank hacia `AGENTS.md` cuando el equipo utiliza reglas heredadas o configuraciones previas.
Diseñar ejemplos internos de instrucciones para proyectos .NET, Java, Node.js, Python, frontend, microservicios o infraestructura.
Revisar conflictos entre instrucciones de alto nivel y reglas locales que pueden producir respuestas inconsistentes del agente.
Mantener `AGENTS.md` vivo, versionado y revisado como parte de la evolución técnica del repositorio.
Tema 8: Gestión avanzada del contexto, indexación y grandes repositorios
Preparar el repositorio para que Kilo entienda arquitectura, dependencias, puntos de entrada y convenciones sin cargar ruido innecesario.
Explicar al agente qué zonas del código debe revisar primero según tarea, evitando exploraciones amplias que consumen contexto sin aportar valor.
Utilizar búsquedas, glob, grep, lectura dirigida y exploración por subagentes para analizar bases de código grandes con eficiencia.
Diseñar instrucciones para monorepos donde cada paquete, servicio o aplicación tiene stack, comandos y normas diferentes.
Crear mapas de arquitectura, README técnicos y documentación auxiliar que faciliten a Kilo construir contexto útil rápidamente.
Evitar que documentación obsoleta, pruebas antiguas o carpetas generadas contaminen el razonamiento del agente.
Usar `.kilocodeignore` o mecanismos equivalentes cuando sea necesario excluir directorios, binarios, secretos, builds o contenido irrelevante.
Gestionar sesiones largas mediante resúmenes, reinicios de contexto y división de tareas para reducir acumulación de errores.
Preparar prompts de orientación inicial que pidan al agente explorar antes de editar en repositorios desconocidos.
Medir cuándo el problema requiere una lectura humana previa, una sesión de arquitectura o un subagente especializado.
Tema 9: Prompting técnico para Kilo Code en tareas profesionales
Formular peticiones con objetivo, contexto, restricciones, archivos relevantes, comandos de validación y criterios de aceptación.
Transformar instrucciones ambiguas en encargos verificables que el agente pueda ejecutar sin inventar requisitos.
Separar fase de análisis, propuesta, implementación y revisión para evitar que Kilo modifique código antes de comprender el impacto.
Pedir al agente que identifique riesgos, archivos afectados, dependencias y pruebas necesarias antes de aplicar cambios.
Diseñar prompts para refactorización segura, corrección de bugs, creación de tests, migraciones, documentación y revisión de pull requests.
Evitar peticiones excesivamente grandes que mezclan arquitectura, implementación, despliegue y documentación en una sola ejecución.
Utilizar restricciones explícitas sobre librerías, estilo, compatibilidad, rendimiento, seguridad y patrones internos.
Pedir diffs pequeños, commits lógicos y cambios reversibles cuando se trabaja en ramas compartidas o código crítico.
Revisar respuestas del agente buscando suposiciones no confirmadas, cambios colaterales y explicaciones que no coinciden con el diff.
Crear una biblioteca interna de prompts reutilizables para tareas frecuentes del equipo.
Tema 10: Agent Manager, sesiones, worktrees y trabajo paralelo controlado
Utilizar Agent Manager para gestionar sesiones locales o worktrees sin perder visibilidad sobre tareas, cambios y contexto.
Comprender cuándo conviene aislar una tarea en un worktree para evitar conflictos con el trabajo principal del desarrollador.
Coordinar varias sesiones de Kilo sobre distintas ramas, incidencias o experimentos manteniendo trazabilidad y control de cambios.
Comparar trabajo local en IDE, ejecución desde CLI y gestión centralizada de sesiones según complejidad del flujo.
Revisar diffs generados por agentes antes de mezclar cambios o convertir experimentos en código incorporable.
Evitar que sesiones paralelas modifiquen los mismos archivos sin estrategia de integración o revisión.
Documentar decisiones de cada sesión para que el resultado no dependa únicamente del historial conversacional.
Gestionar sesiones largas con checkpoints humanos, validaciones intermedias y división de tareas por riesgo.
Preparar normas de equipo para uso de worktrees, limpieza de ramas temporales y conservación de evidencias.
Evaluar cuándo el trabajo paralelo aporta velocidad y cuándo multiplica deuda, conflictos y ruido de revisión.
Tema 11: Uso de Kilo CLI para automatización, scripting y trabajo desde terminal
Ejecutar Kilo desde terminal para analizar proyectos, lanzar tareas, revisar cambios y trabajar sin abrir el IDE.
Utilizar comandos principales como inicio de sesión, `kilo run`, `kilo attach`, gestión de proveedores, agentes, MCP y actualización.
Diseñar tareas headless para análisis, generación de documentación, revisión local o automatización puntual controlada.
Combinar CLI con scripts corporativos, Makefiles, tareas npm, comandos .NET, Maven, Gradle, pytest o pipelines locales.
Controlar diferencias entre ejecución interactiva y ejecución automatizada para evitar acciones sin supervisión suficiente.
Configurar notificaciones, sonidos, comportamiento del TUI y preferencias de terminal según contexto de trabajo.
Preparar comandos de revisión local para analizar cambios antes de abrir un pull request.
Gestionar rutas, entornos virtuales, variables y credenciales cuando Kilo CLI se usa sobre proyectos con dependencias específicas.
Investigar fallos de CLI, runtime, credenciales, MCP o permisos mediante comandos de debug y revisión de logs.
Definir políticas internas sobre qué tareas pueden ejecutarse en CLI y cuáles deben mantenerse dentro del IDE o pipeline.
Tema 12: Workflows como slash commands para tareas repetibles del equipo
Crear workflows como archivos Markdown en `.kilo/commands/` para estandarizar tareas frecuentes de desarrollo.
Diferenciar comandos globales y comandos de proyecto según si representan hábitos personales o procedimientos compartidos del equipo.
Utilizar frontmatter para describir el workflow, fijar agente, seleccionar modelo o ejecutarlo como subtarea cuando proceda.
Diseñar workflows para preparar pull requests, ejecutar checks, generar changelogs, revisar TODOs, crear releases o documentar decisiones.
Evitar workflows demasiado amplios que intentan resolver un proceso completo sin puntos de revisión humana.
Incorporar parámetros, preguntas necesarias y criterios de parada para que el agente no rellene información crítica por su cuenta.
Integrar herramientas internas, scripts, tests, linters, generación documental y comandos Git dentro de workflows revisables.
Versionar workflows dentro del repositorio para que todos los miembros del equipo ejecuten los mismos procedimientos.
Revisar workflows periódicamente cuando cambian arquitectura, comandos, tooling, políticas de ramas o exigencias de calidad.
Construir una biblioteca corporativa de comandos Kilo que reduzca trabajo repetitivo sin generar automatizaciones opacas.
Tema 13: Skills con `SKILL.md` para conocimiento especializado y procedimientos reutilizables
Comprender las Agent Skills como paquetes de conocimiento, instrucciones y recursos que Kilo carga bajo demanda.
Crear skills globales para hábitos personales y skills de proyecto para convenciones propias de un repositorio o dominio.
Diseñar un `SKILL.md` con frontmatter correcto, nombre claro, descripción precisa y reglas de ejecución entendibles.
Incorporar referencias, scripts, plantillas y recursos auxiliares dentro de una skill cuando la tarea requiere material adicional.
Preparar skills para API design, testing, seguridad, documentación, accesibilidad, rendimiento, migraciones o revisión de arquitectura.
Redactar descripciones que permitan al agente decidir cuándo una skill aplica sin depender de palabras clave débiles.
Gestionar prioridad entre skills globales, skills de proyecto, directorios compatibles y rutas adicionales configuradas.
Validar que una skill se carga correctamente preguntando al agente y probando tareas representativas.
Auditar skills compartidas antes de usarlas en entornos corporativos, especialmente si incluyen scripts o referencias externas.
Mantener un catálogo interno de skills que capture conocimiento experto del equipo y acelere la incorporación de nuevos profesionales.
Tema 14: Subagentes personalizados para revisión, seguridad, documentación y arquitectura
Crear subagentes especializados para tareas de revisión de código, análisis de seguridad, documentación, exploración o testing.
Configurar subagentes mediante `kilo.jsonc` o archivos Markdown, definiendo descripción, modo, prompt, modelo y permisos.
Usar subagentes con contexto aislado para evitar que tareas secundarias contaminen la conversación principal.
Invocar subagentes manualmente con menciones o permitir que agentes primarios deleguen mediante la herramienta de tareas.
Diseñar un subagente read-only para explorar código sin riesgo de modificar archivos o ejecutar comandos peligrosos.
Preparar un subagente de revisión que no pueda editar ni lanzar shell, centrado en calidad, seguridad y mantenibilidad.
Crear subagentes de documentación que generen ADRs, changelogs, guías de onboarding y resúmenes técnicos con formato corporativo.
Evaluar cuándo un subagente aporta especialización y cuándo añade complejidad innecesaria al flujo del desarrollador.
Documentar resultados de subagentes para que sus conclusiones puedan revisarse, aceptarse o rechazarse explícitamente.
Construir una arquitectura de agentes internos que refleje roles reales del equipo sin simular autonomía excesiva.
Tema 15: MCP en Kilo Code: conexión con herramientas externas y servidores corporativos
Comprender Model Context Protocol como mecanismo para extender Kilo con herramientas, recursos y servicios externos.
Configurar servidores MCP locales y remotos desde Settings o `kilo.jsonc`, controlando URL, comando, argumentos, timeout y autenticación.
Usar sintaxis de variables de entorno para credenciales cuando un servidor MCP requiere tokens, cabeceras o claves privadas.
Incorporar MCPs de Figma, documentación, GitHub, Sentry, navegadores, APIs internas o herramientas corporativas según caso de uso.
Gestionar permisos MCP con nombres de herramienta y patrones para evitar autorizaciones demasiado amplias.
Diferenciar un MCP de consulta, un MCP de modificación y un MCP capaz de ejecutar acciones sensibles sobre sistemas externos.
Probar servidores MCP en entornos de laboratorio antes de conectarlos a proyectos, repositorios o servicios productivos.
Diagnosticar estados `needs_auth`, servidores fallidos, herramientas no disponibles, timeouts y comandos incompatibles por sistema operativo.
Diseñar MCPs propios para exponer herramientas internas de forma segura y auditable.
Evaluar qué procesos empresariales merece la pena conectar a Kilo y cuáles deben mantenerse fuera del agente por seguridad o complejidad.
Tema 16: Desarrollo de funcionalidades con Kilo Code sobre repositorios reales
Preparar una tarea de desarrollo con requisito funcional, contexto técnico, archivos relevantes y criterios de aceptación antes de pedir código.
Pedir al agente un plan de cambios y revisarlo antes de permitir edición sobre componentes críticos.
Implementar funcionalidades pequeñas y verificables que permitan revisar el diff con claridad.
Coordinar Kilo con tests existentes, linters, compilación y herramientas de análisis para validar cada modificación.
Detectar cuándo el agente genera código correcto sintácticamente pero incoherente con arquitectura, dominio o restricciones del producto.
Dividir funcionalidades complejas en subtareas de modelo, API, interfaz, pruebas, documentación y migraciones.
Gestionar dependencias nuevas evitando que el agente instale paquetes no aprobados o sobredimensione la solución.
Revisar commits, nombres de ramas y pull requests generados con ayuda de Kilo manteniendo criterio profesional.
Pedir explicaciones del cambio vinculadas al diff real y no a una descripción genérica de lo que supuestamente se modificó.
Consolidar un flujo donde Kilo acelera implementación sin sustituir revisión técnica, ownership ni validación funcional.
Tema 17: Refactorización, deuda técnica y modernización guiada por agentes
Analizar código heredado con Kilo para identificar acoplamiento, duplicidad, funciones excesivas, dependencias implícitas y puntos de fragilidad.
Pedir propuestas de refactorización comparando impacto, riesgo, esfuerzo, cobertura de tests y compatibilidad hacia atrás.
Ejecutar refactorizaciones incrementales que preserven comportamiento y puedan validarse con pruebas antes de avanzar.
Utilizar el agente para extraer funciones, reorganizar módulos, mejorar nombres, simplificar condicionales y aislar responsabilidades.
Controlar que Kilo no cambie contratos públicos, formatos de datos, comportamiento observable o compatibilidad sin aprobación explícita.
Diseñar prompts para modernizar dependencias, migrar APIs, actualizar frameworks o adaptar patrones antiguos.
Crear tests de caracterización antes de modificar código legacy que no dispone de cobertura suficiente.
Documentar decisiones de refactorización mediante ADRs o notas técnicas que expliquen por qué se eligió una estrategia.
Medir si la refactorización reduce complejidad real o solo produce una versión diferente del mismo problema.
Construir un backlog de deuda técnica con evidencias, prioridades y tareas aptas para ejecución asistida por Kilo.
Tema 18: Debugging, análisis de errores y troubleshooting con Kilo
Proporcionar logs, stack traces, comandos ejecutados, entorno, versión y pasos de reproducción para que Kilo investigue fallos con contexto suficiente.
Usar el agente para formular hipótesis, localizar archivos relevantes y proponer pruebas de confirmación antes de aplicar correcciones.
Analizar fallos de compilación, errores de runtime, problemas de dependencias, regresiones y comportamientos intermitentes.
Pedir a Kilo que explique trazas complejas conectando capa de presentación, dominio, infraestructura, base de datos y servicios externos.
Evitar que el agente aplique parches superficiales que ocultan el síntoma sin resolver la causa raíz.
Diseñar sesiones de debugging con pasos controlados: observación, hipótesis, prueba, corrección, validación y documentación.
Utilizar comandos autorizados para ejecutar tests, reproducir errores, inspeccionar configuración o revisar logs locales.
Preparar prompts específicos para errores en CI/CD, contenedores, entornos locales, permisos, variables y dependencias.
Documentar incidentes resueltos con ayuda de Kilo para crear conocimiento reutilizable por el equipo.
Convertir bugs repetitivos en tests, reglas, workflows o skills que eviten su reaparición.
Tema 19: Testing asistido por Kilo: unitario, integración, regresión y cobertura
Pedir generación de tests a partir de comportamiento esperado, casos límite, bugs detectados y contratos existentes.
Revisar que los tests generados comprueban lógica real y no simplemente replican la implementación actual.
Diseñar pruebas unitarias que aíslan reglas de negocio, validaciones, transformaciones y errores esperados.
Crear pruebas de integración con bases de datos, APIs, servicios internos, colas, ficheros o dependencias externas simuladas.
Utilizar Kilo para aumentar cobertura en zonas críticas sin perseguir porcentajes artificiales.
Identificar flaky tests, dependencias temporales, datos frágiles y aserciones débiles creadas por automatismos poco revisados.
Pedir al agente que refactorice tests existentes para mejorar legibilidad, fixtures, nomenclatura y reutilización.
Integrar tests en workflows y comandos de revisión local antes de abrir pull requests.
Documentar escenarios de prueba para que QA, desarrollo y negocio compartan criterios de aceptación.
Construir una estrategia donde Kilo acelera creación de pruebas, pero la calidad de la suite sigue siendo responsabilidad del equipo.
Tema 20: Revisión de código, pull requests y control de cambios
Utilizar Kilo para revisar cambios locales antes de subirlos, detectando errores evidentes, código muerto, TODOs y problemas de estilo.
Preparar pull requests con descripción clara, contexto funcional, riesgos, pruebas realizadas y decisiones técnicas relevantes.
Configurar agentes o subagentes de revisión con permisos limitados para evitar que modifiquen código mientras evalúan cambios.
Pedir revisiones centradas en seguridad, rendimiento, arquitectura, mantenibilidad, tests, compatibilidad o experiencia de usuario.
Comparar comentarios generados por IA con criterios humanos para evitar ruido, recomendaciones irrelevantes o falsa autoridad.
Detectar cambios demasiado amplios, archivos tocados sin necesidad o modificaciones que no responden al objetivo del ticket.
Generar checklists de revisión adaptadas a backend, frontend, APIs, infraestructura, documentación o scripts.
Crear resúmenes de diff para reviewers humanos cuando el cambio es grande o afecta a varias capas.
Establecer reglas para aceptar sugerencias de Kilo solo después de compilar, probar y revisar impacto.
Medir si la revisión asistida reduce defectos reales o simplemente añade comentarios sin valor al proceso.
Tema 21: Documentación técnica, ADRs, changelogs y conocimiento del repositorio
Generar documentación a partir de código real, arquitectura, endpoints, comandos, dependencias y decisiones históricas.
Crear ADRs que expliquen contexto, alternativas, decisión tomada, consecuencias y criterios de revisión futura.
Mantener README, guías de instalación, runbooks, documentación API y notas de release actualizadas con ayuda de workflows.
Pedir a Kilo que detecte documentación obsoleta comparando instrucciones existentes con scripts y estructura actual del proyecto.
Crear changelogs y resúmenes de release a partir de commits, pull requests, issues y cambios relevantes.
Documentar procedimientos de despliegue, rollback, mantenimiento y diagnóstico con pasos verificables.
Usar skills de documentación para mantener tono, estructura, formato y nivel de detalle homogéneos en todo el equipo.
Separar documentación pública, interna, operativa y de arquitectura para evitar mezclar audiencias y niveles de sensibilidad.
Revisar que la documentación generada no inventa capacidades, endpoints, configuraciones o garantías inexistentes.
Convertir el uso de Kilo en una herramienta de transferencia de conocimiento y no solo de generación de texto técnico.
Tema 22: Automatización de tareas repetitivas del desarrollador
Identificar tareas repetidas que consumen tiempo y pueden convertirse en workflows, skills, scripts o comandos asistidos por Kilo.
Automatizar preparación de ramas, instalación de dependencias, actualización de versiones, limpieza de archivos y generación de plantillas.
Crear flujos para renombrado masivo, reorganización de carpetas, transformación de formatos y mantenimiento de documentación.
Diseñar automatizaciones con puntos de confirmación antes de modificar muchos archivos o ejecutar operaciones destructivas.
Validar resultados con Git diff, tests, linters y revisión humana antes de confirmar cambios.
Evitar automatizaciones opacas que funcionan una vez pero nadie entiende ni mantiene después.
Integrar Kilo con comandos existentes del proyecto en lugar de sustituir procesos ya fiables.
Crear plantillas para tareas de onboarding, creación de módulos, endpoints, componentes, tests o páginas documentales.
Documentar el propósito, límites y riesgos de cada automatización incorporada al repositorio.
Evaluar qué tareas deben mantenerse como scripts tradicionales y cuáles ganan valor al ser asistidas por agente.
Tema 23: Kilo en proyectos frontend, backend, APIs y microservicios
Adaptar el uso de Kilo a proyectos frontend con componentes, estados, rutas, accesibilidad, rendimiento y pruebas de interfaz.
Utilizar el agente en backend para servicios, controladores, modelos de dominio, persistencia, validaciones, errores y contratos API.
Revisar endpoints, DTOs, OpenAPI, autenticación, autorización y compatibilidad entre clientes y servicios.
Trabajar en microservicios evitando que Kilo optimice un servicio sin comprender dependencias, eventos, contratos y consumidores.
Preparar prompts por stack para .NET, Java, Node.js, Python, TypeScript, React, Angular, Vue, Spring, FastAPI o frameworks equivalentes.
Crear agentes o skills específicos por stack tecnológico para aplicar convenciones reales de la empresa.
Gestionar migraciones entre versiones de frameworks o librerías con pasos controlados y pruebas de regresión.
Evitar que Kilo mezcle patrones incompatibles dentro de una misma base de código.
Documentar contratos, decisiones y límites de cada servicio para que el agente trabaje con contexto suficiente.
Definir criterios de aceptación distintos para UI, backend, APIs, batch, librerías y servicios internos.
Tema 24: Kilo aplicado a DevOps, CI/CD, contenedores e infraestructura
Utilizar Kilo para entender pipelines existentes, localizar fallos y proponer mejoras en workflows de CI/CD.
Generar o modificar archivos de configuración de GitHub Actions, GitLab CI/CD, Azure Pipelines o Jenkins bajo revisión técnica.
Preparar Dockerfiles, Compose, scripts de arranque y configuraciones locales evitando malas prácticas de seguridad y rendimiento.
Revisar infraestructura como código detectando cambios peligrosos en permisos, redes, recursos cloud o secretos.
Crear runbooks de despliegue, rollback y diagnóstico operativo con pasos comprobables.
Automatizar comprobaciones locales antes de lanzar pipelines costosos o releases críticas.
Pedir análisis de logs y errores de pipeline conectando dependencias, tests, rutas, credenciales y entornos.
Configurar permisos restrictivos para comandos shell cuando Kilo trabaja en repositorios con acceso a infraestructura.
Evitar que el agente aplique cambios de producción sin revisión explícita de DevOps o plataforma.
Diseñar una relación segura entre Kilo, terminal, cloud, CI/CD y herramientas internas de operación.
Tema 25: Seguridad del código, secretos y privacidad en el uso de agentes
Revisar riesgos de exponer código propietario, credenciales, datos de cliente, trazas sensibles o documentación interna a proveedores externos.
Establecer políticas sobre qué repositorios, carpetas, archivos y datos pueden procesarse con Kilo según sensibilidad.
Configurar proveedores, modelos locales o BYOK cuando la organización requiere mayor control sobre inferencia y tratamiento de datos.
Usar permisos para bloquear lectura de directorios externos, archivos sensibles, comandos peligrosos y herramientas no autorizadas.
Diseñar `AGENTS.md` con reglas explícitas sobre secretos, validación de entradas, dependencias, logging y prácticas seguras.
Utilizar Kilo para detectar secretos accidentales, patrones inseguros, dependencias vulnerables y errores comunes de seguridad.
Revisar que el agente no introduzca credenciales de ejemplo, bypasses, logs excesivos o endpoints de depuración.
Crear workflows de revisión de seguridad antes de pull requests o releases.
Definir controles de seguridad para MCPs conectados a sistemas externos, repositorios, gestores de incidencias o herramientas cloud.
Preparar una guía interna de uso seguro de Kilo para desarrolladores, QA, DevOps y responsables técnicos.
Tema 26: Gobierno empresarial con Kilo Teams y Enterprise
Diferenciar uso individual de Kilo frente a implantación en equipo con billing centralizado, analítica, modelos compartidos y políticas comunes.
Diseñar una estructura de adopción para equipos, proyectos, proveedores, modelos permitidos y estándares de configuración.
Revisar capacidades de Teams como gestión de equipo, analítica de uso, facturación centralizada, shared BYOK y controles de privacidad.
Analizar necesidades Enterprise como SSO, OIDC, SCIM, audit logs, limitación de modelos/proveedores y compromisos de SLA.
Definir roles internos: administrador de plataforma, champion técnico, responsable de seguridad, owner de repositorio y usuario final.
Preparar políticas sobre uso de modelos, costes, repositorios permitidos, datos sensibles, logs, prompts y herramientas externas.
Crear configuraciones base por tipo de equipo sin impedir ajustes necesarios por stack o dominio.
Diseñar procesos de revisión para nuevos MCPs, skills, workflows, subagentes y proveedores antes de aprobarlos corporativamente.
Medir adopción con indicadores de uso, calidad, reducción de tareas repetitivas, satisfacción y riesgos detectados.
Construir un modelo de gobierno que permita escalar Kilo sin convertirlo en una herramienta descontrolada o infrautilizada.
Tema 27: Costes, límites, consumo de tokens y eficiencia operativa
Interpretar cómo influyen modelo, contexto, herramientas, repeticiones, errores y sesiones largas en el consumo real.
Comparar uso de Kilo Gateway, Kilo Pass, BYOK, Auto Free y modelos locales desde coste, control y calidad de respuesta.
Establecer criterios para escoger modelos baratos en tareas sencillas y modelos más potentes en arquitectura, debugging o cambios complejos.
Reducir coste mediante prompts más precisos, contexto acotado, tareas pequeñas, workflows bien diseñados y validaciones tempranas.
Detectar patrones de gasto inútil: pedir análisis completos repetidos, cargar repositorios enormes o ejecutar ciclos sin revisar resultados.
Configurar límites, reporting y seguimiento por equipo cuando la organización necesita previsibilidad presupuestaria.
Crear recomendaciones internas para seleccionar tier, proveedor y modelo según tipo de tarea.
Evaluar si una automatización ahorra tiempo real o genera consumo adicional por retrabajo y revisión.
Medir coste frente a valor en tareas de documentación, debugging, testing, refactorización y soporte a onboarding.
Diseñar una política de optimización continua que combine productividad, calidad y control económico.
Tema 28: Integración con flujos Git, incidencias, documentación y herramientas corporativas
Conectar el uso de Kilo con issues, historias de usuario, pull requests, ramas, releases y documentación técnica.
Preparar prompts que partan de tickets reales y traduzcan requisitos en tareas de análisis, diseño, implementación y validación.
Utilizar MCP o herramientas externas para relacionar Kilo con GitHub, GitLab, Jira, Linear, Sentry, Figma, documentación o APIs internas.
Revisar criterios para que un agente consulte herramientas externas sin modificar información crítica accidentalmente.
Crear workflows de preparación de PR, revisión de incidencias, actualización documental y generación de notas de release.
Establecer nomenclatura y trazabilidad entre prompts, commits, decisiones y resultados entregados.
Integrar Kilo en ceremonias técnicas como refinamiento, diseño, revisión de deuda, postmortems y planificación de releases.
Documentar limitaciones cuando el agente no tiene acceso completo a sistemas corporativos o cuando los datos están incompletos.
Evitar que la IA genere tareas, comentarios o documentación desconectada de la fuente oficial de verdad.
Diseñar un flujo donde Kilo apoya herramientas existentes en lugar de crear un proceso paralelo difícil de auditar.
Tema 29: Onboarding acelerado en repositorios y productos existentes
Usar Kilo para explorar arquitectura, carpetas, dominios, dependencias, comandos, pruebas y puntos de entrada de un repositorio nuevo.
Crear resúmenes de onboarding por módulo, servicio, área funcional o tecnología sin depender de una única persona experta.
Pedir al agente mapas de flujo desde una petición HTTP, evento, pantalla o comando hasta las capas internas implicadas.
Generar guías de instalación y arranque comparando documentación existente con comandos y archivos reales.
Identificar áreas de riesgo para nuevos desarrolladores: convenciones no documentadas, scripts frágiles, dependencias ocultas o tests lentos.
Preparar sesiones de aprendizaje donde Kilo responde preguntas sobre código sin modificarlo.
Crear skills o workflows de onboarding para que cada nuevo miembro siga el mismo recorrido inicial.
Revisar respuestas del agente con desarrolladores veteranos para corregir interpretaciones erróneas del sistema.
Mantener documentación de onboarding como producto vivo actualizado desde hallazgos reales.
Medir reducción de tiempo de incorporación sin sustituir mentoría técnica, revisión humana ni contexto de negocio.
Tema 30: Migración desde Cursor, Claude Code, Copilot u otras herramientas de IA
Analizar diferencias entre Kilo Code y otras herramientas de codificación IA en superficies, modelos, configuración, agentes y enfoque open source.
Migrar hábitos de prompting desde herramientas anteriores sin arrastrar instrucciones incompatibles o flujos poco seguros.
Reutilizar estándares portables como `AGENTS.md` cuando el equipo trabaja con varias herramientas de agentes IA.
Comparar gestión de modelos, BYOK, permisos, MCP, workflows, skills y CLI frente a soluciones ya implantadas.
Revisar qué reglas o memorias heredadas deben convertirse en instrucciones de proyecto, skills o agentes personalizados.
Adaptar prompts de Cursor, Claude Code o Copilot a la lógica de agentes, permisos y contexto de Kilo.
Diseñar una transición por fases para no interrumpir productividad de equipos que ya dependen de otras herramientas.
Evaluar qué funciones conviene mantener en cada herramienta si la organización no quiere una migración total.
Preparar criterios de decisión basados en seguridad, coste, control, productividad, calidad, comunidad y capacidad de personalización.
Crear un plan de adopción que reduzca resistencia y evite cambios bruscos de flujo de trabajo.
Tema 31: Troubleshooting de Kilo: proxy, certificados, runtime, modelos y MCP
Diagnosticar problemas de instalación, runtime embebido, conexión con servidor local, permisos del IDE y extensiones bloqueadas.
Resolver incidencias de proxy corporativo, inspección HTTPS, certificados, firewalls y restricciones de red.
Revisar errores de autenticación con proveedores, claves API inválidas, límites de rate limit o modelos no disponibles.
Investigar fallos de configuración en `kilo.jsonc`, rutas incorrectas, JSONC mal formado o conflictos entre configuración global y local.
Diagnosticar MCPs que no responden, requieren autenticación, fallan por timeout o no exponen herramientas correctamente.
Revisar problemas de permisos cuando el agente no puede leer, editar, buscar, ejecutar comandos o acceder a directorios permitidos.
Analizar comportamiento inesperado en agentes, skills, workflows o subagentes por instrucciones contradictorias.
Recuperar sesiones problemáticas mediante reinicio de contexto, reducción de alcance, revisión de logs o separación en tareas más pequeñas.
Crear un checklist de soporte interno para resolver incidencias habituales antes de escalar al proveedor o al equipo de plataforma.
Documentar incidencias recurrentes para convertirlas en guías, workflows o ajustes de configuración compartidos.
Tema 32: Diseño de estándares internos para equipos que usan Kilo Code
Definir una guía corporativa de uso de Kilo con casos permitidos, casos restringidos, revisión obligatoria y criterios de seguridad.
Crear plantillas de `AGENTS.md` por stack, tipo de repositorio, criticidad y equipo.
Diseñar configuraciones base de permisos para lectura, edición, comandos, MCP, skills, web y subagentes.
Establecer cuándo se permite BYOK, Gateway, modelos locales o modelos frontier según sensibilidad y coste.
Crear biblioteca interna de workflows para pull requests, releases, documentación, testing, análisis de deuda y onboarding.
Definir skills aprobadas, responsables de mantenimiento, versión, propósito y ámbito de uso.
Preparar subagentes corporativos para revisión, seguridad, documentación, QA, arquitectura y exploración read-only.
Integrar Kilo en Definition of Done, code review, políticas de ramas y estándares de documentación.
Formar a champions internos para acompañar adopción, resolver dudas y mantener prácticas actualizadas.
Revisar periódicamente resultados, riesgos, configuraciones y mejoras detectadas en proyectos reales.
Tema 33: Métricas de productividad, calidad y riesgo en la adopción de Kilo
Medir productividad con indicadores equilibrados, evitando interpretar velocidad de generación como mejora automática.
Analizar impacto en lead time, tiempo de revisión, incidencias, defectos, cobertura, documentación y onboarding.
Revisar calidad del código generado o modificado con métricas de tests, complejidad, mantenibilidad y deuda técnica.
Evaluar seguridad observando permisos, uso de secretos, proveedores, MCPs, comandos ejecutados y exposición de información.
Controlar costes por equipo, proyecto, modelo, tipo de tarea y sesiones de mayor consumo.
Recoger feedback cualitativo de desarrolladores, reviewers, QA, DevOps y responsables técnicos.
Detectar malos usos: aceptación ciega, cambios demasiado grandes, generación sin tests o dependencia excesiva del agente.
Crear paneles de adopción que muestren valor real y riesgos, no solo número de sesiones o tokens consumidos.
Diseñar revisiones trimestrales para ajustar modelos, permisos, workflows, skills y formación interna.
Construir un plan de mejora continua basado en datos, incidentes, aprendizajes y evolución de la herramienta.
Tema 34: Proyecto Final
Recibir un repositorio empresarial con backend, frontend, tests, documentación parcial, pipeline básico y deuda técnica localizada.
Instalar y configurar Kilo Code en IDE y CLI, validando proveedores, modelo inicial, acceso a repositorio y permisos seguros.
Crear una configuración `kilo.jsonc` de proyecto con permisos, modelo, preferencias y restricciones adaptadas al laboratorio.
Diseñar un `AGENTS.md` raíz y reglas por directorio para backend, frontend, tests, documentación y seguridad.
Crear un workflow en `.kilo/commands/` para preparar pull requests con revisión, tests, linting y generación de descripción.
Desarrollar una skill corporativa con `SKILL.md` para aplicar criterios internos de API, testing, documentación o arquitectura.
Configurar un subagente especializado de revisión read-only con permisos limitados y prompt orientado a mantenibilidad.
Integrar un MCP de laboratorio o herramienta externa controlada, ajustando timeout, credenciales por entorno y permisos específicos.
Implementar una mejora funcional pequeña con Kilo, incorporando análisis previo, cambios revisables, tests y documentación.
Resolver un bug mediante sesión de debugging, hipótesis, pruebas, corrección, validación y explicación del impacto.
Revisar un pull request generado con ayuda de Kilo, identificando cambios correctos, riesgos, pruebas necesarias y ajustes pendientes.
Preparar un informe final de adopción con configuración propuesta, flujos aprobados, riesgos, costes, gobierno y plan de escalado.
Perfiles profesionales
Pensado para quienes deben dominar Kilo Code en su día a día
Desarrolladores de software
Este curso encaja con desarrolladores que quieren utilizar Kilo Code para implementar funcionalidades, refactorizar código, crear tests, analizar errores, entender repositorios y automatizar tareas repetitivas sin perder control sobre los cambios. La formación les ayuda a trabajar con agentes de forma precisa, revisable y alineada con los estándares del equipo.
Arquitectos de software y responsables técnicos
Los perfiles de arquitectura encontrarán una metodología para usar Kilo Code en análisis de diseño, evaluación de deuda técnica, revisión de patrones, documentación de decisiones, migraciones, modularización y gobernanza de repositorios. El curso les permite definir reglas, agentes y flujos que eviten usos improvisados de la IA.
Preguntas frecuentes
Resolvemos todas tus dudas sobre nuestra formación en Kilo Code
Explora las respuestas a las preguntas que guian a nuestra comunidad. Aqui encontraras claridad sobre como funciona todo, desde el acceso hasta los detalles de los cursos. Si buscas respuestas, este es el lugar para comenzar.
No. Aunque un desarrollador individual puede aprovecharlo mucho, el curso está diseñado para adopción profesional en equipos. Se trabajan configuraciones compartidas, permisos, `AGENTS.md`, workflows, skills, subagentes, gobierno, costes y políticas de uso.
No es imprescindible. El curso empieza situando Kilo Code, instalándolo y configurándolo desde cero. Aun así, está orientado a perfiles técnicos con experiencia en desarrollo, Git, terminal, repositorios, pruebas y trabajo con IDE.
Sí. El temario incluye uso en VS Code, JetBrains y CLI, con especial atención a diferencias prácticas, configuración, sesiones, permisos, comandos, runtime, Agent Manager, workflows y troubleshooting en entornos corporativos.
Sí. Se trabajan Kilo Gateway, Kilo Pass, BYOK, proveedores externos, modelos locales con Ollama o LM Studio, Auto Model, control de costes, selección por tipo de tarea y políticas corporativas sobre modelos permitidos.
Sí. El curso dedica un bloque completo a MCP: servidores locales y remotos, configuración, permisos, variables de entorno, herramientas externas, timeouts, troubleshooting, casos de uso y criterios de seguridad antes de conectar sistemas corporativos.
Sí. Son piezas centrales del curso. Se aprende a crear instrucciones de proyecto, reglas por directorio, workflows como slash commands en `.kilo/commands/` y skills con `SKILL.md` para encapsular conocimiento especializado.
Sí. El proyecto final y los laboratorios pueden orientarse a .NET, Java, Node.js, Python, frontend, APIs, microservicios, DevOps o documentación técnica. La metodología se adapta al stack real de la empresa.
Sí. Se revisan riesgos de exposición de código, secretos, credenciales, datos sensibles, proveedores externos, modelos locales, BYOK, permisos, comandos shell, MCPs y políticas internas para uso seguro de agentes IA.
Sí. El curso incluye un bloque de migración y convivencia con otras herramientas. Se revisa cómo adaptar prompts, reglas, instrucciones, flujos y estándares sin duplicar esfuerzos ni crear procesos contradictorios.
Sí. El Proyecto Final consiste en configurar Kilo sobre un repositorio empresarial, crear `AGENTS.md`, workflows, skills, subagentes, MCP, resolver una mejora funcional, corregir un bug, revisar un PR y preparar una estrategia de adopción.
Sí, esta formación puede ser bonificable hasta el 100% a través de FUNDAE, siempre que la empresa disponga de crédito formativo suficiente y se cumplan los requisitos de comunicación, asistencia y documentación exigidos.
No. Aunque un desarrollador individual puede aprovecharlo mucho, el curso está diseñado para adopción profesional en equipos. Se trabajan configuraciones compartidas, permisos, `AGENTS.md`, workflows, skills, subagentes, gobierno, costes y políticas de uso.
No es imprescindible. El curso empieza situando Kilo Code, instalándolo y configurándolo desde cero. Aun así, está orientado a perfiles técnicos con experiencia en desarrollo, Git, terminal, repositorios, pruebas y trabajo con IDE.
Sí. El temario incluye uso en VS Code, JetBrains y CLI, con especial atención a diferencias prácticas, configuración, sesiones, permisos, comandos, runtime, Agent Manager, workflows y troubleshooting en entornos corporativos.
Sí. Se trabajan Kilo Gateway, Kilo Pass, BYOK, proveedores externos, modelos locales con Ollama o LM Studio, Auto Model, control de costes, selección por tipo de tarea y políticas corporativas sobre modelos permitidos.
Sí. El curso dedica un bloque completo a MCP: servidores locales y remotos, configuración, permisos, variables de entorno, herramientas externas, timeouts, troubleshooting, casos de uso y criterios de seguridad antes de conectar sistemas corporativos.
Sí. Son piezas centrales del curso. Se aprende a crear instrucciones de proyecto, reglas por directorio, workflows como slash commands en `.kilo/commands/` y skills con `SKILL.md` para encapsular conocimiento especializado.
Sí. El proyecto final y los laboratorios pueden orientarse a .NET, Java, Node.js, Python, frontend, APIs, microservicios, DevOps o documentación técnica. La metodología se adapta al stack real de la empresa.
Sí. Se revisan riesgos de exposición de código, secretos, credenciales, datos sensibles, proveedores externos, modelos locales, BYOK, permisos, comandos shell, MCPs y políticas internas para uso seguro de agentes IA.
Sí. El curso incluye un bloque de migración y convivencia con otras herramientas. Se revisa cómo adaptar prompts, reglas, instrucciones, flujos y estándares sin duplicar esfuerzos ni crear procesos contradictorios.
Sí. El Proyecto Final consiste en configurar Kilo sobre un repositorio empresarial, crear `AGENTS.md`, workflows, skills, subagentes, MCP, resolver una mejora funcional, corregir un bug, revisar un PR y preparar una estrategia de adopción.
Sí, esta formación puede ser bonificable hasta el 100% a través de FUNDAE, siempre que la empresa disponga de crédito formativo suficiente y se cumplan los requisitos de comunicación, asistencia y documentación exigidos.
Diseñemos hoy el curso que tu empresa necesita
Cuéntanos tus objetivos de negocio y prepararemos una propuesta formativa bonificable totalmente ad hoc
de agentes IA sobre código corporativo El curso aborda proveedores, BYOK, modelos locales, permisos, secretos, comandos shell, MCP y exposición de información sensible. Esto permite definir usos seguros y evitar que el agente tenga más acceso del necesario para la tarea.
2
Estandariza conocimiento técnico mediante `AGENTS.md`, skills y workflows Las reglas de arquitectura, testing, documentación y seguridad pueden versionarse dentro del repositorio y reutilizarse entre proyectos. Esto ayuda a que la IA trabaje con el criterio del equipo, no con patrones genéricos aprendidos fuera del contexto real.
3
Reduce dependencia de perfiles concretos en onboarding y mantenimiento Kilo puede ayudar a explorar repositorios, explicar flujos, generar documentación y localizar dependencias, siempre bajo revisión. La formación muestra cómo convertir ese potencial en un proceso repetible para incorporar personas y mantener sistemas existentes.
4
Permite escalar adopción con control de costes y modelos El curso enseña a decidir cuándo usar modelos potentes, cuándo usar opciones más económicas, cuándo aplicar BYOK, cuándo probar modelos locales y cómo controlar gasto por equipo. Esto evita que la adopción crezca sin visibilidad presupuestaria.
5
Integra IA en el ciclo completo de ingeniería La formación no se limita a escribir código. Cubre planificación, arquitectura, implementación, revisión, pruebas, documentación, DevOps, seguridad, MCP, workflows, subagentes y gobierno, ofreciendo una visión completa del uso profesional de Kilo Code.
Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.
Acceso a las grabaciones
Los alumnos podrán revisar las sesiones grabadas para repasar conceptos clave, recuperar explicaciones concretas o reforzar aquellos contenidos que necesiten después de la clase en directo.
Recursos formativos
Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.
Confirmación de asistencia
La plataforma permite registrar y confirmar la asistencia de los participantes, facilitando el seguimiento de la formación y la gestión documental necesaria para la bonificación FUNDAE.
Ejercicios prácticos
Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.
Practica y mejora con nuestra plataforma
Una plataforma practica, con IA integrada y pensada para que mejores desarrollando. Se adapta a tu ritmo, te corrige al instante y te muestra tu progreso real.
Correccion magica
Feedback inteligente
Aprende de cada acierto y fallo con explicaciones claras
Los profesionales de DevOps y plataforma podrán integrar Kilo Code en tareas de automatización, scripts, pipelines, infraestructura, documentación operativa, troubleshooting y revisión de configuración. La formación presta especial atención a permisos, comandos shell, agentes en CLI, entornos controlados, MCP y reducción de riesgos operativos.
Equipos QA y calidad de software
Los perfiles de QA pueden utilizar Kilo Code para generar casos de prueba, revisar cobertura, analizar regresiones, preparar datos de test, documentar escenarios, detectar defectos y automatizar validaciones. El curso aborda cómo pedir pruebas útiles, revisar resultados y evitar que la IA genere tests superficiales o frágiles.
Responsables de seguridad, compliance y gobierno técnico
Las áreas de seguridad y compliance necesitan controlar qué puede leer, editar, ejecutar o consultar un agente IA. Este curso desarrolla criterios para configurar permisos, limitar proveedores, proteger secretos, revisar actividad, separar entornos y definir políticas internas de uso aceptable.
CTO, Engineering Managers y líderes de adopción IA
Los responsables técnicos obtienen una visión completa para decidir cómo desplegar Kilo Code en equipos, qué modelos permitir, cómo controlar costes, qué métricas revisar, qué flujos estandarizar y cómo formar a los profesionales para que la herramienta mejore la ingeniería sin introducir caos.