nazgul

Audit code quality by running parallel checks against a diff or project tree.

Updated Mar 19, 2026
One-click install
npx skills add https://github.com/LarryHsiao/Skadi --skill nazgul
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: nazgul
Source: https://github.com/LarryHsiao/Skadi/tree/main/skills/nazgul
Command: npx skills add https://github.com/LarryHsiao/Skadi --skill nazgul

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Nazgul provides an auditable, non-destructive way to enforce code quality and policy conformance by dispatching multiple checks in parallel against the chosen target (diff or project) and summarizing results in a single table.

Core Features & Use Cases

  • Parallel evaluation of checks defined in checks/ (or project-local overrides) for consistent governance.
  • Supports diff scope (uncommitted changes, specific commits, or ranges) and project scope (project tree) with deterministic results.
  • Returns a concise table of per-check verdicts (pass | fail | n/a) and enforces auditing without making changes, commits, or file issues.

Quick Start

Invoke /nazgul to start the audit on the current target.

Frequently Asked Questions about nazgul

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I audit code quality checks in parallel against a project diff?

To audit code quality in parallel, define checks with frontmatter fields in a checks/ directory and execute them against the diff scope. Nazgul dispatches all checks simultaneously and aggregates pass, fail, or n/a verdicts into a single summary table.

Can I enforce governance policies without modifying files or committing changes?

Yes, you can enforce governance policies non-destructively by running project audits. The system evaluates checks against the project tree or diff and returns verdicts without performing changes, commits, or filing issues.

What is the best way to run multiple code quality checks on uncommitted changes?

The best way to run multiple code quality checks on uncommitted changes is using the diff scope. This evaluates all defined checks concurrently against the current diff and returns a concise table of pass, fail, or n/a results.

How do parallel code audits work with custom check definitions?

Parallel code audits work by dispatching custom check definitions simultaneously. Each check requires specific frontmatter fields including name, scope, agent, and autofix, ensuring deterministic execution and aggregated verdict reporting.

Does the project audit tool support evaluating specific commit ranges?

Yes, the project audit tool supports evaluating specific commit ranges through the diff scope. You can target uncommitted changes, specific commits, or commit ranges, executing all checks in parallel for consistent governance.

What are the limitations of using non-destructive code quality audits?

A key limitation of non-destructive code quality audits is that they never perform changes, commits, or file issues. The system strictly evaluates and aggregates pass, fail, or n/a verdicts into a table without modifying the project tree.