Impact

Measurable improvement.

Every metric quantified. Before Sigil vs. after — across speed, coverage, context quality, and automation.

400%

improvement

AI Workflow Improvement

3x more context (activity, health, critical files). 10x more rules enforced (42 directives). 22x faster repeat sessions. 12 languages via MCP. Zero manual steps. Your AI goes from guessing to knowing — instantly, every session.

Cached extraction speed 22x

before: 2000ms after: 90ms

MCP language coverage 12x

before: 1 language after: 12 languages

AI directives enforced 10x

before: 4 basic rules after: 42 directives

Query capabilities 4x

before: 3 basic patterns after: 12 rich queries

Context intelligence 3x

before: architecture only after: + activity, health, files

Manual steps required −100%

before: 3 manual cmds after: fully automated

Redundant file reads −78%

before: 370 reads after: 80 (deduped)

Fresh extraction speed 14%

before: 2000ms after: 1713ms

The Difference

Before & After

What coding with AI looks like — without Sigil, and with it.

Without Sigil: The Fragmentation Tax

Copy & paste files into the AI, hoping you picked the right ones
Manually write "use TypeScript strict mode" and "run tests first" every session
Switch to Cursor — none of your Claude rules carry over
AI hallucinates function names, ignores your coding standards
Different AI tools, different context, inconsistent output

Result: 6 config files. Zero consistency. Constant repetition.

With Sigil: One Pipe, Every Tool

sigil init — one command extracts architecture, loads directives, configures every AI tool
Your directives follow you everywhere — Claude, Cursor, Windsurf, Cline, Copilot, Continue
AI understands every entity, route, pattern, AND your rules
Token-optimized: critical rules always included, architecture pruned to fit
One source of truth. Every tool. Every session.

Result: consistent AI behavior across every tool you use.

How It Works

Eight commands. Full cycle.

Define directives, extract architecture, visualize it, query it, track drift, check health, optimize context, auto-watch — all from the terminal.

Directives

Define AI rules with priority, category, and conditions. Global directives cascade into every project. Project directives override globals.

          $ sigil directives add "Never use any" --priority high

          $ sigil directives add "Use pytest" --when-language python

          $ sigil directives

            1. [G] [critical] (security) Never hardcode credentials

            2. [G] [high] (code) Never use any

Init

Extracts architecture, loads directives, detects installed AI tools, and configures all of them in one command.

          $ sigil init

            ✓ Extracted: 31 entities, 28 components, 20 routes

            ✓ Loaded 4 directives (3 global, 1 project)

            ✓ Created CLAUDE.md, .cursorrules

            ✓ Injected 4 directives

Graph

Launch an interactive dependency graph. Click nodes, search, filter by type. Handles 1000+ node codebases.

          $ sigil graph

            ⚡ Sigil Graph — my-app

            🌐 http://localhost:4040

            Nodes: 176 | Edges: 89

Diff

Detect architectural drift. See what changed structurally — added entities, modified props, removed routes.

          $ sigil diff

          + entity: PaymentMethod (5 fields)

          ~ component: Dashboard

            + prop: billingEnabled: boolean

          - route: /api/legacy-auth

Query

Ask questions about your architecture. Dependency trees, reverse deps, import chains, dead function detection.

          $ sigil query "what depends on User"

            8 dependent(s) of "User":

            [component] UserCard imports User

            [import] routes/api → schema {User}

            ...6 more

Health

10 architectural checks. Circular deps, god components, auth gaps, dead functions, config drift. Score 0–100.

          $ sigil health

            Score: 87/100 (good)

            ✗ Circular dep: auth → session → auth

            ⚠ 3 dead functions detected

            ⚠ 2 env vars missing from .env

Context

Token-optimized output for AI prompts. Critical directives always included, architecture pruned to fit your budget.

          $ sigil context --tokens 4000

            # my-app — Architecture

            Entities (31) · Routes (20) · Directives (4)

            ~574 tokens.

Watch

Auto re-extract on file changes. Context stays fresh without manual re-runs. 1.5s debounce, sub-100ms when cached.

          $ sigil watch

            ⚡ Sigil Watch

            ✓ Extracted: 31 entities (1720ms)

            👁 Watching: src, app, lib

            ↻ src/index.ts changed (90ms)

What Your AI Gets

Architecture + directives. One payload.

Run sigil context --tokens 4000 — your AI receives a unified, token-optimized context with architecture and your directives baked in.

sigil context --tokens 4000

$ sigil context --tokens 4000

  # my-app — Architecture Context

  ## Stack
  framework: next.js@16 · orm: drizzle · database: postgresql

  ## Directives (2)
  - Never hardcode credentials [critical]
  - Always use TypeScript strict mode [high]

  ## Entities (31)
  - Users [src/db/schema.ts]: id, email, name, role
  - Posts [src/db/schema.ts]: id, title, content, authorId
  ...29 more

  ## Routes (20)
  - /api/users GET, POST(auth) [src/app/api/users/route.ts]
  - /api/posts GET, POST(auth), DELETE(auth)
  ...18 more

  ## Directives (1)
  - Use server components by default

  ~574 tokens.

AI Integration

MCP Server — zero-friction context.

Add one line to your AI tool config. Sigil provides architecture + directives for all 12 languages on every session — no manual steps, always fresh, sub-100ms cached.

      // Requires Pro license — get your key at sigil.riomyers.com

      "mcpServers": {

        "sigil": { "command": "sigil-mcp-server" }

      }

sigil://context resource

Instant Context

AI reads architecture + directives on session start in <100ms. Entities, routes, patterns, and your rules — everything, instantly.

watch mode

Always Fresh

File watcher auto-updates context when you save. Your AI never works with stale architecture.

sigil_query tool

Rich Queries

AI can query dependency trees, import chains, dead functions, reverse deps — "what depends on User", "show import graph", "find dead code."

sigil_health tool

Health Checks

10 architectural checks: circular deps, god components, auth gaps, dead functions, config drift. Score 0–100 with actionable suggestions.

Visualization

Explore the dependency graph.

Run sigil graph to launch an interactive force-directed graph of your entire codebase.

Sigil Graph — architecture visualization

Open live demo → · Cal.com: 1,072 components · 67 routes · 1,676 exports · parsed in 5.8s

Use Cases

When to use Sigil

Real scenarios where structured context changes everything.

sigil directives

Rules That Follow You

Define "never hardcode secrets" once. It applies everywhere — Claude Code, Cursor, Windsurf, Cline, Copilot, Continue. Global directives cascade into every project. Project directives override when needed.

sigil context --tokens 4000

Token-Aware Context

Large codebase? Sigil prunes intelligently. Critical directives always included. Architecture fills the remaining budget. Your AI gets the maximum context that fits — not a raw dump that overflows.

sigil health + sigil query

Find Dead Code & Config Drift

Sigil detects unreferenced functions, imported-but-never-called symbols, and env vars that are defined but unused (or used but undefined). Deep static analysis, no runtime needed.

sigil graph

Onboard in 15 Minutes

New to a project with hundreds of files? Launch the interactive graph. Click through components, trace dependencies, understand the architecture visually — without reading a single line of code.

Comparison

Why Sigil?

Existing tools solve pieces of the puzzle. Sigil is the complete picture.

Feature	Sigil	repomix	aider repo-map	Cursor Indexing
Structured output	✓ YAML/JSON	✗ flat text	~ tree-sitter map	✗ proprietary
Architecture-aware	✓ entities, routes, patterns, call graphs	✗ file dump	~ symbols only	~ basic
AI Directives	✓ priority, conditional, inherited	✗	✗	~ .cursorrules only
Token-optimized	✓ budget-aware pruning	✗	✗	✗
Interactive graph	✓ force-directed	✗	✗	✗
Drift detection	✓ structural diff	✗	✗	✗
Auto-configures AI tools	✓ 6 tools	✗	✗	✓ self only
Behavioral profiles	✓ global + local	✗	✗	✗
MCP server (auto-context)	✓ resource + tools	✗	✗	✗
Global + project rules	✓ directives with inheritance	✗	✗	✗
Plugin system	✓ any language	✗	✗	✗
Free tier available	✓ Free + Pro	✓	✓	✗

✓

AI Directives with Inheritance

Define rules globally, override per-project. Priority-based pruning under token pressure. Conditional by language/framework.

No other tool offers structured, portable AI directives.

✓

Token-Optimized Unified Context

Architecture + directives in one budget-aware payload. Critical rules never pruned.

✓

Structured YAML/JSON Output

Not a flat text dump — structured architecture with entities, components, routes, and relationships.

repomix: flat text · aider: tree-sitter map · Cursor: proprietary

✓

Interactive Dependency Graph

Force-directed visualization of your entire codebase. Click, search, filter by type.

No other tool offers this.

✓

Architectural Drift Detection

Compare snapshots to see what changed structurally — added entities, modified props, removed routes.

✓

Auto-Configures 6 AI Tools

Claude Code, Cursor, Windsurf, Cline, Copilot, Continue — one command configures all.

✓

MCP Server — Zero-Friction AI Context

One config line. AI gets full architecture on every session. Auto-updates on file changes.

✓

Behavioral Profiles

Define your identity, style, and workflow rules globally. Every project, every AI tool.

✓

12 Languages Built-In

TypeScript, Python, Go, Rust, Java, Kotlin, PHP, C#, Ruby, Swift, Elixir, Dart — all with lazy loading. Extend via plugins.

✓

Free Tier + Pro Plans

Get started free. Upgrade for health checks, auto-fix, watch mode, and unlimited directives.

Pricing

Choose your plan.

Start free. Scale as you grow. Every plan makes your AI dramatically better.

Free

forever

✓ Extract architecture
✓ 5 directives
✓ 3 presets
✓ Context output
✓ Show + diff
✗ Health checks
✗ Auto-fix
✗ Watch mode
✗ MCP server

Get Started

Recent Updates

Latest improvements to Sigil.

NEW

Universal presets — writer, researcher, business, student, creative modes

Sigil now supports non-coding workflows with 5 new directive presets

NEW

Stats dashboard — 400% AI workflow improvement quantified

Every metric measured: 22x faster caching, 12 languages, 42 directives

PERF

22x faster cached extraction — 2000ms down to 90ms

mtime fast-path, hash deduplication, lazy plugin loading

NEW

Smart context — recent activity, health snapshot, critical files

AI gets git history, health score, and hub files alongside architecture

NEW

sigil fix — auto-repair issues found by health checks

Generates error boundaries, syncs env vars, reports unfixable issues

NEW

Project audit dashboard — health scores for every project at a glance

Run sigil init from any directory to audit all detected projects

NEW

MCP polyglot — all 12 languages now supported via MCP server

Python, Go, Rust, Java, and 8 more languages via lazy loading

NEW

Deep Python parsing — entities, imports, env vars, function analysis

Pydantic models, dataclasses, FastAPI routes, import graph extraction

Your AI. Your rules.Every tool.