A Crowd Over Your Shoulder

Background AI reviewers that watch as you code

The Frame

Review shouldn't wait for the pull request

amplifier-bundle-observers turns code review from a late one-time gate into "expert colleagues looking over your shoulder," running automatically in the background so issues get caught early — without breaking your flow.

And if that crowd is real, how big is it?

Traditional review
One gate, late, single perspective.
Observers
Watch each change as it lands, automatically.
The promise
Catch issues early without interrupting your flow.

Proof

Fifty observers, one author, four domains

The bundle ships a library of exactly 50 observer definitions spanning coding, writing, reasoning, and systems-thinking — built almost single-handedly by Paul Payne, who authored 33 of 36 commits.

So why isn't a single late review enough?

50

observer definitions (markdown files)

33/36

commits by Paul Payne

4

domains: coding, writing, reasoning, systems-thinking

3

modules run the bundle

The Tension

Traditional review fires late, and only once

Review at PR time arrives long after the thinking that produced the bug. It is single-perspective and never live — you hit the gate once, from one reviewer's point of view, well past the moment you could have changed course cheaply.

To escape that, you first need to know what an observer actually is.

The Unit

An observer is just a file — the same shape as an agent

Each observer is a markdown file with a YAML frontmatter block — name, model, timeout, tools — plus a markdown instruction body. The redesign into this shape landed deliberately in commit 54f23d4.

Now watch what happens when a change lands.

# observers/security-auditor.md
---
observer:
  name: Security Auditor
  model: claude-3-5-haiku-latest
  timeout: 30
tools:
  - grep
  - read_file
---
# Security Auditor
<markdown instruction body>

Mechanism — Live

Each cycle spawns the watchers in parallel

On the orchestrator:complete event after each cycle, a hook detects the changed files and spawns the watching observers in parallel on the fast Haiku model.

And the findings that come back? They're ranked.

Trigger — fires on orchestrator:complete after each cycle
Parallel — parallel_sync, semaphore-capped at max_concurrent 10
Fast model — 50/50 observers run claude-3-5-haiku-latest
Bounded — 30s per observer, skip on timeout

Mechanism — Signal

Findings are ranked, deduped, and auto-resolved

Every finding is ranked across five severity levels. Prior observations are fed back into each observer's prompt so live issues aren't re-reported, and fixed ones are marked resolved.

So the crowd sounds unstoppable — but here's the honest part.

Criticalhighest priority, sorted first
Highserious issues
Mediumworth addressing
Lowminor findings
Infoobservations only

The Turn

The "crowd watches everything" story is honest fiction

The default bundle turns on just 2 observers — security-auditor and code-quality. The 50 are a catalog you compose from. And one dogfooding session burned ~90 assistant turns chasing a self-referencing include that loaded the wrong observer set, with the fix "implemented but not yet tested."

Which points at what the real product actually is.

2

observers on by default (security-auditor, code-quality)

50

the catalog size you compose from

~90

assistant turns to diagnose one include bug

The Payoff

The win isn't 50 scanners — it's one composable observer

It began as a single default "Code Scanner" (commit 5fb0cbe), then was redesigned the same day (54f23d4) into composable markdown observers and expanded in bulk across domains. So the real product isn't a monolithic 50-scanner tool — it's one observer unit, the same shape as an agent, that you snap together into exactly the review crowd a project needs.

One file. Any size crowd. Any domain.

Sources

Research Methodology

Primary source: microsoft/amplifier-bundle-observers, verified via a fresh clone at /tmp/observers-src. Bundle version 0.1.1, MIT License. Status: early / experimental (v0.1.x).

Commands run (every fact re-derived independently):

find observers -name '*.md' | wc -l → 50 observer files
grep -rh 'model:' observers/ | sort | uniq -c → 50 use claude-3-5-haiku-latest, 0 sonnet
git log --format='%an' | sort | uniq -c | sort -rn → Paul Payne 33, dependabot 2, Brian Krabach 1 (36 commits)
cat bundle.md → trigger orchestrator:complete, parallel_sync, max_concurrent 10, timeout 30, skip on timeout; default observers security-auditor + code-quality
sed -n '14,22p' modules/hooks-observations/.../models.py → severity enum critical/high/medium/low/info
head -40 observers/security-auditor.md + commit 54f23d4 → markdown + YAML frontmatter redesign; commit 5fb0cbe → initial "Code Scanner" observer
ls modules/ → hooks-observations, hooks-observations-display, tool-observations
session-analysis/1460da3d/recommendations.md → ~90-turn include bug, fix "implemented but not yet tested"

Gaps / reported-only: The "~5-day marathon" and "one reviewer into ~50 specialists" framings are reported figures, not independently derivable — git shows feature work on ~4 working days (Jan 21, 22, 26, 27) within a ~12-day span, and the default bundle enables only 2 observers. No repo evidence of production adoption or issue counts; not claimed.

Primary contributor: Paul Payne (33 of 36 commits).