deadeye

He doesn't waste shots.

He doesn't check twice, and he doesn't spray and pray. One round chambered, one shot on target, and he's done — because the shot you never had to take is the best one. deadeye puts that discipline inside your coding agent.

It watches what your agent is about to do — spawn a subagent, dump a noisy test log, make a big multi-file edit — and fits the model, effort level, and context to the task before the tokens are spent, not after. Everything it remembers lives in one local folder, ~/.deadeye/: no hosted service, no API keys, no telemetry.

Full feature tour, with live examples → the site

Install

Host	Install	What you get
Claude Code	Plugin	The full engine, including model and effort routing
Codex CLI	Plugin	Most of the engine; no model or effort routing
Gemini CLI	Extension	Coder persona and session guidance
Cursor	deadeye init cursor	Persona, output trimming, exfiltration guard
Windsurf	deadeye init windsurf	Coder persona

Claude Code

/plugin marketplace add deepaksinghcs14/deadeye-cc

/plugin install deadeye@deadeye

Hooks and slash commands are live immediately. On macOS and Linux the binary downloads itself on first use from Releases, sha256-verified.

Windows

Self-bootstrap isn't built for Windows yet. After the two commands above:

1. Download deadeye_windows_amd64.exe (or _arm64) from Releases.
2. Put it on PATH as deadeye.exe, or at %USERPROFILE%\.deadeye\bin\deadeye.exe.
3. Run deadeye version to confirm it resolves.

Codex CLI

codex plugin marketplace add deepaksinghcs14/deadeye-cc

codex plugin add deadeye@deadeye

Then start Codex, run /hooks, and trust deadeye's hooks. Codex does not run a plugin's hooks until you have reviewed them, and asks again when an update changes them. The binary downloads itself on the first session (macOS/Linux).

You get output trimming, the exfiltration guard, the coder persona, the plan gate, the codebase map and the decision log. Not on Codex yet: model and effort routing.

Details, and installing without the plugin

The plugin's hooks are the ones deadeye init codex registers, addressed from the plugin. That path installs and loads in Codex 0.162; it has not yet been run end to end in a live session.

On a Codex too old for plugins, install the binary and run deadeye init codex. It shows the exact changes to $CODEX_HOME/hooks.json (or ~/.codex/hooks.json), writes them only after you confirm, and installs the $deadeye-pr, $deadeye-review and $deadeye-vapt user skills. Use one path or the other — with both, every hook runs twice.

Gemini CLI

Install the binary, then:

deadeye init gemini

gemini extensions install --path ~/.deadeye/gemini-extension

The first command writes a self-contained extension; the second is yours to run, because deadeye never edits Gemini's own config. You get the coder persona and session guidance (codebase map, vulnerable-dependency flag, soft plan gate). Experimental: the tool-level features wait on a live check of Gemini's tool schemas.

Cursor

Install the binary, then, in the project you want it on:

deadeye init cursor

It writes the coder persona as a rules file and registers deadeye's hooks in ~/.cursor/hooks.json, after showing you both and asking. Hooks you already have are kept. You get the persona, trimmed command output, the exfiltration guard, session guidance and the decision log. Experimental: built from Cursor's hook documentation and not yet confirmed in a live Cursor.

What runs through which hook, and what Cursor can't do

You get	Through
Coder persona	The rules file, .cursor/rules/deadeye.md
Session guidance, codebase map, session memory	sessionStart
Trimmed command output	preToolUse on Shell
Exfiltration guard on commands and credential files	preToolUse and beforeReadFile
Advice on repeated commands and oversized MCP responses	postToolUse

Not on Cursor: model routing (a hook can see a subagent's model but not change it), the plan gate and per-turn advice (the prompt hook cannot inject context), and the persona inside subagents. The guard blocks outright rather than asking, because Cursor does not enforce "ask" on these hooks. If deadeye itself fails, the hooks answer "allow"; it never blocks a tool call by breaking.

Windsurf

deadeye init windsurf

Writes the coder persona to .windsurf/rules/deadeye.md. Windsurf's hooks can only block, with no way to rewrite a command or add context, so the persona is all it gets.

Review commands on every host

deadeye init <host> also installs /deadeye-pr, /deadeye-review and /deadeye-vapt in that host's own command format. On Windsurf the rubrics are shortened to fit its workflow size limit.

Check it is working

deadeye doctor

One read-only pass over the plumbing: which binary is running, whether ~/.deadeye is private, whether config.json parses, the socket, the daemon, whether the routing judge can reach claude, and whether the hooks cover every tool deadeye handles. Each failure prints the command that fixes it. Reach for it when deadeye seems to be doing nothing: /deadeye-status shows what the settings are, and those can look perfect while the plumbing underneath is broken.

Uninstall

Host	Command
Claude Code	/plugin uninstall deadeye@deadeye
Codex CLI	codex plugin remove deadeye@deadeye
Gemini CLI, Cursor, Windsurf, or a Codex init install	deadeye uninstall <host>
The binary and all local state	deadeye uninstall --purge

From source: go install github.com/deepaksinghcs14/deadeye-cc/cmd/deadeye@latest

Numbers

Every figure is measured on a real run. The rewrite happens before the command runs, so only the part worth keeping ever enters context.

Real run	Before	After	Cut
go test with one genuine failure	485 B	99 B	79.6%
This repo's own suite (202 lines, all passing)	10,301 B	55 B	99.5%
npm install express mocha (progress spam)	553 B	55 B	90.1%
Coder persona a subagent inherits, per spawn	9,499 B	1,099 B	88.4%

The command rows are logged to ~/.deadeye/decisions.jsonl; the persona row is measured off the two rendered rulesets. Run /deadeye stats savings to see your own.

How it works

1. Look      Cheap, deterministic signals: files touched, recent git activity, nearby tests,
             how the request reads, whether it names something real, whether it's read-only
2. Decide    The cheapest (model, effort) that should still clear the bar for this task
3. Apply     Recommends the subagent's model and effort, or sets them if you turn on enforce;
             trims noisy command output; asks before a risky multi-file edit
4. Learn     Pick a bigger model than it recommended, and it gets more cautious
             for that kind of task next time

The rule behind all four: when unsure, a capable middle — not the priciest. Thin evidence defaults to the sonnet tier; picking cheaper needs real evidence above a confidence bar. When the signals can't place a task, a routing judge classifies it with one small claude -p call on your own login.

Every decision is printable: /deadeye-route shows the full reasoning. deadeye advises by default and never touches your settings.json. If anything inside it errors, your call passes through untouched.

What it controls

Ten independent controls. Each has its own switch, and turning one off never touches the others.

What	Modes	What it does
Context hygiene	off / on	Trims verbose command output (tests across nine ecosystems, builds, linters, installs, log tails) before it enters context, and flags waste: re-reading unchanged files, re-running a command, an oversized MCP response.
Coder persona	off / spotter / marksman / sniper	A lean-first coding discipline, with a live security check on what's written, injected each session and into subagents.
Security	off / advise / ask	Exfiltration guard: reading a credential file, or a command shipping one out, becomes a permission prompt a prompt-injected model can't answer.
Codebase map	off / on	A per-project map (skeleton, most-touched files, exploration notes) injected once per session, so a fresh session doesn't re-explore from scratch.
Model choice	off / advise / enforce	Picks the model for a subagent, only when you didn't choose one.
Effort level	off / advise / enforce	Suggests lower effort for mechanical steps. enforce sets it on subagent calls that didn't choose one (Claude Code 2.1.292+). No effect if CLAUDE_CODE_EFFORT_LEVEL is pinned.
Routing judge	off / on	On by default. Classifies a subtask the cheap signals can't place, with one small claude -p call on your own login: about half a cent, about 2.5 seconds, cached.
Plan-first gate	off / soft / hard	Suggests, or requires, a short plan before a risky multi-file edit.
Workflow suggestion	off / on	Flags tasks that look like parallel work. Only ever suggests; never starts one.
Update check	off / on	A daily background check for a newer release; asks once per version.

Change a setting with /deadeye config (a settings pane with the mod on, a picker from chat otherwise), deadeye config in a terminal, or deadeye config set <key> <value>. Settings live in ~/.deadeye/config.json, with an optional per-repo .deadeye.json; the full list is on the settings page.

Four environment variables are kill switches: DEADEYE=off (everything), DEADEYE_PREPROCESS=off, DEADEYE_GATE=off, DEADEYE_CODER=off.

Commands

Everyday

Command	What it does