Air traffic control for AI coding

Git Was Built for Humans

Git tracks snapshots and diffs. AI agents also need intent binding, policy gates, durable findings, and semantic impact analysis.

  • Git remains the source transport.
  • Nool adds semantic governance above Git.
  • Agents need durable reasoning, not only file history.

Git is still the right substrate for source transport, branching, hosting, and collaboration. The problem is not that Git is bad. The problem is that AI coding agents operate at a speed and scope Git was not designed to govern.

Git records snapshots and diffs. It does not know the agent's declared intent. It does not know whether a change touched files outside the task. It does not preserve the reasoning that made a risky change acceptable.

flowchart LR
  A[AI agent edits code] --> B[Git diff]
  B --> C[What changed]
  A --> D[Nool proposal]
  D --> E[Why it changed]
  D --> F[Blast radius]
  D --> G[Findings]
  D --> H[Release readiness]

Nool adds a layer above Git. Start with nool status --compact to inspect repository state. Use nool task list and nool task pick to bind work to a task. Use nool announce intent to make the work boundary visible. After implementation, use nool debug blast-radius and nool propose --path <file> --intent "..." to create a governed transition. Use nool solidify to seal accepted work.

For release readiness, nool doctor --compact checks semantic and filesystem health. If the repository has only filesystem questions, nool doctor --fs-only --compact isolates that surface. If semantic state is the concern, nool doctor --semantic-only --compact keeps the signal tight.

This is not a Git replacement story. It is a division of labor. Git moves code. Nool explains and governs code evolution. AI agents need both, because a clean commit is not the same thing as a safe transition.

That division matters for adoption. Teams do not need to abandon GitHub, CI, branch protection, or existing release habits. They add Nool where Git is intentionally silent: task intent, thread context, agent findings, semantic impact, and release-readiness state. The result is still compatible with human review, but the review starts with more than a patch file.

In practice, this keeps the social contract of Git while adding the operational contract agents need. Humans still approve. Agents just bring better evidence.

That evidence is the difference.