TAILOR

Make the code fit the project — with zero waste.

The Unified AI Coding-Agent Engineering Framework
Combining Spec-Driven Development (SDD), Adaptive Pragmatism (Lite/Full/Ultra), Progressive Project Memory (.ai/), AST Semantic Code Reuse, and a Native Model Context Protocol (MCP) Server for Claude Code, Cursor, Codex, Gemini CLI / Antigravity, Windsurf, Roo Code / Cline, GitHub Copilot CLI, and Zed.

Created by Aman Katiyar (@AmanKtyr).

Overview & Objectives

AI coding assistants frequently encounter two distinct failure modes:

1. Unstructured Generation ("Vibe Coding"): Agents generate code from loose prompts, introducing redundant dependencies, duplicate components, and unvetted architectural changes.

2. Extreme Laziness without Specifications: Agents produce abbreviated implementations without documented requirements, contracts, or architectural constraints.

Tailor unifies these requirements into a disciplined, multi-agent engineering framework:

• Spec-Driven Development (SDD): Transforms user intent into formal feature specifications (spec.md), technical plans (plan.md), and granular checklists (tasks.md), governed by a Project Constitution (.ai/CONSTITUTION.md).

• Adaptive Pragmatism Ladder: Enforces the 7-step decision ladder (YAGNI -> Existing Code -> Stdlib -> Native API -> Installed Dep -> One-liner -> Minimal Code) with configurable intensity levels (lite, balanced, ultra, strict).

• Progressive Project Memory (.ai/): Self-healing, compact domain memory reducing LLM context token overhead by up to 80% with live drift repair.

• AST Semantic Code Reuse: Deterministically indexes workspace components, hooks, and utilities to inject reuse audits prior to code generation.

• Strict Anti-Styling & Anti-Bloat Guardrails: Enforces zero unsolicited CSS, prevents styling sprawl (gradients, glassmorphism, random Tailwind classes), and mandates minimal diff discipline.

• 17 Production Agent Skills: Standardized skills across frontend, backend, security, testing, architecture, and governance synchronized automatically to .agents/skills/.

• Native MCP Server: Connects directly to Claude Desktop, Cursor, Zed, Windsurf, and Antigravity via standard JSON-RPC.

Related MCP server: Ouroboros

Comparison Matrix

Quick Start & Installation

Tailor can be utilized via the universal Agent Skills standard, as a Global / Local CLI, or as a Model Context Protocol (MCP) Server.

1. Universal Agent Installation (skills CLI)

# 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. NPM CLI Installation

# Install globally
npm install -g @amanktyr/tailor

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

3. Model Context Protocol (MCP) Server Setup

Add Tailor to your claude_desktop_config.json or Cursor MCP settings:

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

CLI Command Reference

# 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

# Skills Governance
tailor skills list                   # Inspect all 17 agent engineering skills and sync status
tailor skills sync                   # Mirror all skills into .agents/skills/ for Gemini & Codex
tailor skills info <name>            # View complete directives and rules for a specific skill

# 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

The 7-Step Pragmatism Ladder

Before writing any new implementation or adding dependencies, AI agents follow this mandatory sequence:

┌────────────────────────────────────────────────────────┐
│ 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.       │
└────────────────────────────────────────────────────────┘

Universal Multi-Agent Support (10+ Platforms)

Run tailor sync at any time to update all adapter files simultaneously.

Benchmarks & Measurable Results

Tailor includes an automated benchmark suite (benchmarks/scripts/run-benchmarks.js) running across 5 real fixture codebases:

• 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, legacy dependencies, leaked secrets, eval)

Benchmark Performance:

• Project Signal Detection: 100% accurate across Next.js, Django, React, ASP.NET Core, and Express.

• Semantic Reuse Matching: 100% match for user requests (modal -> existing Dialog, fetchUser -> getUser).

• Dependency Governance: 100% rejection of trivial micro-packages (is-odd, left-pad) and challenge on redundant libraries (axios).

• Security Defenses: 100% detection of hardcoded AWS credentials, SQL string concatenation, and dangerous eval().

• Token & LOC Reduction: 40-70% reduction in generated code volume and context token consumption.

Privacy & Security

• Local & Deterministic Execution: Zero telemetry, no hidden remote logging, and no source code transmission.

• Non-destructive Defaults: Never silently overwrites or deletes unrelated files.

Contributing & Development

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