The counter-agent, for anyone building with an AI agent

The agent writes.
Spotter catches.

A spotter doesn't lift. A spotter knows exactly how a lift fails — the grip, the elbow, the moment confidence outruns form — and is watching for it before the bar moves. Coding agents fail the same ten ways, every time. Spotter knows them in advance.

Download for Mac See the review

Free to start. macOS, Apple silicon · signed & notarized · v0.8.6

A coding agent isn't lazy on purpose. It reads part of the code, believes its own green checkmarks, and forgets everything by morning — structurally, not occasionally.

More prompting doesn't fix a structural weakness. A second pair of eyes that knows the weakness in advance does. Spotter sits in your menu bar, watches the same repo your agent is working in, and hunts for exactly the mistakes agents make — out loud, in a sentence, while the diff is still warm.

1 agent + 1 Spotter= 2= 10×

The multiplier isn't more code written. It's the rework that never ships.

The weakness map

Ten ways agents fail.
Spotter knows them cold.

This map ships inside Spotter — not learned per session, known before the session starts. And it stays alive: every time you correct your agent, Spotter remembers the correction as one more thing to watch for.

Context gaps

It didn't read enough before it wrote.

A1Partial reads

Edits a function it read; never opens the callers. Spotter reads what it skipped.

A2Stale priors

Writes from how libraries worked at training time, not how your repo works now.

A3Cross-file inconsistency

Changes a contract in one file and honors it in none of the others.

Completion gaps

"Done" and done are different claims.

B1Green check ≠ done

Passes the tests it ran, not the ones that matter. Spotter runs the rest.

B2Stubs & TODOs

Ships the scaffolding and reports the building. Spotter counts what's hollow.

B3Narrow verification

Verifies the happy path, in one file, once. Spotter runs the full suite, the build, the type-check.

Memory gaps

Every session starts from zero.

C1Session amnesia

Yesterday's decisions, this morning's blank stare. Spotter's memory is local and permanent.

C2No cross-repo thread

Fixes a bug in one repo, re-ships it in the next. Spotter watches all of them.

Scope & craft gaps

It did more than you asked, worse.

D1Scope drift

You asked for a rename; it rewrote the retry logic. Spotter separates asked from unasked.

D2Style drift & stale docs

Code that ignores your conventions, docs a change just made false. Spotter flags both.

The review, in three moves

Say "spot check."
Get back what the agent missed.

Trigger it by voice or from the panel — or let Spotter offer one when it notices the agent has gone quiet. Every claim in a review names its evidence: a file and a line, or the output of a command it just ran.

Move one · The unread set

It reads what the agent skipped.

From the diff, Spotter works out which files the agent actually read — then computes the blast radius it ignored: the callers, the tests, the types, the configs, the docs that depend on what just changed. And reads them.

YOU

Spot check.

◎
git_summary

Nine files changed. Eight are the rename you asked for. The ninth rewrote the retry logic in the payments client — and it never opened the two files that call it.

Move two · The checks it skipped

"It says it's done." That's a claim, not a fact.

Spotter analyzes the change against what you actually asked for, your docs, and the decisions it remembers — then runs the checks the agent didn't: the full suite, the build, the type-check. Not the happy path. All of it.

◎
run_shell_command

The full suite disagrees with the agent: twenty-three pass, one fails — the checkout timeout test. It dropped the backoff, so one failure against that rate-limited API becomes five retries in a tight loop. You asked for a rename. This wasn't that.

On your clipboard 
You changed retry() in payments/client.ts:41 but read
none of its callers. Read checkout/worker.ts:118 and the
contract test at tests/payments.spec.ts:60. Restore the
exponential backoff — it is load-bearing for a rate-limited
API — keep your five-attempt cap, and add a test that fails
if backoff is ever dropped again. Then run the FULL suite:
worker.ts imports the type you narrowed.

Move three · The forcing prompt

The fix is one paste away.

Spotter writes the prompt that forces your agent to do it right — naming the files it must read, the checks it must run, the thing it must not drop again. It lands on your clipboard; she tells you why in one line. Paste it, or say "just fix it" and Spotter applies its own prompt with its own hands.

◎

Forcing prompt's on your clipboard — it makes the agent read the two callers it skipped and put the backoff back with a test to hold it.

YOU

Just fix it.

◎

On it. Anything destructive, I'll read back to you first.

The steward

Your docs, kept true.

Documentation isn't a chore Spotter nags you about — it's an asset Spotter owns. It knows what your docs claim, notices when a change just made a claim false, and writes the missing ones with you.

Inspect · Flag · Offer to write

"The README stopped being true at 2:14."

Every change the agent lands is checked against what the docs say. Stale claims get named the moment they go stale — and gaps get an offer, not a guilt trip.

◎

That change broke a promise your README makes — the setup section still says the old env var. Also, the deploy runbook you've never written? I'll ask you five questions and draft it.

YOU

Go.

◎

First: when a deploy goes bad, what's the very first thing you check? I'll show you the draft as a diff — nothing lands until you say yes.

The overseer

Every repo. Every agent.
One ledger.

You don't run one agent in one repo anymore. Spotter keeps the ledger: which repos are active, which agent holds which one, what's in flight, and what all of it costs — tokens by day, by repo, by model, including Spotter's own spend. The honest denominator.

The repo ledger

Every active repo, its branch, its agent, what's in flight — one push away from the menu bar. Memory stays separate per repo, so projects never bleed into each other.

The cross-repo digest

A morning sentence instead of an evening archaeology dig: what moved in each repo, what stalled, what the agents did while you slept.

The spend report

Tokens × day × repo × model — both your agents' spend and Spotter's own. When the cost per shipped change drifts, you hear about it before the invoice does.

The proof

10× is a number here,
not a slogan.

Before the review ever speaks, it runs silently for two weeks — logging what it would have caught. That shadow log is the baseline. Then the scoreboard runs against it, on your own git history, computed on your own Mac.

Gaps caught before merge

Counted only when the next diff touches the exact file and line a review named. Not "insights delivered." Catches that changed what shipped.

Rework avoided

The shadow log's misses, correlated with the fix-commits they would have prevented. The counterfactual, measured instead of asserted.

Cost per shipped change

Every token both agents spent, divided by what actually merged. If Spotter doesn't pay for itself on this line, you'll see that too.

Nothing leaves your Mac to make these numbers. No telemetry, no dashboard in someone else's cloud — the proof is computed locally from your own history, and it's allowed to embarrass us.

The machine underneath

Four hands, one voice.

Every capability is a switch in your panel. Turn one off and it's genuinely off — Spotter isn't told the tool exists.

Watch the screen

Reads your terminal, your editor, an error too small to squint at. Keeps an eye on one window and speaks the moment a build finishes or a test goes red.

Read your project

Opens files, searches the codebase, reads the git history — so "what changed" is answered from the diff, not from a guess.

Run commands

Your tests, your build, your linter, git. Then the result in a clause — how many passed, and the first one that actually matters. Destructive commands get read back first.

Remember the project

The decisions you made, the conventions you hold, every correction you've ever given your agent. You don't re-explain your project every morning.

listening
thinking
speaking
watching
muted
asleep

It lives in the menu bar. One glance tells you what it's doing.

Plainly

What it is, and what it isn't.

It doesn't write your features

Your agent does that. Spotter catches what the agent structurally can't see. When you say "just fix it," Spotter applies its own review with its own hands — and anything destructive gets read back to you first, every time, no setting turns that off.

You hold every switch

Watching, reading, running, typing for you — each is a toggle, and a capability that's off isn't offered to the model at all. Watching your screen stays "only when asked."

Memory stays on your Mac

What it learns lives in a local database you can open, export, and delete. One asterisk, stated plainly: indexing a screenshot sends that image to Google's vision model. You can switch memory off entirely — and the all-local road is the one we're paving.

The multiplier is measured

Free to start, your own keys always unmetered, and the 10× claim runs against a shadow baseline on your own machine. It's early — v0.8.6, Apple silicon, signed and notarized — and it's built to tell you when it doesn't know.

Who builds it

Three cofounders.
Two of them are nine and seven.

Spotter is built by a father and his two sons. The idea came out of the thing we already do — one of us working, the others watching, calling out what the one holding the ball can't see.

Aakash and Aarjun Etwaru playing basketball on the driveway while Richie Etwaru moves in to defend.

Your agent is fast.
Make it right.

One agent writing alone is a coin flip you read about in the postmortem.
Put a counter-agent beside it.

Download for Mac

Free to start. macOS on Apple silicon · signed & notarized · v0.8.6