Communitygithub.com

AgentPilotLab/agent-lean-safe-coding

Skill de codificación segura y eficiente para Windows, optimizado para Codex, Claude Code y agentes de IA.

¿Qué es agent-lean-safe-coding?

Este skill ayuda a los agentes de IA a escribir código más pequeño y seguro, especialmente en entornos Windows o repositorios con mucho texto. Proporciona un proceso estructurado en modo `full` que incluye clasificación de tareas, un 'envoltorio de seguridad' para archivos de texto y Windows, una escalera de reutilización de código, un presupuesto de parches y verificación mínima. También ofrece modos `lite` (triaje rápido) y `audit` (solo revisión sin editar). Está diseñado para evitar la sobre-ingeniería, la duplicación de lógica, la fragilidad de rutas de Windows y la corrupción de texto, preservando el estilo del código existente y fomentando la reutilización de funcionalidades ya presentes en el proyecto, el framework o la plataforma. El skill lee documentación adicional (`references/windows-text-safety.md` y `references/reuse-ladder.md`) solo cuando es necesario, manteniendo el contexto del agente reducido.

Compatible con✓Claude Code✓Codex CLI~Cursor
npx skills add AgentPilotLab/agent-lean-safe-coding

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Agent Lean Safe Coding (Codificación Segura y Eficiente para Agentes)

Usa este skill para mantener los agentes de codificación más pequeños y seguros: construye solo el comportamiento necesario, reutiliza lo que ya existe y protege los repositorios con mucho texto o de Windows contra ediciones frágiles.

El modo predeterminado es full.

  • lite: triaje rápido, contexto reducido, parche mínimo y seguro.
  • full: escalera de triaje, envoltorio de seguridad para Windows/texto, verificación de dependencias, presupuesto de parches, verificación.
  • audit: sin ediciones; revisa un plan o diff para detectar sobreconstrucción, lógica duplicada, riesgo de dependencias, riesgo de Windows/texto y verificación débil.

Bucle de Ejecución

  1. Clasifica la tarea.
  2. Coloca los archivos de riesgo dentro del envoltorio de seguridad.
  3. Recorre la escalera de triaje antes de escribir código.
  4. Establece un presupuesto de parches.
  5. Edita localmente y preserva el estilo.
  6. Verifica la compuerta objetiva más pequeña.
  7. Reporta el resultado con notas de reutilización y riesgo.

1. Clasificar

Nombra el tipo de tarea antes de editar:

  • bugfix: encuentra la causa compartida; inspecciona los llamadores hermanos antes de dispersar guardas.
  • feature: verifica si el comportamiento solicitado ya está proporcionado por la plataforma, el framework o el repositorio.
  • refactor: requiere una simplificación concreta o reducción de riesgo; evita reorganizar el código por gusto.
  • review: señala eliminaciones, oportunidades de reutilización, operaciones inseguras de shell/texto y comprobaciones faltantes.
  • docs/text: protege la codificación, los finales de línea, la estructura Markdown y los ejemplos.

Si la solicitud no es clara pero un valor predeterminado conservador es seguro, procede con ese valor predeterminado y establece la suposición brevemente.

2. Envoltorio de Seguridad

Usa el envoltorio de seguridad cuando esté presente cualquiera de estos: rutas de Windows, PowerShell o cmd, texto no ASCII, texto chino, emojis, Markdown, prompts, plantillas, archivos de localización, reemplazos exactos, codificación incierta, archivos sensibles a CRLF/LF, o salida generada que pueda confundirse con código fuente.

Dentro del envoltorio:

  • Prefiere herramientas de parche para ediciones pequeñas.
  • Evita pasar contenido no ASCII a través de tuberías de shell o cadenas de PowerShell en línea.
  • Preserva el estilo de nueva línea existente a menos que un formateador sea dueño del archivo.
  • Usa APIs de ruta o rutas literales entrecomilladas para scripts.
  • Trata el mojibake de la consola solo como evidencia de visualización; inspecciona los bytes o las lecturas UTF-8 antes de reescribir.
  • No edites carpetas generadas, carpetas de dependencias, cachés, binarios, capturas de pantalla o archivos a menos que el usuario lo solicite explícitamente.

Lee references/windows-text-safety.md solo cuando una tarea tenga riesgo de codificación, nueva línea, ruta o fragilidad de shell.

3. Escalera de Triaje

Antes del código personalizado, detente en el primer nivel que resuelva la tarea limpiamente:

  1. Elimina la necesidad: ¿se puede satisfacer la solicitud eliminando, configurando o documentando una ruta existente?
  2. Reutiliza código del proyecto: helper, componente, hook, validador, utilidad de prueba, comando, esquema o patrón establecido.
  3. Usa el comportamiento del lenguaje o la biblioteca estándar.
  4. Usa el comportamiento de la plataforma o el framework: controles del navegador, CSS, restricciones de base de datos, enrutamiento del framework, validación, caché, serialización o herramientas de compilación.
  5. Usa una dependencia ya instalada.
  6. Agrega una pequeña implementación local.
  7. Propón una nueva dependencia o implementación más grande solo con una razón clara, riesgo y necesidad de aprobación.

Nunca agregues una dependencia de producción automáticamente. Si una nueva dependencia parece justificada, explica qué reemplaza, por qué las opciones instaladas no se ajustan, el riesgo de mantenimiento y el comando de instalación exacto.

Lee references/reuse-ladder.md solo cuando la decisión de dependencia/reutilización no sea obvia.

4. Presupuesto de Parches

Antes de editar, elige un presupuesto pequeño:

  • Archivos que se espera cambiar.
  • Archivos intencionalmente dejados solos.
  • Código existente o característica de plataforma a reutilizar.
  • Comando de verificación mínimo o razón por la que ningún comando es útil.

Prefiere menos archivos, menos abstracciones y cambios directos cerca del comportamiento. No agregues interfaces, fábricas, capas de servicio, interruptores de configuración, puntos de extensión futuros o envoltorios a menos que la tarea actual los necesite.

5. Reglas de Parche

  • Arregla la ruta raíz una vez en lugar de agregar soluciones repetidas del lado del llamador.
  • Elimina el código redundante cuando el comportamiento siga siendo correcto.
  • Mantén el ruido de formato fuera del diff.
  • Mantén los comentarios escasos; usa un comentario conciso solo cuando un límite intencional necesite ser visible más adelante.
  • Si un atajo tiene un límite conocido, nombra ese límite y el desencadenante de mejora en ese comentario.
  • No conviertas una pequeña función en un subsistema.

6. Verificación

Ejecuta la compuerta nueva más estrecha que demuestre el cambio:

  • Prueba existente para el comportamiento modificado.
  • Prueba unitaria enfocada o autocomprobación para lógica nueva no trivial.
  • Verificación de sintaxis/tipo/lint para archivos de lenguaje editados cuando no haya pruebas disponibles.
  • Revisión de diff para cambios solo de documentación o de una línea trivial.

Las ramas, analizadores, rutas de dinero/seguridad o rutas de pérdida de datos no triviales necesitan una comprobación ejecutable cuando sea práctico. Las líneas triviales no necesitan nuevo andamiaje de prueba.

7. Informe Final

Mantén el informe final breve:

Cambiado - ...
Triaje - reutilizado/stdlib/plataforma/dependencia instalada/código local/nueva propuesta de dependencia
Seguridad - riesgos de Windows/texto manejados o no relevantes
Verificado - comando/resultado o razón
Riesgos - límite restante, si lo hay

Para el modo audit, devuelve primero los hallazgos con referencias de archivo/línea cuando estén disponibles, luego una lista de eliminación/reutilización y la brecha de verificación más pequeña.

Skills relacionados