XDA-Developers recently described adding a single hook to Claude Code and watching it stop repeating the same mistake on every subsequent run. That’s a small change with a large implication: a hook turns an AI coding assistant from something that suggests code into something that enforces a workflow. Instead of hoping the model remembers a lint rule or a naming convention, a hook fires automatically before or after a specific action and blocks, rewrites, or logs it. Seven AI coding tools whose hook, rules, or automation systems hold up once you actually try to make an agent follow your team’s process instead of its own.
What to look for in an AI coding tool with hooks
- Hook trigger types. Pre-tool-use hooks catch a bad action before it happens; post-tool-use hooks catch the result after. Git hooks and save hooks cover the rest of the workflow.
- Auto-approval rules. A hook system is only useful if you can also define which actions never need a manual approval, so the agent doesn’t stall on routine steps.
- Context-file support. Files like
.cursorrulesthat persist project conventions across sessions without you repeating them in every prompt. - Audit-log or observability. You need to see what the agent actually ran, not just what it claims it ran.
- Editor fit. A hook system that only works from a separate CLI is less useful than one that runs inside the editor you already use.
- Shell command integration. The strongest hook systems let a hook call an arbitrary shell command, not just a fixed set of built-in checks.
Quick comparison
| App | Best for | Platforms | Free plan | Starting price |
|---|---|---|---|---|
| Claude Code | Full pre/post-tool-use hook system | Windows, macOS, Linux | Limited free usage | $20/mo (Pro) |
| Aider | Git pre-commit and lint hooks | Windows, macOS, Linux | Free, open-source | Free (bring your own API key) |
| Cursor | Per-project rules files | Windows, macOS, Linux | Limited free tier | $20/mo |
| Continue.dev | Custom slash commands and context providers | Windows, macOS, Linux | Free, open-source | Free |
| Cline | Auto-approval and pre-execution guardrails | Windows, macOS, Linux | Free, open-source | Free (bring your own API key) |
| Sourcegraph Cody | Context files plus ignore rules | Windows, macOS, Linux | Free tier | $9/mo (Pro) |
| Gemini Code Assist | Enterprise policy hooks | Windows, macOS, Linux | Free tier | $19/user/mo (Enterprise) |
The apps
1. Claude Code — Best for a full pre/post-tool-use hook system
Claude Code is the tool behind the XDA story, and it’s the one with the most complete hook system of the group. It supports pre-tool-use hooks (run before Claude executes an action, with the power to block it), post-tool-use hooks (run after, for validation or logging), stop hooks (run when a session ends), and subagent-stop hooks for multi-agent workflows. Each hook is a shell command you define in a config file, so a hook can run a linter, check a file against a style guide, or refuse a commit that touches a protected path.
Where it falls short: Hooks are configured through JSON and shell scripts, which has a learning curve compared to a simple rules file. The hook system is Claude Code-specific, so nothing carries over if a team also uses a different agent.
Pricing: Limited free usage; Pro at $20/month; higher-usage tiers for teams.
Platforms: Windows, macOS, Linux (terminal-based, works with any editor).
Download: Claude Code
Bottom line: The reference implementation for hook-driven AI coding, and the one the source story is built around.
2. Aider — Best for git pre-commit and lint hooks
Aider is a terminal-based, open-source pair-programming tool that ties directly into git. It can run a pre-commit hook and a lint hook automatically after every edit, so a broken build or a failed style check gets caught before it becomes a commit instead of after. Because it’s open-source, the hook behavior is visible in the codebase rather than hidden behind a hosted service.
Where it falls short: No graphical interface; everything happens in the terminal. Hook configuration is closer to editing a config file than clicking through a settings panel.
Pricing: Free and open-source; you supply your own API key for whichever model you connect it to.
Platforms: Windows, macOS, Linux.
Download: Aider
Bottom line: Pick this when the workflow you want to enforce is fundamentally a git workflow.
3. Cursor — Best for per-project rules files
Cursor is a fork of VS Code with AI completion and chat built in, and it uses .cursorrules and .cursor/rules files to steer how the model behaves on a specific project. Rather than a hook that intercepts an action, these files persist conventions (naming patterns, architecture notes, banned libraries) so the model applies them automatically on every completion and chat response.
Where it falls short: Rules files steer suggestions; they don’t block or gate actions the way a true pre-tool-use hook does. Paid tiers are required for heavier usage.
Pricing: Limited free tier; $20/month Pro; higher tiers for teams and larger context.
Platforms: Windows, macOS, Linux.
Download: Cursor
Bottom line: Pick this when you want persistent project conventions inside a familiar VS Code-based editor.
4. Continue.dev — Best for custom slash commands and context providers
Continue.dev is an open-source, MIT-licensed extension for VS Code and JetBrains IDEs. It lets you define custom slash commands that trigger specific automated actions, plus context providers that feed the model relevant files, docs, or terminal output automatically instead of you pasting them in each time. Being open-source and IDE-native makes it straightforward to adapt to a team’s existing tooling.
Where it falls short: The hook and automation model is less granular than Claude Code’s pre/post-tool-use system; it leans more on context and commands than on strict interception.
Pricing: Free and open-source.
Platforms: Windows, macOS, Linux (VS Code and JetBrains).
Download: Continue.dev
Bottom line: Pick this for an open-source, IDE-native alternative that doesn’t lock you into a single model vendor.
5. Cline — Best for auto-approval rules and pre-execution guardrails
Cline is an open-source VS Code extension that runs as an autonomous coding agent inside the editor. It supports auto-approval rules that let routine actions (reading a file, running a known-safe command) proceed without a manual click, while pre-execution guardrails stop it from running commands outside an allowed list. That combination keeps the agent moving on trusted work while still gating the risky parts.
Where it falls short: Configuration lives in the extension’s settings rather than a portable config file, which makes it harder to share guardrail setups across a team’s repos.
Pricing: Free and open-source; you supply your own API key.
Platforms: Windows, macOS, Linux (VS Code).
Download: Cline
Bottom line: Pick this for a free, VS Code-native agent with real guardrails on what it’s allowed to execute.
6. Sourcegraph Cody — Best for context files plus ignore rules
Sourcegraph Cody uses .cursorrules-style context files to steer responses, and adds cody.ignore, a file that excludes specific paths (secrets, generated code, vendored dependencies) from what the agent can read or act on at all. That ignore-file model is closer to a hard boundary than a soft convention, which matters in larger codebases.
Where it falls short: The free tier caps usage, and Cody’s deeper code-search features are tied to a Sourcegraph instance, which adds setup for teams not already using it.
Pricing: Free tier available; Pro at $9/month; Enterprise pricing for larger teams.
Platforms: Windows, macOS, Linux (VS Code, JetBrains).
Download: Sourcegraph Cody
Bottom line: Pick this when keeping the agent out of specific directories matters as much as steering its style.
7. Gemini Code Assist — Best for enterprise policy hooks
Gemini Code Assist targets organizations that need repository-wide rules enforced across every developer, not just the ones who bother to set up their own config. Enterprise policy hooks let an admin define rules once and apply them across a whole team’s repos, with the enforcement point sitting closer to the organization than the individual developer.
Where it falls short: The hook and policy features that matter most are gated behind the Enterprise tier; the free tier is closer to a standard code-completion assistant.
Pricing: Free tier; Enterprise at $19 per user/month.
Platforms: Windows, macOS, Linux (VS Code, JetBrains, Cloud Workstations).
Download: Gemini Code Assist
Bottom line: Pick this when the rules need to be enforced organization-wide, not opt-in per developer.
How to pick the right one
- If you want the deepest hook system and don’t mind a terminal-first workflow: Claude Code.
- If the workflow you’re enforcing is really a git workflow: Aider.
- If you want persistent project conventions inside a familiar editor: Cursor.
- If you want an open-source option that isn’t tied to one model vendor: Continue.dev.
- If you want a free, VS Code-native agent with real pre-execution guardrails: Cline.
- If keeping the agent out of specific files matters as much as steering its output: Sourcegraph Cody.
- If you’re rolling this out to an entire engineering org and need policy enforced centrally: Gemini Code Assist.
- Most teams end up running two: one agent with strict hooks for the main repo, and a lighter one for scratch work.
FAQ
What is a Claude Code hook?
A Claude Code hook is a shell command that runs automatically at a defined point in the agent’s workflow: before a tool executes (pre-tool-use), after it executes (post-tool-use), when a session stops, or when a subagent stops. Because it can block an action outright, it turns a rule you’d otherwise have to repeat in every prompt into something the agent can’t skip.
Which AI coding tools support pre-commit hooks?
Aider ties directly into git and can trigger a pre-commit or lint hook after every edit. Claude Code and Cline support similar pre-execution checks through their own hook and guardrail systems, though they aren’t strictly git-hook-based.
Do Cursor rules work like Claude Code hooks?
Not exactly. Cursor’s .cursorrules files steer how the model completes and responds, based on conventions you’ve written down. Claude Code’s hooks can actively intercept and block an action before it runs. Rules shape behavior; hooks enforce it.
Are Aider hooks free?
Aider itself is free and open-source, including its git hook integration. You still need an API key for whichever underlying model you connect it to, and that usage is billed by the model provider, not by Aider.
Can I use hooks without paying for a subscription?
Yes. Aider, Continue.dev, and Cline are all free and open-source, and each supports some form of automated enforcement (git hooks, custom commands, or pre-execution guardrails) without a subscription. You’ll still pay for API usage on the underlying model unless you’re using a free-tier model.
Do these hook systems work outside VS Code?
Claude Code and Aider are both terminal-based and editor-agnostic, so they work regardless of which editor you use. Cursor, Continue.dev, Cline, and Cody are built as extensions for VS Code (and in some cases JetBrains), so their hook and rules features are tied to those editors.
