TAILOR

Haz que el código se ajuste al proyecto — con cero desperdicio.

El framework unificado de ingeniería de agentes de codificación con IA
Combina Desarrollo Dirigido por Especificaciones (SDD), Pragmatismo Adaptativo (Lite/Full/Ultra), Memoria Progresiva de Proyecto (.ai/), Reutilización Semántica de Código con AST y un Servidor Nativo del Model Context Protocol (MCP) para Claude Code, Cursor, Codex, Gemini CLI / Antigravity, Windsurf, Roo Code / Cline, GitHub Copilot CLI y Zed.

Creado por Aman Katyar (@AmanKtyr).

Resumen y objetivos

Los asistentes de codificación con IA se encuentran con frecuencia con dos modos de fallo distintos:

1. Generación no estructurada ("Vibe Coding"): Los agentes generan código a partir de indicaciones vagas, introduciendo dependencias redundantes, componentes duplicados y cambios arquitectónicos no validados.

2. Extrema pereza sin especificaciones: Los agentes producen implementaciones abreviadas sin requisitos, contratos o restricciones arquitectónicas documentados.

Tailor unifica estos requisitos en una estructura de ingeniería multiagente disciplinada:

• Desarrollo Dirigido por Especificaciones (SDD): Transforma la intención del usuario en arte udara especificaciones funcionales (spec.md), planes técnicos (plan.md) y listas de tareas detalladas (tasks.md), rigiéndose por una Constitución de Proyecto (.ai/CONSTITUTION.md).

• Escalera de Pragmatismo Adaptativo: Impone la escalera de decisión de 7 pasos (YAGNI -> Código existente -> Stdlib -> API nativa -> Dependencia instalada -> One-liner -> Código mínimo) con niveles de intensidad configurables (lite, balanced, ultra, strict).

• Memoria Progresiva de Proyecto (.ai/): Memoria de dominio autónoma y compacta que reduce el consumo de tokens de contexto de la LLM hasta en un 80 %, con reparación de desviaciones en vivo.

• Reutilización Semántica de Código con AST: Indexa de forma determinista los componentes, hooks y utilidades del espacio de trabajo para inyectar auditorías de reutilización antes de la generación de código.

• Servidor MCP Nativo: Se conecta directamente con Claude Desktop, Cursor, Zed, Windsurf y Antigravity mediante JSON-RPC estándar.

Related MCP server: memorix

Matriz comparativa

Inicio rápido e instalación

Tailor se puede utilizar a través del estándar universal de Agent Skills, como CLI global / local, o como un servidor Model Context Protocol (MCP).

1. Instalación universal del agente (CLI skills)

# Install Tailor across all AI coding assistants in your workspace
npx skills add AmanKtyr/Tailor -y

# Or install globally across your machine (-g)
npx skills add AmanKtyr/Tailor -g -y

2. Instalación CLI de NPM

# Install globally
npm install -g @amanktyr/tailor

# Or run directly via npx without installation:
npx @amanktyr/tailor init

3. Configuración del servidor Model Context Protocol (MCP)

Añade Tailor a tu claude_desktop_config.json o a los ajustes MCP de Cursor:

{
  "mcpServers": {
    "tailor": {
      "command": "npx",
      "args": ["-y", "@amanktyr/tailor", "mcp"]
    }
  }
}

Referencia de comandos CLI

# Project Governance & Initialization
tailor init                          # Conduct discovery, stack selection, and initialize .ai/
tailor constitution                  # View or regenerate .ai/CONSTITUTION.md
tailor sync                          # Synchronize all 10+ AI agent adapter files

# Spec-Driven Development (SDD) Workflow
tailor spec init                     # Initialize specs/ directory and constitution
tailor spec new <feature-name>       # Scaffold specs/<id>-<name>/spec.md with user stories
tailor spec plan <id>                # Generate reuse-aware technical plan (plan.md)
tailor spec tasks <id>               # Generate granular, ordered task checklist (tasks.md)
tailor spec list                     # View all active feature specs and completion status

# Intelligence, Memory & Security
tailor analyze                       # Deterministically inspect stack, frameworks, and reusable catalog
tailor memory update                 # Synchronize .ai/ progressive memory documents
tailor memory drift                  # Detect drift between active code and recorded memory
tailor security                      # Run static security rules and credential leak checks
tailor dependencies --check <pkg>   # Evaluate package for bloat, redundancy, and licenses
tailor review                        # Run holistic quality, architecture, and security gates
tailor doctor                        # Run full system, git, memory, and skill diagnostics
tailor mcp                           # Start stdio Model Context Protocol (MCP) server

La escalera de pragmatismo de 7 pasos

Antes de escribir cualquier implementación nueva o añadir de dependencia, los agentes de IA siguen esta secuencia obligatoria:

┌────────────────────────────────────────────────────────┐
│ 1. Does this need to exist? (YAGNI)                    │
│    -> Reject speculative complexity or future-proofing.│
├────────────────────────────────────────────────────────┤
│ 2. Already in this codebase?                           │
│    -> Search src/components/, src/lib/, src/utils/.    │
├────────────────────────────────────────────────────────┤
│ 3. Does the Standard Library do it?                    │
│    -> Use crypto.randomUUID(), structuredClone(), etc. │
├────────────────────────────────────────────────────────┤
│ 4. Does a Native Platform / Browser API cover it?      │
│    -> Use <dialog>, <input type="date">, fetch().      │
├────────────────────────────────────────────────────────┤
│ 5. Does an already-installed dependency solve it?      │
│    -> Reuse existing packages in package.json.         │
├────────────────────────────────────────────────────────┤
│ 6. Can it be written as a one-liner / inline helper?   │
│    -> Avoid creating 50-line wrappers for simple logic.│
├────────────────────────────────────────────────────────┤
│ 7. Only then: Write the minimum amount of clean code.  │
│    -> Clean domain boundaries, types, and tests.       │
└────────────────────────────────────────────────────────┘

Soporte universal multiagente (10+ plataformas)

Ejecuta tailor sync en cualquier momento para actualizar todos los archivos de adaptadores a la vez.

Benchmarks y resultados medibles

Tail incluye una suite de benchmarks automatizada (benchmarks/scripts/run-benchmarks.js) que se ejecuta sobre 5 bases de código reales:

• nextjs-app (Next.js 14, React 18, Tailwind CSS, Vitest)

• django-app (Django 4.2, PostgreSQL, DRF, Pytest)

• react-app (React, Vite)

• dotnet-api (ASP.NET Core, C# .NET 8)

• messy-monolith (Express, dependencias heredadas, secretos filtrados, eval)

Rendimiento de los benchmarks:

• Detección de las señales del proyecto: 100 % de precisión en Next.js, Django, React, ASP.NET Core y Express.

• Coincidencia semántica de reutilización: 100 % de coincidencia para las solicitudes de los usuarios (modal -> Dialog existente, fetchUser -> getUser).

• Gobierno de dependencias: Rechazos del 100 % en micropaquetes triviales (is-odd, left-pad) y cuestionamiento de librerías redundantes (axios).

• Defensas de seguridad: Detección del 100 % de credenciales de AWS hardcodeadas, concatenación de cadenas SQL y eval() peligroful.

• Tokens y reducción de LOC: 40-70 % menos de código generado y menos tokens de contexto.

Privacidad y seguridad

• Ejecución local y determinista prioridad: Cero telemetría, sin registro remoto oculto y sin transmisión del código fuente.

• No destructivo por defecto: No sobrescribes silenciosamente ni eliminar archivos no relacionados.

Contribución y desarrollo

git clone https://github.com/AmanKtyr/Tailor.git
cd Tailor
npm install
npm run build
npm test
npm run benchmark
node dist/cli/bin.js doctor

License

MIT © Aman Katiyar & Tailor Contributors