Claude Code Kit

An unsupervised AI agent will eventually skip a safety check under pressure, and nothing alarms when it does.

AI coding agents are fast. They are also optimistic: given enough pressure, a session will reach for --no-verify, skip documentation updates, or silently re-introduce a pattern that was removed on purpose. Under deadline stress, the agent force-pushes past a failing test, commits without updating docs, or brings back a deleted pattern. None of these failures are loud. They accumulate across sessions until the codebase is inconsistent or a secret lands in git history.

The standard answer ("write better prompts") doesn't hold across sessions, across models, or under deadline pressure. Rules in a chat window evaporate. Rules enforced by the toolchain do not.

A drop-in governance layer that forces every commit through an AI reviewer and six automated quality gates, installed in one command.

You get three things a buyer cares about. Auditability: every commit is reviewed for style, risk, and secrets before it lands. Recoverability: hard hooks physically block force-push and history rewrites, and the agent cannot bypass them even if told to. Consistency: docs freshness, link integrity, and markdown budgets are checked automatically, every time.

The kit installs under a namespaced folder (.claude/dprvda-kit/) so it cannot collide with other tooling. Root files required by external tools (CLAUDE.md, .pre-commit-config.yaml) are placed at the repo root only. An existing CLAUDE.md is never overwritten. It is written alongside for manual merge.

Three enforcement layers run on every commit, and the agent cannot opt out of any of them.

Claude Code hooks fire before any Bash tool call. block-dangerous-git.py physically prevents 11 dangerous git patterns (force-push, reset --hard, clean -f, history rewrites) at the system level. The model cannot bypass them even if instructed to. check-script-launch.py runs the AI judge against a script before it executes. remind-claude-md.py re-injects the rules file on every commit so a compacted session cannot lose project constraints.

Pre-commit gates run through a two-phase dispatcher. Phase 1 runs serially and is fail-fast: the AI judge (critic_llm) sends each staged source file to an OpenAI-compatible endpoint (defaults to DeepSeek), caches verdicts by SHA-256 content hash so unchanged files are never re-reviewed, and prepends a structured LLM_REVIEW_BLOCK comment directly into the file when severity is warn or block. Phase 2 runs in parallel: check_links, check_doc_freshness, check_md_size, and check_secrets execute concurrently, with total hook time equal to phase 1 plus the slowest phase 2 gate. Six gates in total, all blocking by default.

Conventions layer: a short CLAUDE.md rules file refreshed on every commit, plus 9 reusable workflow skills (handoff, tdd, grill-me, caveman, to-issues, zoom-out, audit-structure, compact-docs, write-a-skill) covering the full arc of an AI-driven development session. Language packs (Rust: cargo-audit, cargo-vet, binary-secrets, Python: ruff) are opt-in flags at install time.

Unchanged files are never re-reviewed, and no API key is required to start.

The AI judge caches each verdict by content hash, so commit-hook time stays flat as your codebase grows. The judge is deliberately soft: if LLM_JUDGE_API_KEY is absent or the endpoint is unreachable, the gate exits 0 and the commit proceeds, safe to adopt with zero cost. Everything installs under the namespaced folder, so it never collides with your existing tools. A seeds/ folder provides copy-paste starting points for the user's global ~/.claude/CLAUDE.md, and 286 total files ship in the kit covering template, packs, seeds, and installer.

Born from a real production codebase where AI was the primary developer across hundreds of commits.

The kit was extracted and generalized from a single-developer codebase where every failure mode it guards against (force-push under pressure, doc drift, secret leak) actually happened and was fixed by this exact discipline. Each gate targets a failure that occurred in production, not a failure imagined in a design doc. The 6,842 lines of Python powering the gates, hooks, installer, and context injector carry those lessons in concrete, auditable form. It installs with one command, runs on Python 3.9 and git, and requires no permanent dependency on the kit itself.