CLAUDE.md Is the Steering Wheel. TRACE Is the Seatbelt.

Every week someone asks: "We already have CLAUDE.md. Why do we need TRACE?"

Or the Cursor variant: "We have .cursor/rules." Or the Kiro variant: "We have steering files and hooks."

It's a fair question. And the answer is simple once you see the distinction: these tools solve different problems at different layers.

What steering tools actually do

CLAUDE.md, Cursor rules, and Kiro steering files are all input steering. They shape what the AI does before it starts working. They say things like "use TypeScript," "follow our naming conventions," "don't modify files in /legacy/," "run tests before committing."

This is valuable. It makes AI tools write better code that follows your patterns. Without it, the AI writes plausible code that doesn't match your project's conventions.

But input steering cannot answer this question:

"The AI just modified src/models/user.ts. There are 6 files that import from user.ts. Did the AI update all 6 of them?"

Steering files don't maintain a dependency graph. They don't track which files are sources of truth. They don't verify that when an anchor changes, all consumers are updated. They don't remember what happened in the last session. They don't block commits that are structurally incomplete.

What TRACE does

TRACE is output verification. It doesn't care how the AI was instructed. It checks whether the result is structurally complete.

TRACE maintains a structural graph of your project. It knows that user.ts is an anchor with 6 consumers. When user.ts changes and one consumer doesn't, TRACE blocks the commit. It doesn't matter whether the AI was told to "be careful." It matters whether the output is coherent.

Four scenarios

The fourth scenario is what you actually want. The AI writes code the way you prefer (steering), and TRACE verifies it didn't break any structural relationships (verification).

But can't I just put TRACE's rules in CLAUDE.md?

You can try. You could write:

## Rules
- Before modifying any file, check what depends on it
- After modifying a file, update all dependents
- Keep track of what you did in a session log
- Don't add dependencies without checking the license

This works when the context window is fresh, the request is explicit, and the change is obvious. But when the session is long, the request is fast ("just fix this quick bug"), or the change seems small, the AI skips these steps. We've observed this systematically across dozens of sessions. It's not a bug. It's a structural behavior pattern.

TRACE doesn't rely on the AI remembering instructions. The pre-commit hook doesn't care whether the AI intended to follow process. It checks whether the result is coherent. That's the fundamental difference between instruction and enforcement.

TRACE is tool-agnostic. Steering is not.

CLAUDE.md only works with Claude Code. Cursor rules only work with Cursor. Kiro steering only works inside Kiro. If your team uses different AI tools, each person has a different set of steering rules (or none at all).

TRACE works with all of them. One trace.yaml, one set of anchors, one pre-commit hook, one MCP server. Every developer gets the same structural verification regardless of which AI tool they prefer.

Via the MCP server, TRACE connects to Claude Code, Cursor, and Kiro equally. The AI tool calls trace_impact before modifying files and trace_check after changes, regardless of which AI tool is making the calls.

The complete stack

┌─────────────────────────────────────┐
│  CLAUDE.md / Cursor Rules / Kiro    │  ← Input steering
│  "How should the AI behave?"        │     (tool-specific)
├─────────────────────────────────────┤
│  TRACE (.trace/ + trace.yaml)       │  ← Output verification
│  "Is the AI's work complete?"       │     (tool-agnostic)
├─────────────────────────────────────┤
│  MCP Server (trace-mcp)             │  ← Connection layer
│  AI calls TRACE automatically       │     (works with any MCP client)
├─────────────────────────────────────┤
│  Pre-commit hook                    │  ← Hard enforcement
│  Blocks incoherent commits          │     (works with any git client)
└─────────────────────────────────────┘

Every layer addresses a different failure mode. Steering prevents bad input. TRACE catches bad output. The MCP server makes it autonomous. The hook makes it mandatory.

You wouldn't argue that a good steering wheel means you don't need a seatbelt. They work at different layers. Use both.