Git hooks and Claude Code hooks for automated workflows.
A Claude Code hook pack that caps response length by rule rather than by prompt — 25-word sentences, 200-word replies. A stop hook re-fires whenever the model drifts back into verbosity, and a filter strips load-bearing filler words drawn from your own transcript fingerprints. For people who find output-style instructions get ignored after a few turns.
A set of executable enforcement gates that stop a coding agent before it can break production. Each hook fails closed — if the check cannot run, the action is denied — and every rule was added in response to an actual incident rather than a hypothetical. A practical starting point for hardening agent permissions.
A Claude Code plugin that hard-blocks any dependency addition, upgrade, or downgrade until the agent records a fresh version check with a source citation. It targets the specific failure mode where a model invents a package version from stale training data. Supports npm, pip, Poetry/uv, Cargo, and NuGet.
Pairs an output style with a Stop hook so Claude writes up its work for someone who wasn't in the room, using the specific vocabulary of what it actually did. Counters the generic 'I updated the file' summaries that tell a reviewer nothing. Useful when handing sessions off or reviewing agent work asynchronously.
Chains Claude Code sessions via a Stop hook so the agent keeps working unattended toward a tested MVP instead of halting when a turn ends. The tested-build gate is what keeps an overnight run from producing a large pile of broken code. For anyone who wants long autonomous runs without babysitting the terminal.
A waybar module showing live Claude Code session status (working, waiting, idle), fed by Claude Code hooks. Realtime, multi-session aware, and dependency-free. A clean example of using hooks to drive external UI.
A stop hook that fires the moment Claude decides it is done, refuses the stop, and injects a conciseness prompt just in time before the final recap is written. The author's argument is that instructions parked in CLAUDE.md or the system prompt decay over a long session, while a just-in-time injection lands exactly when the verbose summary would otherwise be produced. A practical pattern for anyone fighting unreadable model recaps.
This plugin wraps cottage, a git-based secrets manager, so decrypted secrets in your repo stay invisible to Claude Code. Hooks clean up decrypted material both at session start and on every user prompt, which the author found necessary because secrets decrypted in another terminal mid-session were otherwise still visible. A subcommand installs cottage from the right repository for your environment.
Sits between the agent and the system, intercepting tool calls to block dangerous commands and audit everything that runs. Pitched squarely at the 'agent deleted production' scenario. Worth a look if you run agents with broad shell access.
A Claude Code plugin where a stated test result must actually reproduce, a fabricated import never reaches disk, and every command's real output is recorded. No subagents, active immediately on install. Directly targets the 'the agent said tests pass' trust problem at the hook layer.
Maps Claude Code states — idle, thinking, using a tool, waiting on you, errored — onto Govee smart lights. A glanceable way to know when a long session needs input without watching the terminal. Frivolous and genuinely useful in equal measure.
An MIT-licensed hook kit that blocks Claude Code from reading, echoing, or committing secrets while running in auto-accept mode. The author frames it honestly as a seatbelt rather than a vault: it turns accidental prod-secret reads into something you must explicitly confirm.
Bridges Claude Code lifecycle events — task complete, waiting for input, requesting authorization — to native Windows Toast notifications using the ntfy protocol. Because it rides ntfy, iPhone delivery works with no public IP or port forwarding.
Surfaces Claude Code events as native Windows toast notifications so you stop missing task-completion and permission-request prompts. Useful when Claude Code runs in a background terminal while you work elsewhere.
Sends VS Code notifications for Codex and Claude Code completions through Feishu, with local alerts as a fallback, secure hook handling, retries, and an offline queue.
After finding that Claude Code mostly ignored a six-tool MCP server for codebase context and fell back on grep, the author switched to hooks instead. A SessionStart hook injects a codebase map into the prompt before you type anything, and it re-syncs in the background after every edit. graft init wires this up automatically — context arrives whether or not the model thinks to ask for it.
A pixel-art familiar that sits in a screen corner and mirrors what Claude Code is doing, wired up through hooks. It exists mainly to catch stalled permission prompts: you get a native OS notification and a speech bubble, and the mascot starts shaking if you ignore it for 30 seconds. Ambient status includes one card per session, tool-specific faces, context ring, model tag, usage bars, and subagent badges.
A small Claude Code plugin marketplace with two focused entries: hooks that enforce jj (Jujutsu) version control conventions, and hooks that wire agent work into beads task tracking. Narrow by design — useful if you already use either tool and want the agent to respect it.
Matches project knowledge — rules, conventions, domain notes — against the prompt, the file being edited, or the tool being invoked, then injects just that slice at the moment it is needed. Keeps CLAUDE.md from ballooning into an always-loaded encyclopedia that eats context all session.
A Claude Code plugin that records coding mistakes as they happen and injects the relevant lesson back into context right before a tool call that might repeat it. The point is preventing the same error twice without stuffing everything into CLAUDE.md. Retrieval is scoped to the pending action rather than dumped wholesale.
A Claude Code plugin that checks cryptographic signatures on skills and instruction files before their contents reach model context. Targets the supply-chain risk of installing third-party skills that can inject arbitrary instructions. Verification happens at load time, not install time.
A Stop hook that treats the final assistant message as a set of hypotheses and re-runs each one fresh — tests actually execute, files are actually checked, endpoints are actually hit. Motivated by research finding that 75.8% of failing agent runs that graded themselves still claimed success, and that LLM judges catch this at near coin-flip rates. Blocks completion when a claim does not hold.
Local-first gates that block three specific agent failure modes: unverified completion claims, blind retry loops, and reviews performed against stale state. Works across Claude Code, Codex, and Hermes. Runs entirely on your machine.
A PreToolUse hook for Claude Code and Codex CLI that outright denies dangerous shell commands, prompts for confirmation on risky ones, and audits every call. Rules are deterministic with no LLM in the decision path, so behavior is predictable and cheap. Ideal for unattended or automated sessions.
A state machine that records a per-commit review verdict and refuses the push until that commit has actually been reviewed. Your own coding agent does the reviewing; the tool tracks and enforces the outcome. It closes the common failure mode where an agent commits and pushes work nobody verified.
Attacks agent token cost from four directions: compresses shell command output before it reaches context, blocks calls it predicts will be expensive, prices the running session live, and recovers sessions whose prompt cache expired. Built on Bun for Claude Code.
Three zero-dependency hooks that stop secrets from being written into source, require real verification before config changes land, and nudge compaction at safe boundaries instead of mid-task. Small and readable enough to audit before installing.
A permission gate for Claude in Chrome built as an escalating action ladder, designed so containment does not depend on correctly detecting an attack. That framing matters for prompt injection, where detection is the part that keeps failing.
Requires the agent to log a mistake before fixing it, enforced mechanically by a git hook rather than by asking nicely. Three files plus tooling and CI, zero dependencies. The mechanical enforcement is what makes it stick where a CLAUDE.md instruction would not.
pf-handoff tracks context-window usage, fires threshold reminders as you approach the limit, and writes HANDOFF state files so work survives compaction. After a compaction it auto-picks-up from the handoff file instead of losing the thread. Ships as rules plus skills plus hooks, with English and Russian docs.
A thread prompted by Claude Code flagging that a read .env file had entered context and been sent to Anthropic. The discussion moves past TLS-in-transit concerns to the real risks: plaintext local transcripts, re-emission of secrets into committed files or ticket comments, and MCP servers receiving whatever the model puts in context. Commenters share hook and permission setups that block secrets files outright.
A PreToolUse gated execution policy layer sitting in front of Bash and PowerShell, making every command recordable and requiring each one to connect to the prior evidence chain. Built to keep an agent coherent across macOS, Windows, Linux, and different shells without a database or external orchestration library.
Gates for Claude Code built on the premise that exit code 0 does not mean a step is done. Covers both software builds and finished video output, and is designed to fail rather than optimistically report success.
A regression-testing CI gate for skills that edit themselves: golden-transcript record and replay against a skill's declared and inferred capability surface, with no hosted infrastructure. Published on both npm and PyPI as evolveguard-cli. A genuinely under-served problem as SKILL.md and MEMORY.md files start rewriting themselves.
A Claude Code plugin that cuts context tokens and model cost three ways: hooks that truncate tool output, a workflow where Opus plans and Sonnet or Haiku implement, and guards for workflow hygiene. Practical for anyone hitting limits on large repositories.
Actively monitors and enforces CLAUDE.md, skills, instructions, MCP configuration, guards, memory files, system prompts, and project docs rather than hoping the model reads them. It learns your preferences over time and bans patterns you have rejected from future generations.
An always-on-top bar showing what Claude Code is doing and, more usefully, when it has gone quiet waiting on a permission prompt. Built on the hook system rather than screen scraping, so status is structural; runs local-only with no API key.
The author's working Claude Code setup for running 10+ personal apps without reviewing every diff: hooks, subagents and commands, including two blocking hooks that stop bad changes rather than just warning about them. MIT licensed.
Running several sessions in one repo means agents overwrite each other's files and get confused about where changes came from. Subagents don't help across separate sessions and markdown-based messaging is brittle, so the author built inter-session messaging on Claude Code hooks - actions that fire on events like turn end.
After a year of focusing on prompts and skills, the author found hooks to be the feature that actually changed their setup: scripts and CPU time are cheap while tokens are expensive, so a deterministic script bolted to a workflow stage beats asking the model to remember to trigger a skill. Includes concrete uses like lint runs and data-file updates.
A tiny desktop companion that perches on your screen edge and reacts to Claude Code hook events. It is a Swift binary under half a megabyte with no Electron runtime, so it costs almost nothing to leave running. A lightweight take on ambient session-status indicators.
A Claude Code hook that holds a paragraph from your CLAUDE.md until the Write or Edit it actually applies to, then delivers it once, gated on path and content. Solves the problem of guidance that gets stated at session start and forgotten by the time it matters.
A Claude Code session-start hook that opens with a summary of your previous state and then lets you choose how to resume. The name is Sheng for what's up.
Catches AI writing tells and undefined jargon before they land in a commit, doc, or issue, with adapters for Claude Code, pre-commit, and CI. Enforcement at three layers means it actually holds.
After CLAUDE.md, memory entries and output-style config all failed to stop Claude's 'clever' metaphors, the author moved the instruction into a UserPromptSubmit hook and found it held. Discusses the per-turn token cost and how to keep the injected reminder short. A practical answer to instructions that quietly stop being followed.
Lets each agent call dibs on files with an expiry, and enforces those claims through hooks so two parallel sessions don't stomp the same file. Also records git-native lessons from conflicts. One binary, no server, no database.
A lightweight task framework for Claude Code that persists tasks, injects relevant memory back into the session, and writes structured decision logs - all exposed through MCP tools and Claude hooks. Aimed at people who want tracking without adopting a heavy project system.
Intercepts Claude Code before it writes API keys, credentials, or private keys to a file - the block happens before anything touches disk or git history, rather than scanning after the fact. Fully local, zero dependencies, zero telemetry.
A hook that posts a Claude resume-session command onto GitHub pull requests, so you can pick a session back up from the PR rather than hunting for the right local session ID.
Resolves what a tool call will actually touch before it runs and blocks it when the blast radius exceeds a ceiling you declared up front. Prevents the class of incident where an agent deletes or rewrites far more than intended. A stronger guarantee than per-call approval prompts.
A plugin that briefs every new session on the surrounding state: which worktree another agent is editing, uncommitted changes, existing PRs, failing CI, occupied dev ports, and what production is actually running. Addresses the hygiene that slips when several sessions run at once. Written up as a response to specific repeated failures.
Six dependency-free Claude Code hooks that deny placeholder or stub code and dangerous commands, and block a session from ending on an unverified 'done' claim. Enforcement happens at the harness level rather than relying on prompt instructions, making the guardrails harder for the model to talk its way around.
A single development doctrine compiled into hook-based enforcement for both Claude Code and Codex, installed with one command via npx voidharness init. Free, account-free, and MIT licensed, aiming to make agent behavior standards concrete and enforced rather than just written guidance.
Turns every Claude Code session into a queryable local SQLite record using only native primitives (hooks, subagents, skills, MCP), then reads that record back to predict your next dispatch, recall past incidents, attribute cost, and gate commits.
Blocks destructive tool calls from AI agents before they execute, and signs every decision into a hash-chained, verifiable record using an open-source verification tool.
warrant-mcp lets you write rules for your AI agent once in plain English, then deterministically checks every tool call against those rules and uses a Claude Code hook to block calls that violate them. Useful for teams wanting guardrails on what an agent is allowed to do without writing custom validation code.
A developer building the graft codebase-mapping tool found Claude Code often silently ignores custom MCP tools in favor of grep, since nothing tells the model when a tool beats built-ins. The fix: use SessionStart/UserPromptSubmit hooks to inject context directly into stdout, bypassing the tool-selection problem entirely — a reusable technique for any MCP server author.
A local-first policy engine, with no LLM in the loop, that enforces source choice and proof-of-use for coding agents through Claude Code hooks — including routing to specific MCP tools — so agents can't skip required checks.
A local-first SIEM-style flight recorder for AI coding agents that produces a MITRE-mapped audit trail, detects suspicious action sequences, and flags data-loss-prevention concerns.
A write-up on using Claude Code's Stop hook — the point where the agent hands control back with nothing waiting on the result — to rebuild a repo's structural call/import graph in the background. The hook spawns a detached process and returns immediately, so the graph refreshes for free via tree-sitter parsing with no added prompt latency and no model call.
If a project's .env defines ANTHROPIC_API_KEY, Claude Code's built-in security-review plugin uses that key instead of your subscription for its automatic Opus-powered review on every commit/push, billing pay-as-you-go credits with no indication in chat. Fix by renaming the env var or disabling the review (ENABLE_COMMIT_REVIEW=0 / SECURITY_GUIDANCE_DISABLE=1).
A hooks-based router that classifies each prompt and injects only the matching guidance for that discipline, adding zero token overhead on plain conversational turns. Claims are benchmarked, including ones that failed, rather than just asserted.
A Claude Code plugin that fits the model, effort level, and context budget to each task automatically, aiming for fewer tokens at the same quality. Uses a deterministic policy kernel implemented in hooks, and every reported number is measured rather than estimated.
Adds enforcement, memory, and parallel-session coordination to Claude Code, centered on a Stop gate that actually runs your test suite before accepting a task as complete — so completion is judged on evidence rather than the model's own claim that it's done.
A Claude Code plugin that injects relevant coding, security, and scientific-computing rules — 195 rules across 28 domains, including test-quality rules derived from mutation-testing its own suite — into every prompt. Also ships a plan-approval gate, access guard, per-project memory, session handoffs, and red/blue-team review agents.
A Claude Code plugin plus shell helpers that manage large reads, noisy tool output, and redaction, producing artifacts and measured token/cost evidence for how much context each operation actually consumed.
A Rust daemon plus Tauri app and Claude Code plugin for supervising unattended agent runs: it blocks forbidden tool calls before they execute, gates 'done' on actually running tests, checkpoints work to git, caps spend, and produces a morning report where every line is sourced back to evidence. Local-first with no telemetry.
A three-layer Claude Code hook setup for building a daily dev-journal habit: SessionStart injects the journaling routine, UserPromptSubmit nudges you when the log goes stale, and Stop blocks the end of a turn once per day until today's entry is updated. PowerShell-first and fail-open by design.
A Claude Code hook (Session Token Killer) that clamps oversized Read tool results down to line-numbered outlines instead of dumping the full file into context. The author measured that 85% of their oversized agent context came from file reads alone; a companion tool, RTK, targets token waste per command instead of per session.
A Claude Code plugin that adds a "Mixture-of-Experts" routing hook, computing a divergence gauge from nine tracked lens activities. The gauge's properties (positivity, boundedness, non-constancy) are backed by machine-checked Lean 4 theorems, and install/uninstall is asserted byte-identical with no network calls.
A supervision layer for coding agents, written in C++, that gates every tool call in about 2.3ms and chains each event into a local, tamper-evident ledger. Notably, when it repairs a broken build it hash-locks the project's test files first, so a "green" bought by editing a test is refused instead of accepted.
Pushary adds human-in-the-loop gating to AI coding agents via push notifications you can approve straight from your phone. It ships as agent hooks/skills for Claude Code, Claude Cowork, Codex, Cursor, and Gemini, with npm and PyPI packages backing the integration.
Enforces user-authored playbooks across Claude Code, Codex, and Gemini CLI, with verifiable evidence gates and auditable readiness reports — for teams that want agent output checked against a defined bar before it ships.
Puts Claude Code and Codex sessions under a declared network policy, matching every outbound connection on both destination host and the calling binary, with a Slack front end for visibility and control.
Gives Claude Code native macOS dialog boxes for asking questions, confirming actions, and collecting input, instead of everything staying buried in the terminal.
Captures agent actions, developer identity, and sensitive-data access locally and privacy-safely, with optional branch-level risk feedback — aimed at teams that need an audit trail for AI-written code, not just a debug log.
A repository template for making AI decisions auditable — rubrics, hooks, golden test sets, and a precedent-based ensemble pipeline, plus a real-time monitoring dashboard for reviewing what the agent decided and why.
An encrypted vault for secrets with scoped approvals and audit logs, aimed at stopping AI coding agents from leaking credentials into logs, commits, or model context.
Sends a Slack notification only when a Claude Code agent has truly finished, filtering out false-positive completion signals. Aimed at reducing notification noise for people monitoring long-running agent sessions.
A Stop hook that detects when Claude Code's end_turn event silently fails (invoke-leak or empty end_turn) and automatically injects a retry. Addresses a known failure mode where sessions appear to finish but haven't actually completed.
Your agent reads CLAUDE.md and other rule files — ratchet verifies whether it actually followed them, closing the gap between advisory instructions and enforced behavior.
Catches commit messages that claim '47 tests passing' when the real pytest run says otherwise. Available as a pre-commit hook, a Claude Code hook, or a standalone CLI.
A PostToolUse Prettier hook rewrites the file after Claude writes it, so the next edit gets refused as stale and Claude re-reads the whole file — paying for one edit twice in context, not milliseconds. The fix: format at the boundary (one bulk pass plus a pre-push hook) rather than continuously, unless your repo is already fully formatted and diffs stay small.
After a Mac restart, Warp and Superset reopen panes as idle empty shells — pane-resume resumes the actual Claude Code, Codex, or Gemini conversation each pane had. Opt-in zsh hook, macOS only.
Six native Claude Code subagents paired with seven enforcement hooks, designed to make the parent-side contract structural — enforced by hooks — rather than merely advisory instructions in CLAUDE.md.
A hook-based bridge that adds vision capability to Claude Code when running text-only models like DeepSeek, using a permanent cache and an Action Guide. Useful for setups where the coding backend has no native image understanding but the workflow still needs to inspect screenshots or diagrams.
A tool that keeps AI coding agents grounded in a project's actual architecture over long-running tasks: baseline-first, evidence-verified, and checked for drift, to prevent agents from silently deviating from an established design.
Policy guardrails for Claude Code, Codex, and Cursor that check every tool call locally against a policy before it's allowed to run, rather than relying on the model to self-restrict.
A library that wraps agent tools with undo handlers so that if one step in a chain fails, every already-succeeded step rolls back automatically in reverse order, like a database transaction. Includes adapters for the Vercel AI SDK and Mastra, plus an MCP server so Claude Code can trigger rollbacks through plain tool calls.
Adds native tmux status indicators showing when a Codex or Claude Code session needs approval, is running, or has finished, useful for anyone managing several agent sessions across tmux panes.
Audits CLAUDE.md, AGENTS.md, .cursorrules, GEMINI.md, and 18+ other agent memory files against the live repo, flagging typed claims that no longer hold, citing the commits that broke them, and applying a half-life decay score with a token meter. Fixes are approve-only, and it works with any agent.
Verifies where MCP servers and Agent Skills actually come from, observes what they do at runtime, and enforces user-defined policy over both, managed centrally across hosts like OpenCode, Claude Code, and Cursor.
A PreToolUse hook on Task that detects self-contained subagent work (research, prose, isolated codegen) and offers to route it to someone else's idle Claude Code session over a network instead of spawning locally. An acceptance judge validates the returned artifact, and any risky or repo-touching work always falls back to running locally. The author reports 2.34M tokens saved across 72 tasks, but notes there aren't yet enough idle 'earner' sessions online to make routing reliable.
Argues that Claude Code's approval system has a structural gap: it judges one bash command at a time, but the model carries everything it read beforehand — including deploy configs and secret references — and the approval prompt never surfaces that history. Points to Gensee Crate, an open-source project wiring read-history into the approval prompt itself so you see what the agent explored before you approve a command.
Sends completion cards to Feishu when a Claude Code, Codex, or other coding-agent session finishes, so you know a long-running task is done without watching the terminal. A narrower, notification-focused entry in the crowded Feishu/Lark integration space.
Plays a distinct sound the moment Claude Code finishes a task, needs input, hits a usage limit, or fails, so you do not have to keep glancing at the terminal. Works on Windows, Linux, and macOS.
Sends desktop notifications for Claude Code showing which conversation replied or is waiting on you, and jumps you straight back into that session. Useful when running several Claude Code conversations in parallel.
A settings.json hook example that injects a writing rule into every turn via UserPromptSubmit, instructing Claude to avoid metaphor and vivid or cryptic phrasing and instead name things by what they literally do. Useful if you find Claude's default response style overly flowery or hard to parse.
A background hook fires after each Claude reply, using Haiku to read the conversation and generate a clear, short session title, re-checking as the topic evolves. Supports optional project prefixes for bucketing sessions and includes a backfill command to retitle existing sessions; works in both the Claude Code CLI and desktop app.
After analyzing Claude Code's own compaction boundary records, this poster built a plugin that recovers dropped detail by returning your own prior turns verbatim (lexical retrieval, not a re-summary) at the compaction boundary for about 700 tokens. It also ships two other hooks: declining re-reads of unchanged files (22.4% of disk reads in their corpus) and redirecting oversized skill loads (one skill cost 325,000 tokens, 75% of a session) to just the relevant section.
A lightweight hook that plays animal sounds to notify you of Claude Code or Codex session events, instead of a plain beep or system notification. A small, fun quality-of-life hook for anyone running long unattended sessions.
Uses raw HID commands on stock firmware to turn a VIA-compatible RGB keyboard's backlight into a status indicator for Claude Code or Codex, showing approval-waiting, done, or error states at a glance. No custom firmware flash required.
A cross-platform watchdog that monitors Claude Code and Codex session state, detects interruptions, and automatically resumes the session. Aimed at unattended long-running agent work where a stall would otherwise go unnoticed.
A PreToolUse hook that compresses shell command outputs before they hit the model context, reducing token usage across Claude Code, Gemini CLI, and Qwen Code. Includes a TUI dashboard tracking estimated USD savings from the compression.
A writeup on setting up hooks after months of avoiding them, covering PreToolUse (blocks tool calls before they run, with a reason fed back into Claude's context so it can self-correct) and Stop hooks (runs typecheck before allowing session handoff). Includes concrete examples for secret-scanning, destructive-command blocking, package-manager enforcement, and a warning that unconditional Stop-hook blocking loops forever.
A dependency-free (stdlib Python) tool that catches credentials pasted into an AI coding agent's chat input before they reach the model, filing them locally and recording their origin. Works with Claude Code, Codex, and Gemini CLI — distinct from tool-call-blocking approaches in that it screens user-pasted chat input rather than commands or file writes.
Engineering guardrails that audit an agent's instructions, review the scope of its changes, record proof of execution, and explain how a repository evolved over time.
Keeps AI coding agents inside verified requirements and approved scope, with traceable evidence and human-controlled release gates before anything ships.
Runs reconciliation, consistency, and Excel-integrity checks on AI-generated analysis, stopping the line when the numbers don't add up rather than trusting the model's own claims.
Self-verification hooks plus a reasoning skill that check the agent's own claims against your prompts, your tests, parked work, and memory. Fail-silent, stdlib-only, no network calls.
A Java annotation processor that acts as AI guardrails for code-generation tools like Cursor, Claude, Gemini, and Codex CLI, letting developers protect critical code and steer AI implementations through simple annotations.
A tool-agnostic rulebook that makes any LLM write real Bärndütsch (Bernese German), plus a Claude Code hook that injects it automatically when your prompt is written in the dialect.
Turns recurring code-review findings into rules that get automatically enforced going forward, instead of the same feedback being repeated every review.
A Claude Code configuration bundling automated pre-commit AI review, merge safety guards, protocol enforcement hooks, and skill-based development workflows.
A governance runtime for AI agents that intercepts actions before they execute, enforces configurable guard policies, requires approvals for risky operations, and produces audit-ready decision trails. Structured oversight for teams that need a paper trail on what an autonomous agent actually did.
Scoped permission allowlists and a protected-branch push guard for Claude Code, Codex, and agy, aimed at developers whose enterprise environment has blocked bypass/dangerous-mode.
Hooks that block destructive commands, keep secrets out of the context window, and carry session state across a compaction event, so a long session doesn't lose track of what it was doing when Claude Code compacts its context.
Local hooks that flag vague or underspecified prompts to an AI agent before they get sent and burn tokens on a doomed attempt.
A tool that detects when a Claude Code session is losing context and nudges Claude to delegate or compact, rather than just displaying a passive dashboard. Addresses a common pain point of long sessions degrading in quality.
A plugin collection adding security checks, cost/usage tracking, and workflow hooks to Claude Code sessions.
A niche Claude Code plugin that automates engineering tasks in Siemens TIA Portal, bringing agentic coding assistance to industrial PLC/automation engineering workflows.
CommitLore stores structured decision records (rejected alternatives, limits, warnings, unverified assumptions) in Git commit trailers and refs/notes, then surfaces them via an MCP tool or PreToolUse hook before Claude edits a path. MIT-licensed, keeps Git as the sole source of truth, and the author transparently walked back an unproven agent-behavior benchmark claim rather than overstating results.
A .claude/ configuration layer with 18 skills, 4 agents, and 8 hooks designed to keep Claude Code's behavior consistent across sessions, on the premise that hooks enforce rules while written instructions merely drift. Hooks block risky commands like rm and git clean, fence each agent to its own directory, keep the main checkout unwritable so code only lands in worktrees, and provide a file-based ask/answer bus between blocked sessions.
Pushes approval-request cards to your phone, watch, or PC via Feishu when Claude Code, Cursor, Codex, or other agents (9 supported) want to take risky actions. Lets you review and approve or deny agent actions remotely instead of staying at your desk.
A collection of Claude Code hooks that intercept and block destructive tool calls at the tool boundary before they can cause harm. Also surfaces silent failures that Claude Code would otherwise ignore. Addresses the problem of agentic coding accidentally deleting or overwriting important files.
A successor to TDD Guard (2k stars, 300k downloads) that enforces Test-Driven Development and other rules across multiple coding agents. Hooks into the agent workflow to enforce step-by-step TDD rather than letting Claude skip the red-green-refactor cycle. Open source, with video walkthrough by Emily Bache.
A hook-based token compressor that intercepts bash command output across 5 AI CLI hosts: Claude Code, Copilot CLI, OpenCode, Gemini CLI, and Codex CLI. Achieves up to 95% compression on bash output with signature mode for code file reads, cross-call deduplication, and a self-teaching protocol. No runtime dependencies.
Drop-in memory layer wired via Claude Code hooks (PostToolUse, UserPromptSubmit, SessionStart/End) that applies the Ebbinghaus forgetting curve: unused memories fade, recalled ones reinforce, and weak matches surface separately with hedging language. Uses ChromaDB + sentence-transformers locally; no external API calls for memory itself.
A curated suite of Claude Code plugins covering session continuity, DevOps/AWS/Terraform, AI/LLM patterns, frontend and UI, and code review. All plugins share a common hook infrastructure via symlinks, so installing multiple plugins avoids duplicate hook wiring. MIT licensed.
ThumbGate is a PreToolUse hook that evaluates the exact arguments of every tool call before execution — not the model summary. Returns allow, block, or require-approval. Gates high-consequence actions like force-pushes, destructive DB ops, credential output, and production deploys. Open-source and MIT licensed.
Adds a 5-question task-start protocol and tiered action gate via a PreToolUse hook in Claude Code. Claude must answer intent-alignment questions before running any tool, and destructive actions are blocked outright before execution. Directly addresses the core safety problem of agents acting before fully understanding the task.
Security tool that detects and stops prompt injection payloads that attempt to write themselves into AI agent config files such as CLAUDE.md or .mcp.json. Targets the persistence class of attack where malicious content survives across sessions by hijacking the agent's own configuration. Essential for anyone running Claude Code against untrusted codebases or external data sources.
A UserPromptSubmit hook that reads Claude Code's local rate_limits data, tracks your token burn rate over the last 45 minutes, and warns or blocks before you start a task you can't finish. Configurable thresholds (warn at 75%, block at 92%), zero dependencies, fully local. Prevents the frustrating scenario of a big refactor dying mid-run due to a rate limit hit.
A single-file install hook providing a deterministic context guard, cache-stable startup packets, durable Obsidian memory integration, and real provider usage measurement. Targets cache efficiency and context stability across sessions.
Watches code edits, infers which test types are needed, and guides test planning through a combination of hooks, an MCP server, and a /tdd skill. Language-agnostic, no telemetry.
A Go tool that reads Claude Code local session transcripts, attributes them to the current branch, and appends a Claude-Cost git trailer to every commit. Enables cost-per-feature analysis with standard git log commands. Single static binary, no telemetry, handles rebase/squash/amend correctly.
Converts referenced PDFs and Office files to Markdown and injects a pointer into Claude Code context. Reports image-only PDFs honestly instead of silently arriving empty. Works on Windows, macOS, and Linux.
Injects a live status line into Claude Code showing the current workflow phase (Plan → Exec → Verify → Done). The model itself updates the status as work progresses.
Analysis of three failure modes from AI-generated code — invisible duplication, complexity accumulation in hotspot files, and missing co-changes — with concrete mitigations. Key technique: inject a code health map via SessionStart hooks naming hotspot files, coverage gaps, and duplication clusters before the agent writes anything.
PR hook that detects UI slop — AI-recognizable UI patterns that degrade product quality — in every pull request before it ships.
Uses git commit trailers as the single source of truth for institutional memory available to AI coding agents. The git history becomes the agent memory store.
My current process is a session wrap hook that summarizes the chat. But I am looking to optimizing my flow? submitted by /u/Unable_Breath_1966 [link] [comments]
Your AI coding assistant's security watchdog. Claude Code hooks that catch supply chain attacks, exposed secrets, and obfuscated commands.
Build Claude Code hooks without the boilerplate. Typed scaffolds for Python and TypeScript.
Anthropic’s #1 hater here - I come in peace! My beloved OpenAI has stabbed us in the back with their epic 5.6 usage rug-pull. Opus 5 looked super solid as a work horse so decided to move one of my ...
https://preview.redd.it/sycx7n6305fh1.png?width=1567&format=png&auto=webp&s=64ebf0cde5bc0bb208abd3fee82fa148713ae6a3 Today they did something new: planned and shipped a whole feature end to end. 🚀 ...
Local context-compression layer for agent tool outputs. Claude Code PostToolUse hook or generic filter, single Go binary.
Industry-best agent configuration files for Python projects - AGENTS.md, ruff, mypy, pytest, CI, pre-commit hooks, Makefiles — the ultimate coding-agent onboarding kit
Rewrites your Claude Code prompts before the LLM sees them — detects code, question, or text-gen intent, strips noise, adds structure. Runs automatically via a UserPromptSubmit hook, no LLM call ne...
🔊 Free on-device TTS for Claude Code on macOS — spoken response summaries via a Stop hook + Apple's say, with multi-session queueing
Offline PII firewall for AI agents and LLM apps: fast local detection and redaction, Claude Code hook, LiteLLM guardrail. Zero network calls, one dependency.
Track Claude Code sessions across tmux panes and jump to the one that needs you — fzf picker, status-bar badge, and hook-driven inbox-style statuses
I'm a solo founder. My "team" is me plus 3–4 Claude Code sessions running in parallel on the same repo. For the last six months they've all been reading and writing one shared memory file that live...
Fail-closed independent review loop for Claude Code and Codex. Native hooks, six reviewer paths (Codex, Gemini, Claude, OpenCode, OpenRouter, Ollama), LKG policy control plane and local audit trail.
Real-time secret-leak guardrails for AI coding agents (Claude Code, Codex), Git hooks, and CI.
A silent, glanceable status light for AI agents — your Mac's camera LED: on while the agent works, off when it's done. Hooks for Claude Code & Codex
A safety gate that blocks an AI coding agent from finishing a task until the project's own real-app verification passes. Distinguishes passing tests from a feature actually running—bridging the gap between unit test success and observable behavior. Lightweight hook that enforces an evidence-based done criterion.
A safety hook that parses every Bash command Claude Code wants to run and enforces configurable security policies before execution. Lets you block or require approval for dangerous patterns (rm -rf, curl | bash, etc.) without disabling Bash entirely. Configurable policy file makes it adaptable to different project risk levels.
A blog post demonstrating how to use a Claude Code post-tool-use hook to prevent the agent from ever reading environment variables. By intercepting env var access before the model processes the output, the hook closes a potential exfiltration vector where the agent could learn and leak credentials. Practical security hardening with minimal setup.
Compiles your team's coding conventions into native toolchain enforcement—ESLint rules, Clippy lints—so they run deterministically in CI with no LLM cost. The project's own AGENTS.md is executable, making it self-documenting. Bridges the gap between agent-readable conventions and machine-enforceable rules.
Deterministic, offline security layer that classifies AI agent tool calls into green/yellow/red/black risk tiers and blocks secret exfiltration and prompt injection. Runs as a Claude Code hook or MCP proxy. Includes a tamper-evident audit log and an open benchmark (arena) for comparing agent firewalls.
This is the moment Director exists for. You /clear a degraded session, or you open a repo you parked: $ claude > where were we? ▸ Director: acme-api-main-7c21e9d4 · 1 open-item(s) ## open-items 01K...
State-and-hook guardrails for Claude Code: finish the job without skipping steps or cutting corners — enforced by hooks. bash + jq, MIT.
A VS Code-style desktop app for running many Claude Code CLI sessions as browser-style tabs, with live per-session status driven by Claude Code's own lifecycle hooks.
Sits between Claude Code and its tools, evaluating each tool call against configurable permission rules before allowing it to proceed. Lets you define fine-grained policies over which tools can be called and under what conditions, adding a human-auditable layer of control without disabling tools entirely.
devguard adds a lightweight memory and self-correction layer to Claude Code via hooks. It records decisions made per feature and uses hook callbacks to nudge the agent back on track when it begins looping or contradicting past choices. Local-only, zero external dependencies, no configuration required.
A dual-agent commit gate where Claude builds and Codex reviews; no commit passes without review, approval, and documented evidence. Prevents unreviewed AI-generated code from merging. Complements standard git hooks with cross-agent verification.
Warns an AI coding agent before it edits code that exists specifically to fix a bug. Implements the Chesterton's Fence principle: don't remove something until you understand why it's there. Prevents agents from silently undoing intentional bug-fix patterns.
A shipping gate for Claude Code that runs tests, code review, security checks, and secret scanning before any push to a protected branch — and unlike git hooks, it cannot be bypassed with --no-verify. Triggered by saying 'ship it'. Forces all quality checks to pass before pushing.
A pre-merge quality gate for UI screens that checks contrast ratios, touch target sizes, keyboard navigation paths, and responsive breakpoints. Runs as part of the Claude Code workflow before any UI screen is merged. Part of the humbleteam design skill collection.
Wires Claude Code hooks to a Tuya/Halonix smart bulb: amber when a tool runs, red pulse when approval is needed, green when idle. Control path is a hook firing a Python script over local LAN — no cloud required. The red pulse makes long-running sessions self-announcing.
A practical setup using macOS immutable flags to lock critical files (CLAUDE.md, .zshrc, SSH config) so Claude Code cannot accidentally modify them, combined with a trash alias that intercepts rm commands. Includes a flock script for toggling protection and CLAUDE.md instructions to use trash instead of rm.
Open-sourced governance setup using PreToolUse hooks that exit 2 when a rule is broken, preventing the tool call from running and feeding stderr back to the model as correction. Includes a SessionStart hook that loads relevant rules by index, a UserPromptSubmit intent hook, and a Stop hook write-back gate to prevent ending sessions without updating trackers.
Teaches coding agents to keep agent memory, internal instructions, temporary artifacts, and unwanted attribution out of human-owned repositories. Addresses the common problem of AI agents polluting git history with their own scaffolding and internal state files.
MV3 browser extension that lets you mark elements on any page and send structured feedback (selector, computed CSS, screenshot) directly to your Claude Code agent via a local inbox. Bridges the gap between visual UI review and the agent that needs to fix the code.
A flight recorder and firewall for AI agents that records every tool call, tracks lethal-trifecta taint (prompt injection paths) across a session, and blocks the prompt-injection exfiltration path. Zero dependencies and cross-harness. Essential security layer for agentic setups handling sensitive data.
Runtime failure resolution for coding agents — hooks into Claude Code, Codex, and popular harnesses to catch infinite loops, dangerous actions, and secret leaks before they become incidents. Zero latency because it runs locally. Provides a safety net for unattended agent sessions.
A fail-closed Bash safety gate that intercepts and validates shell commands before Claude Code or Codex can execute them. Blocks dangerous commands while allowing safe ones through with no configuration needed for common cases. Provides a hard safety boundary for unattended agent sessions.
Detects behavioral drift from your Claude output contract and steers the model back — deterministic, dependency-free, with 100% accuracy on a 170-session test corpus. Useful for production workflows where Claude output needs to stay within a defined format or behavior envelope over many turns.
Thoughtful analysis of the gap between hook-level permission grants and the actual session-level impact of combined agent actions. Covers CLAUDE.md write-back risks, config drift, and the difference between blocking one tool call and auditing an entire 400-action session. Recommends per-session user account isolation and keeping secrets out of agent-readable paths.
An extensive practical writeup overhauling a Claude Code hook setup: AI-powered UserPromptSubmit hook for skill activation, a guard hook that enforces skill usage, vector search for auto-injecting dev docs, and a setup wizard that verifies its own work. Includes honest benchmark results — 93% precision on authored prompts, 27% on real session history — with a detailed analysis of why intent matching is hard.
A hook-based integration that routes multiple Claude Code sessions to separate Discord channels, automatically creating categories and channels named after the project directory. Mirrors the conversation bidirectionally so you can respond from Discord and have input fed back to the agent. Useful for monitoring parallel sessions across projects from a phone or secondary screen.
A Claude Code hook setup that keeps VSCode tab titles updated with the agent's current state (investigating/fixing/verifying/blocked/done). Uses CLAUDE_CODE_DISABLE_TERMINAL_TITLE, a closed list of states in a config file, and a Stop hook that re-asserts the title after every turn.
Takes CLAUDE.md rules and compiles them into hooks that fire at the exact moment each rule is relevant. Instead of injecting all rules into every session, each rule activates only on the trigger that makes it meaningful.
Generates AGENTS.md, per-folder CLAUDE.md files, and Claude Code hooks from your codebase to enforce architecture rules. Agents cannot deviate from the rules because the rules are wired into their hooks and context files at the folder level.
Explores using Claude Code hooks to intercept files containing secrets before they reach the agent context. A hook catches a fake API key in a submitted file and blocks the handoff, acting as an additional guard layer alongside permissions and ignore rules.
Enforces a single policy across Claude Code, Cursor, Copilot, and any MCP agent using git-hook and CI gates, with an append-only audit trail. Self-hosted compliance for teams that need consistent AI governance across their entire toolchain.
sheepdog is a PreToolUse hook that blocks Edit/Write on governed paths unless the matching skill was invoked in the preceding minutes. Configured via a project-level config.json mapping paths to skills — if Claude tries to touch a governed file without reading the skill first, it gets an error. Plain bash + jq, no build step required.
Casper is a git hook system for Claude Code that attaches evidence requirements to the agent's claims of completion. When the agent says "done," Casper requires a claim-evidence pair before proceeding — logged in a verdict ledger. A lightweight accountability layer for unattended AI coding sessions.
An empirical study across 140 Codex CLI runs (901.6M tokens) found that return payloads eligible for token-saving hooks represent only 0.16% of complete-task tokens, yielding at most ~1% modeled cost savings even with perfect 90% compression. A matched comparison showed no clear plugin effect, with within-arm cost variance of 30-52%. The author recommends measuring trajectory-level cost, cache behavior, and task quality before installing hooks.
A Claude Code toolkit focused on security: its guard hooks intercept agent-driven package install commands and scan them before execution. Prevents Claude Code from silently installing malicious or unintended packages during autonomous sessions. A practical security layer for running Claude Code with broader permissions.
A self-hosted multi-channel notification gateway (Docker + Redis) that fans one message out to ntfy, Telegram, email, Slack, Discord, and WhatsApp via a token-auth API. Ships a Claude Code hook that notifies your phone when Claude finishes a task. The hook integration makes it easy to stay aware of long-running sessions without watching the terminal.
14 auditing healers that detect drift, fix mechanical issues, and prevent recurrence in Claude Code repositories. Acts as a running immune system that keeps the repo healthy without manual intervention.
Validates AI-written tests by gutting each changed function and rerunning only its covering tests — hollow tests that still pass are flagged with exact file/line locations, forcing the agent to fix them before claiming done. Supports JS/TS, Python, and Kotlin. Memoizes repeat checks for speed.
Native rules, hooks, and guards that prevent Claude Code and Codex from hallucinating code, duplicating files, or shipping unverified changes. A set of guardrails for adding discipline to agentic coding sessions.
A collection of reusable Claude Code plugins, hooks, skills, and compatibility distributions focused on Git workflows, safe automation, and developer productivity. Pre-packaged for common developer scenarios. A practical starting point for teams that want to extend Claude Code without building from scratch.
A Claude Code hooks setup that warns when you are about to trigger a cache re-write after the 1-hour cache expiration, blocking the message until you resend it with a WARMOK keyword. Addresses accidental usage spikes from returning to long-running sessions. Install via npx claude-rewarm-guard install.
Automatically saves technical shortcuts taken by coding agents to your repo as they happen. Creates a living debt log you can review and address on your schedule — no more invisible debt accumulating silently during agentic sessions.
Describes a hook/workflow where Claude checks "was that message meant for this thread?" when running many parallel sessions. Catches misdirected messages (e.g., a voice transcription intended for another project) before the agent runs off with the wrong intent.
A collection of Claude Code PreToolUse hooks that block destructive shell commands, secrets exposure, and PII in tool calls, and protect source-of-truth files from accidental modification. Drop-in safety net for any Claude Code project.
A simple hook that lets Claude write your git commit messages, saving time on routine commits. Minimal setup with direct integration into the commit workflow.
Snapshots files before Claude Code runs destructive bash commands (rm -rf, git reset, rsync), making agent mistakes reversible even for files git never tracked. An essential safety net for autonomous agent sessions.
A Mac notch app that intercepts Claude Code's PreToolUse hooks and displays approval prompts on the MacBook notch. Tap Allow/Deny without switching to the terminal — with heartbeat failsafe so a crashed notch never stalls a run.
dotnet new templates that enforce AI agent architectural rules by turning violations into build errors. Uses Roslyn analyzers, NetArchTest fixtures, and git/Claude hooks, all wired at error severity.
Human-in-the-loop context compaction for Claude Code — you pick which conversation turns survive, and a SessionStart hook re-injects them after every compact or resume. Gives precise control over what context Claude remembers.
A local secrets firewall that redacts credentials in prompts, file reads, and tool output before they reach the LLM (Claude Code, Codex, OpenCode). No proxy, no npm, deterministic hooks.
A structured workflow enforcer for Claude Code that blocks implementation if a plan is missing via PreToolUse hooks. After each response it evaluates scope impact and blast radius, then runs a gbc verify step to compare implementation against declared evidence. A disciplined approach to preventing unplanned AI-driven code changes.
A quality-tooling suite for AI coding agents built around the Phoenix-13 hook set and Quantum-11 shared doctrine. Provides a one-step DLC installer to deploy the full suite and includes benchmarks comparing agent behavior with and without the tooling. Acts as the landing page for the broader TheColliery ecosystem of AI coding guardrails.
An AI agent permission gateway that intercepts dangerous tool calls from Claude Code, Codex, or Antigravity and routes them to your phone for approval before execution. Adds a human-in-the-loop safety layer for destructive operations.
A CI gate that scans only lines added by a diff and flags vibe-coded artifacts: leftover chat text, placeholder stubs, swallowed errors, em dashes, AI prose patterns, and unstyled shadcn defaults. Routed by file type (code/text/UI). Drop into any repo without cleanup required.
Your build is green — but did the agent make it green by weakening the tests? mumei re-runs them from a clean HEAD, freezes what must not be tuned, and reads the diff for deleted tests and suppress...
A pixel crab that sits on your desktop and mirrors your Claude Code session state in real-time — typing animation during tool use, thought bubble while thinking, and "!?" claws on permission prompts. It hooks into PreToolUse/PostToolUse/Notification/Stop events by writing a state file the app watches. Install via Homebrew on macOS.
Multi-runtime AI agent governance harness — Claude Code · Codex · Gemini under one YAML policy, with portable security hooks
I've been running private multi-hour knowledge-work tasks through several models. I can't share the tasks or outputs, so I've removed everything identifying and renamed them Test A and Test B. With...
Extends Claude Code and Cursor rewind to cover terminal commands, not just agent file edits. Uses git commits for every agent turn to enable precise revert — with backup refs so no work is ever lost.
Stops skipped tests, skipped reviews, and file-boundary violations before PRs are submitted. A Claude Code hook that enforces workflow discipline at the PR gate.
Uses a Claude Code skill + PreToolUse hook to block npm/npx/yarn and enforce pnpm instead. Defends against npm supply-chain attacks (Shai-Hulud-style) in agentic workflows.
I had Fable, so I used Fable. For everything. Including "where is the function that handles retries", which is a grep. That is where the tokens go. Not on hard problems, on easy ones handled by a m...
A personal, deterministic, local-only principle-guard for Claude Code — one hook that blocks dangerous actions and flags drift/sycophancy. No deps, no network, no LLM. Every rule off by default.
Spec-driven AI development workflow — methodology docs, starter templates, and Claude Code/Codex plugins with feature specs, current-truth docs, ADRs, hooks, and review gates.
Claude Code plugin that catches the bugs your agent shrugs at — enforced by hooks, auto-closed on merge.
Block irreversible AI-agent actions before they run — deterministic, fail-closed action-veto (deny-list + exec-check + human-in-the-loop) for any tool-using agent, from a Claude Code hook to local ...
BUG: Fable usage is horrific. FIX IT. Tell GPT SOL to build a PRD and down grade its model to LUNA to generate the scaffolding and Terra to revise based on the PRD and have SOL Correct any advanced...
submitted by /u/Patient_Tennis_9793 [link] [comments]
8 Best AI Coding Agent Guard Surfaces 2026 – Sigil Hook & Sandbox Review
Block the fake-green failure mode in autonomous coding agents: deleting, disabling or weakening tests to force a green build. Zero-dep Claude Code hook.
Serialized text-to-speech queue for Windows: edge-tts + mpv, single consumer, Claude Code Stop-hook announcements, clipboard hotkey, tray icon + NiceGUI dashboard
Your Claude Code agent that remembers across sessions — date-tagged memory, three hook-enforced memory caps, per-session handoffs, stale-refs detection, multi-project isolation, sandbox experiments...
Live index of Claude Code extensions, hooks, and plugins — refreshed every 15 minutes from GitHub
Per-window Claude Code status badges for macOS Terminal.app using Claude Code hooks
Web generator for .claude configurations (CLAUDE.md, settings.json, rules, hooks) with verified Claude Code marketplaces and third-party tools catalogs. 100% static, in-browser.
Deploy a Full AI Engineering Team 2026 - Claude 12-Agent System with Automated Quality Hooks
🔊 Haz que Claude Code te hable: lee sus respuestas en voz alta con hooks + say de macOS. Cero dependencias, cero tokens. / Make Claude Code speak its answers aloud on macOS.
Config complète + méthode de travail pour Claude Code, prêtes à installer. Playbook 10 chapitres, 9 schémas mermaid, hooks d'enforcement, agents de review, apprentissage continu. En français.
ReqForge — From requirements to shippable products. Open-source Agent Harness for Claude Code, Cursor & OpenCode. Spec→Plan→Build, hooks, review. /change-manager for brownfield.
A quick comparison showing Claude Code's hook ecosystem (23 hooks) vs Codex CLI's limited 3-hook support. Illustrates the breadth of lifecycle automation available in Claude Code for custom tooling and integrations.
A lightweight, zero-dependency lint hook that plugs into the agent loop to enforce code quality. Fast and universal — no additional runtime dependencies needed.
Practical explanation of using Claude Code hooks (lifecycle event listeners) and SKILL.md together to encode standards and workflows. Before: every session starts from scratch. After: hooks inject context automatically, skills define reusable patterns.
A hook-based gate that forces an architecture review before any file edit proceeds. A UserPromptSubmit hook delegates to an architect agent; a PreToolUse hook blocks edits unless a valid session marker exists. Documents architectural decisions automatically.
A safety layer for Claude Code that intercepts and blocks dangerous shell commands and credential file reads before they execute. Protects against AI errors that could damage systems or leak secrets.
A framework encoding how your team does things as prescriptive rules triggered by context, not requested by intent. Ways (workflows) fire automatically based on what Claude is doing — ensuring standards are enforced without relying on Claude remembering to follow them.
A Claude Code Stop hook that triggers a native macOS notification with a sound (Glass tone) when Claude finishes a task. Added via the hooks system in user settings. Simple one-liner using osascript so you can step away and get notified when Claude is ready for input.
A pure-bash, zero-dependency tool that sends desktop alerts, sounds, Slack, Discord, Telegram, Email, and WhatsApp notifications when long-running terminal commands complete. Includes AI CLI hooks specifically for Claude Code, Codex, Gemini CLI, Copilot, and Cursor. No dependencies to install.
A GitHub repo of ready-to-use plugins, hooks, and commands for Claude Code, focused on data mining, automation, and integration tools. Aims to provide copy-paste-ready session enhancements without needing to write them from scratch.
A project that implements all 23 Claude Code hooks with explanations and a companion video covering each hook's use case. Hooks are one of the key features differentiating Claude Code from other CLI agents like Codex. The repo serves as both a reference implementation and a learning resource.
A battle-hardened production Claude Code configuration featuring an Evidence Policy, 16 deterministic hooks (CircuitBreaker, InputGuard, PII redaction), 9 specialized agents, Confidence Scoring, 311 tests, and 71% coverage with mypy strict mode. One of the most comprehensive open-source Claude Code configurations available.
Integrates Symbiont's zero-trust AI governance framework into Claude Code. Enforces security policies, verifies tool calls, and tracks audits within development workflows. Useful for compliance-conscious teams that need a verifiable audit trail of AI actions.
A daemon-based hooks system for Claude Code with lazy startup (only starts when needed), automatic shutdown when idle, and project-level handler extensibility. More efficient than running hooks as separate processes for each event — especially for high-frequency hook usage.
CLI tools and hooks for Claude Code
submitted by /u/shanraisshan [link] [comments]
Some background: I'm not a software engineer. I run IT Operations — I've spent 11+ years managing infrastructure, teams, and systems at scale, but I'd never written code before about 30 days ago wh...
I have two Stop hooks configured: 1- ~/.claude/settings.json (global): plays a notification sound when Claude finishes 2- {project}/.claude/settings.json (project): runs lint fix after editing The ...
I swear this whole coding-agent wave feels like a manic marketing funnel designed to do one thing: get us dependent . Look, I use Claude Code / Copilot / whatever — they speed up boring stuff, no d...
Hi folks, As autonomous agents are becoming more and more powerful, such as Karpathy's autoresearch , I felt that so much technical information and experience are being lost in-between sessions. Un...
A plugin that reads previous Claude Code session markdown files and automatically steers current sessions based on established patterns. Uses semantic extraction so Claude stops ignoring your markdown files.
Generate enforced guardrails — CLAUDE.md rules, hooks, and settings — from a single natural language description. Tame AI coding agents by describing your constraints in plain English instead of hand-crafting config files.
A developer used Claude Code hooks to build a real-time global leaderboard tracking coding activity across agents. Demonstrates practical use of Claude Code hooks for cross-session event tracking and competitive stats.
A Claude Code PostToolUse hook that enforces tag-based two-party consensus between Claude and an external AI auditor (GPT/Codex). Drop into one directory, configure via JSON. Adds auto-sync, planning doc normalization, and inline quality checks.
V1R4 is a 3D avatar overlay that plugs into Claude Code via hooks and reads responses out loud using local TTS. It extracts a hidden tag from Claude output to trigger speech with different personalities selectable.
A Claude Code hook that prevents the agent from weakening test assertions when fixing failing tests. Detects patterns like removing assertions or converting strict checks to weak ones, and blocks the commit with an explanation.
A PreToolUse hook that closes a real security gap: compound bash commands (using &&, ||, ;, |, subshells) can bypass allow/deny patterns because Claude Code matches the full command string. This Python script decomposes each compound command into sub-commands and checks each one individually — deny wins, and auto-approve only fires when every sub-command passes. Zero dependencies, reads your existing settings.json permissions.
If you use Claude Code alongside other tools (Codex, Cursor, Aider), you've probably lost context when switching. I built ai-sync to fix this. **What it does:** - `/sync-init` bootstraps a `.ai-syn...
Hello ! I am thinking of an idea and don't know if it makes sense or not, so please tell me if I should try it and if yes what to say / not say. I used to live in a 3rd world country that seems to ...
A Homebrew-installable collection of Claude Code hooks that sync agent activity with Obsidian vaults and send desktop notifications. Hooks fire on tool use events to automatically log decisions, file changes, and session summaries into your knowledge base.
10 production hooks + 5 templates for autonomous Claude Code operation. Context monitoring, syntax checking, branch protection, error gates, and more.
🔔 Cross-platform smart notifications plugin for Claude Code. 6 types. Click-to-focus. 1 line installation. Instant. Analyze context. Zero dependencies. webhooks. Linux, MacOS, Windows.
Real-time statusline, live monitor, session analytics, and hooks for Claude Code
VibeFlow provides Claude Code skills and hooks that enforce a documentation-before-code discipline in AI-assisted development. A full workflow with checkpoint gates prevents jumping straight to implementation, and branch-locked enforcement keeps agents in scope. Ideal for teams wanting to maintain structured development practices even when using AI coding tools.
Extracts data from 26 sources. Some need to hook up with API. Optional LLM layer generates trade ideas based on the narrative plus communicates via Telegram/Discord. Open to suggestions, feature im...
Yes I use PowerShell. Don't Judge me. I was tired of guessing whether my prompt cache had expired while I was sitting there thinking about my next message, so I built a countdown timer that shows t...
Been using it all day yesterday, did I expect opus to handle 1m context, no. Did I expect it to handle more context, yes. I pushed this yesterday, it was the first time in a long time I saw opus st...
This future will either amazing or horrible. Finally got around to hooking up my phone to my desktop. tmux made it a breeze. I assume this will be downvoted to oblivion, for obvious reasons. I’m ok...
So with the release of the 1 million context model with no extra usage I kinda changed my workflow drastically. I used to use parallel sub agents to do exploration and have the context fed back to ...
https://reddit.com/link/1ru081n/video/iw1vypwaw3pg1/player Been messing around with Karpathy's autoresearch pattern and kept running into the same annoyance: if you run multiple agents in parallel,...
I've been using claude AI for maybe a week and a half now. And I'm hooked. I won't lie, I use it for RP and bouncing ideas around from time to time. It's great! However the daily limit kinda sucks ...
Claude AI on guys and their for fishing section of their portfolios: LMAOOOO 💀😂 The absolute AUDACITY of the pride!! "Look what I caught!!" Sir you drove a boat to where the fish LIVE. You put food...
i have all 22 hooks configured in this repo , but i cant find any use case to test these 2 new hooks. submitted by /u/shanraisshan [link] [comments]
A Claude Code plugin that silently records the complete session lifecycle, automatically fetches proven solutions from the community for reuse, and compiles structured reports — so every collaboration builds on past sessions.
A Claude Code hook that plays ambient background sounds while Claude is working and automatically stops them when Claude needs your attention — a subtle productivity aid that signals session state through audio.
ContextWeave is a hook kit for Claude Code and Gemini CLI that persists agent traces and working context into Beads — a structured format enabling deterministic rehydration of context across sessions.
A zero-config watchdog plugin for Claude Code and Copilot CLI that detects when agents are stuck in error loops, stalling indefinitely, or repeating failed attempts. Automatically raises an alert before wasted tokens accumulate.
A Claude Code hook that intercepts submitted prompts via the UserPromptSubmit event and asks targeted clarifying questions before Claude executes — reducing wasted iterations from underspecified prompts. Works entirely within Claude Code with no external dependencies.
A hook that automatically redacts sensitive information (API keys, passwords, PII) from screenshots before they are sent to AI agents. An essential safety layer for teams using Claude Code in environments with confidential data.
A Claude Code hook that inspects Python scripts before they are executed, scanning for hidden destructive commands, dangerous imports, and unsafe patterns — preventing Claude from accidentally running malicious or accidentally harmful code.
tokwave is a terminal-based tool that captures every tool call via Claude Code hooks and renders it as a live audio waveform showing your real-time token generation speed. Combines a hook, terminal UI, and MCP server — installable with npm install -g tokwave.
parry-guard is a security tool for Claude Code that scans for prompt injection attacks using DeBERTa and Llama transformer models, running locally via Candle or ONNX inference in Rust. It acts as a defensive layer to detect and block adversarial instructions embedded in untrusted content before they reach the agent, with no network calls required.
Clawd Tank is a hardware notification device using a $12 ESP32-C6 board with a tiny LCD showing an animated crab that reacts to Claude Code lifecycle hooks in real time. When Claude Code fires a Notification hook, the crab animates, an LED cycles colors, and a card slides in; it falls asleep after 5 minutes of inactivity. Features BLE connection, multi-session support (up to 8 concurrent), macOS menu bar app, and a TCP simulator for testing without hardware.
I posted previously about using defense in depth when coding with LLMs and a lot of people asked how to actually set it all up. So I wrote a step-by-step guide that assumes zero prior experience. I...
I started using Claude last week and quickly got hooked. So far the free plan has worked just fine, whenever I hit the 5hr limit I just take a break, and catch up with real life. Some 5hr windows I...
Automated social media content from development activity
A hook library that enhances Claude Code workflows with custom command management. Handles permission request notifications and status updates through hooks, making it easier to build automated approval flows and notification systems around Claude Code operations.
A Claude hook that automatically generates social media content based on your development activity. When you commit or reach development milestones, the hook creates draft posts for social sharing — useful for indie hackers building in public.
A safety guard plugin that uses AST (Abstract Syntax Tree) analysis to classify bash commands by risk level before Claude executes them. Blocks dangerous commands based on their syntactic structure rather than simple string matching, providing more reliable protection.
A controlled experiment running the same coding task 6 times — 3 with oh-my-claudecode hooks ON, 3 OFF — using Claude Sonnet 4.6. The result was less dramatic than the hype surrounding external hook tools suggests. Repo includes the test methodology and raw results for others to verify.
bitloops captures every developer-AI interaction and attaches it to git commits, building a queryable semantic model of how your codebase evolved. You can query the history of AI-assisted decisions to understand why code is the way it is. Built for AI-native development workflows.
mmi automates the permission decision process for Claude Code Bash tool calls, reducing the interruptions caused by constant approval prompts. Provides policy-based control over which shell commands Claude can run without human confirmation.
The most downloaded item on skillsmp.com is a simple notification hook that alerts you when Claude Code finishes a task. Knowing when the agent is done is described as the single most useful workflow addition, enabling truly unattended sessions.
By adding an ElevenLabs text-to-speech script to Claude Code hooks, this developer made it feel like genuine pair programming — Claude reads its responses aloud after each paragraph. A creative use of the hook system to add audio presence to terminal-based coding sessions.
Claude Code supports skill-scoped stop hooks that can re-invoke Claude with a skill-specific prompt when conditions are met, such as lowering resource constraints and rerunning a workflow after an OOM error. An underdocumented feature with powerful recovery automation potential.
sensitive-canary is a set of Claude Code hooks that intercept outgoing requests and scan for secrets, API keys, and PII before they are sent to the Anthropic API. Implements a canary-style tripwire: if sensitive data is detected in tool inputs or file content, the request is blocked and the user is alerted.
A memory system for Claude Code built entirely on hooks and markdown files — no external dependencies, no database. PostToolUse hooks capture decisions and key context; a summary hook on session end updates a persistent memory.md. The entire system is under 200 lines and works across any project.
A thread covering five advanced Claude Code techniques: a UserPromptSubmit hook that injects one optimization hint after 8+ tool calls (reusable skill, memory pattern, or refactor), preemptive context hints, CLAUDE.md layering tricks, and two more patterns for power users. Good high-density reference for experienced Claude Code users.
A PreToolUse hook for Claude Code that intercepts every file write and scans for hardcoded API keys, passwords, and other secrets before they are written to disk. If a secret is detected, the write is blocked and Claude is prompted to use environment variables instead — preventing accidental credential leaks.
A hook-based system that gives Claude Code better awareness and control of its own context window. Instead of silently approaching the limit, the hooks surface context usage and trigger structured summarization or handoff steps at configurable thresholds. Reduces context-overflow failures in long-running sessions.
remembrall monitors Claude Code's context window and automatically saves your work state when context runs low, preventing mid-session progress loss. Zero dependencies, works across platforms.
Claude Code hook configuration that plays soothing mouse click sounds during long-running tasks using voice hooks. Demonstrates Commands → Agents → Skill weather orchestration pattern. Repo includes a collection of Claude Code best practice hooks.
Collection of Claude Code hooks focused on security hardening — blocks prompt injection attempts, validates tool calls, and adds utility extensions through custom scripts. Provides a defensive layer for unattended or multi-agent sessions.
A validation dispatcher for Claude Code hooks that enforces git workflow standards, commit message conventions, and code quality rules. Centralizes hook logic into a single dispatcher, making it easy to maintain consistent enforcement across different types of Claude Code events.
Boris Cherny (creator of Claude Code) shares a no-dependency pattern for automatic memory: create an agent stop hook that reads the conversation and documents key memories to CLAUDE.md or a notes file. No MCP server required — just a hook and a markdown file.
Claude Code v2.1.10 introduces a Setup hook event triggerable via --init, --init-only, or --maintenance CLI flags. Lets you automate repository setup and maintenance tasks that run on first install or during upkeep. v2.1.11 also fixes excessive MCP connection requests for HTTP/SSE transports.
A 3-layer safety hook system that intercepts and blocks catastrophic commands even when Claude Code runs with all permissions bypassed. Lets you get the productivity benefits of unrestricted mode without risking irreversible filesystem or system damage. Installable drop-in safety net for power users.
https://reddit.com/link/1rqw4ae/video/slts2qlyffog1/player Inspired by this tweet , I wanted to add some fun to the terminal. I built a PTY proxy using Claude that wraps Claude Code with a shadow t...
Claude Code hooks that auto-switch model tier based on task complexity
Provide a scaffold template to kickstart Claude Code projects with ready-made commands, hooks, and documentation for efficient development.
I've been using Claude Code for 3 months now and thought I had a solid workflow. Then I stumbled onto stop hooks and recently memory, and honestly felt embarrassed I hadn't been using them sooner. ...
Thinking about this for my operation. Thoughts? -------------- # AI Coding Policy In the interest of transparency, here is our philosophy and policy on AI coding agents. ## Philosophy **Iterative D...
Hooks, context rules, and session automation for Claude Code — applied automatically, every session.
Hey r/ClaudeAI , I’ve been a heavy ChatGPT user for over a year (daily coding, research, and long writing sessions). Yesterday I finally decided to give Claude a proper try on the free tier and… wo...
Interactive trust manager for Claude Code — safely trust dialog prompt and enable hooks in new directories
avakill intercepts tool calls before they execute and enforces YAML-based policies to kill dangerous operations in real-time. Works with OpenAI, Anthropic, LangChain, and MCP. Provides a configurable safety layer between AI agents and your system without modifying agent code.
Vectimus uses Claude Code's pre-tool-use hooks to intercept Bash, Write, Edit, MCP, and WebFetch calls and evaluate them against 78 Cedar policies (368 rules) in ~3ms. If an action is dangerous, it blocks it and suggests a safer alternative. Runs entirely local.
agentcrumbs adds a debug mode to any AI agent by injecting structured trace breadcrumbs inline. These traces are automatically stripped before git merge, giving full observability into agent decisions during development without polluting production code. From the Trigger.dev team.
Viberails is a CLI that uses Claude Code's PostToolUse hook to catch convention violations in real-time as Claude edits files. It auto-detects your existing conventions (file naming, test coverage, package boundaries), then enforces them without any configuration. MIT-licensed, works with JS/TS repos.
A Claude Code plugin that intercepts speculation, invented causality, and fake citations before they pollute your context. Zero dependencies, works offline, no API keys. Install in one command. Prevents hallucinated information from compounding errors in agentic sessions.
Enforces safety guardrails on Claude Code tool calls by blocking risky or harmful commands before execution. Acts as a hook layer that inspects and filters tool use to protect your workflow from unintended destructive actions.
A developer shares that spec-workflow-mcp with SDD (Specification-Driven Development) templates yields more predictable Claude Code behavior than Plan mode alone. They suggest adding a Hook triggered after context compaction to reconfirm the active spec, maintaining coherent behavior in long sessions. A practical tip for teams using structured development workflows.
A pattern for Claude Desktop using a BRAIN.md file read at session start and updated at session end via hooks. The post also clarifies a common misconception: the User Preferences field is not a startup script — it is injected on first message. Proposes a true SessionStart hook as a Claude Desktop feature.
A collection of tools, hooks, and shell utilities that enhance the Claude Code terminal experience. Includes a statusline integration, a tmux usage bar, a keychain CLI for credential management, and system notification hooks. Improves visibility into Claude Code activity during development.
A Claude Code plugin that fixes the default worktree behavior so that claude -w branches from HEAD instead of origin/main. Adds real branch resolution, worktree.guessRemote support, custom branch prefixes, and a .worktreelink file for symlinking heavy directories instead of copying them.
A Claude Code hook system that converts session events into spoken in-character notifications (Adjutant, SHODAN, GLaDOS, HEV Suit). Each session gets a distinct voice so you know which one is talking without looking. Uses OpenRouter LLM + local TTS.
A gatekeeper layer that intercepts and blocks AI agent actions based on configurable principles rather than fixed rules. Provides a principled safety net between agent intentions and real-world effects without requiring per-action allowlists.
Turns any repo into a governed AI workspace with quality gates, security scanning, and risk management enforced locally via git hooks. Works with Claude Code, GitHub Copilot, Cursor, Gemini, and Codex — a universal governance layer for AI-assisted development.
Development discipline tool with a status line for Claude Code featuring two-tier enforcement, real-time read/edit tracking, and an investigation gate. Designed to keep Claude Code disciplined and transparent about what files it's touching.
A hook system using UserPromptSubmit and PreToolUse hooks to enforce brand voice consistency across AI-written copy. A reviewer agent is injected before any copy file edit, and hooks block writes to .tsx/.md files unless voice review is complete. Prevents copy drift in AI-generated content.
Installs and orchestrates lifecycle hooks across Claude Code, Cursor, and Gemini from a single manifest file. Manage hooks once and deploy them to all your AI coding assistants simultaneously — a unified hook management layer for multi-agent workflows.
A PreToolUse hook pattern that intercepts Claude's default tool choices and redirects it toward MCP tools when better alternatives are available. Solves the common problem where CLAUDE.md instructions drift after a few turns and Claude reverts to built-in tools. The hook enforces the preference at the infrastructure level rather than relying on prompt compliance.
Uses tree-sitter AST parsing to gate Claude Code's bash command execution at a syntax level rather than simple string matching. Provides fine-grained, semantically-aware control over what shell operations Claude can run. More robust than keyword blocklists — Claude can't bypass it by rephrasing the command.
A personal agent setup called Rupert that combines Claude, Gemini, and OpenCode with hooks that notify you of what each agent is doing in real time. Includes a memory-agent component for reducing token usage across sessions.
Anyone else frustrated that claude -w branches from origin/main instead of HEAD? ( #27134 ) I was on a feature branch, hit claude -w , and the worktree started from main. So I just built a plugin t...
This isn't a criticism of Claude. It's a structural problem with any AI reviewing its own output. When Claude generates 30 files in one session, it self-reviews by comparing output to its own assum...
I just vibe-coded a TikTok research AI agent in Claude Code A complete research-to-brief pipeline that scrapes TikTok, analyzes video hooks with AI, and generates creative briefs on demand. All i...
A real-time safety scanning layer for LLM applications with 10 scanners covering prompt injection, PII detection, harmful content, code vulnerabilities, and obfuscation. Offers sub-millisecond latency, Python and TypeScript SDKs, an MCP proxy, and native Claude Code hooks integration for pre/post-tool safety checks.
🪝 Customize and deploy ready-to-use hooks for Claude Code, enhancing safety, automation, and notifications in your projects.
Claude Code setup that just works. Bootstrap every project with agents, hooks, commands, and smart permissions. One command, zero headaches.