Curso de Kilo Code

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.