BUG-014
Stale rank index
useRankings.ts
An autonomous product team, built from agents
It finds its own work, ranks it, and never stops shipping.
Point it at a feature. A team of agents discovers what to build, throws out the slop, scores what survives, and ships sprints of fixes and enhancements. When the backlog runs low it discovers more, and keeps going. A human orchestrates and never writes a line of code.
Continuous discovery, not a one-shot idea list
Evidence-anchored intake filter
Fixes + enhancements every sprint
Self-replenishing backlog, automatically refilled
What makes it different
One loop that never stops
Most agent tools generate a list of ideas and stop. This runs the whole team on a cycle: discover, prioritize, ship a sprint of fixes and enhancements, then refill the backlog and go again.
Backlog
drains, refills, repeats
Stage
Hover or tap any node, or the green Replenish link, to see what it does.
Stage hand-off
Replenish (closes the loop)
Work in flight
1
Discover
Five read-only lenses (Flow, Runtime, Coverage, Consistency, Gates) sweep the feature in parallel, each hunting one kind of problem. Every candidate must cite a specific file:line, a reproducible flow, or a spec it violates. Anything unanchored, cosmetic-only, or already tracked is dropped before it reaches the backlog.
2
Prioritize
One deterministic pass scores every surviving candidate with (impact × fit) / effort, assigns stable IDs, and ranks the full list. Agents never score their own finds. A P1 bug always drains first, and two runs always produce the same ranking.
3
Sprint
A batch of 3 to 5 disjoint-file stories runs Builder, then Diff Reviewer, then Reviser at an 85% enhancement / 15% fix mix. The Reviewer is never the Reviser. Max two reviser rounds. Only what passes ships, and partial sprints still deliver the files that cleared.
4
Ship
Everything that clears the Definition of Done is committed and deployed. Native builds, SQL, and migrations stay gated for a human. The system supports two operating modes: standing authorization to ship automatically, or a pause at each sprint for human sign-off.
Replenish & repeat. At each sprint close, if ready stories drop below the low-water mark (default 3), the loop re-runs discovery, rotating one lens to control cost. An empty sweep pauses and notifies rather than spinning. This one step is what turns a pipeline into a loop.
Why the output isn't slop
Two jobs, kept strictly apart
The default failure of agentic discovery is confident, well-formatted nonsense. The fix is to make discovery a strict intake gate and the build a self-checking pipeline. Every move is either a human orchestrating or an agent doing, and the two never blur.
The orchestrator
Routes, never writes code
A human scrum-master slices work, writes tight briefs, scores, accepts, ships, and keeps the backlog. Not one line of feature code. It stays lean by passing pointers like file paths and symbol names, never pasting files into its own head.
The agents
Do the work, return receipts
Lens agents find work, the prioritizer scores it, the product agent writes stories, and builders ship them. Each returns a terse manifest, never a code dump, so the orchestrator stays sharp across dozens of hand-offs.
Evidence or it's dropped
Every candidate must cite a file:line, a
reproducible flow, or a spec it violates. No anchor, no intake. "This could be nicer" never makes it in.
Reviewer is not the Reviser
One agent audits a diff for runtime correctness; a different agent fixes what it flagged. A critic grading its own rework drifts into self-justification.
Agents never self-score
Discovery can't set its own impact or priority. One deterministic pass scores the whole filtered union against an anchored rubric, so two runs rank the same.
The roster
A full product team, dispatched as agents
Each role has a mode and a single job. Read-only roles always run in parallel; anything that writes the same file is sequenced, never raced.
| Role | Mode | Job |
|---|---|---|
| Orchestrator | scrum-master | Lifecycle, briefs, scoring, accept, ship, bookkeeping. Writes no feature code. |
| Discovery × 5 lenses | read-only | Each owns one lens, sweeps every surface, surfaces candidates with evidence. |
| Prioritization | write | Dedupe, score, rank, assign stable ids, write the backlog. |
| Product | read-only | Turn top items into dev-ready stories that meet a Definition of Ready. |
| Builder | write | Implement one story over one disjoint file set. |
| Diff Reviewer | read-only | Audit the diff for runtime correctness, rank findings P1 / P2 / P3. |
| Reviser | write | Fix P1 / P2, usually the original Builder resumed. Max two rounds. |
Inside discovery
Five lenses, each hunting one kind of problem
Run in parallel, every lens sweeps the whole feature but only through its own question. Convergence across lenses on one gap is the highest-confidence signal there is.
Flow
Dead ends, missing CTAs, multi-tap core jobs, states with no way out.
Runtime
Stale state and closures, wrong-state conditionals, broken CRUD wiring, off-by-one, null/NaN, empty/loading/error paths.
Coverage
Specced-or-listed but not actually built or usable. Real capability gaps against the design.
Consistency
House-style and pattern drift across surfaces, plus cross-document conflicts.
Gates
Brand and token violations, accessibility (labels and hit targets), AI-tells, and other hard-gate failures.
Signal vs. noise
Highest signal: human device reports and runtime-correctness audits. Lowest: generic best-practice suggestions, which the filter rejects.
The mechanics
Scored once, then built in disjoint slices
Prioritization is a single deterministic pass. The sprint that follows runs a Builder, a separate Reviewer, and a Reviser over file sets that never overlap.
Stage 02 · Prioritize
One number, computed the same way every time
An anchored rubric turns each item into impact, fit, and effort points, then a single deterministic pass ranks the whole union. Fit is persisted, ids are never reused, ties break impact then effort then id. Every input ends as scored, merged, rejected, or deferred, with no silent drops.
priority score = (impact × fit) / effort
Stage 03 · Sprint
Fixes and enhancements, shipped together
Each sprint pulls 3 to 5 disjoint-file stories at an 85% enhancement / 15% bug mix. Builder builds, a fresh Reviewer audits runtime correctness, a Reviser clears P1/P2 in at most two rounds. Any P1, regression, or device-reported bug is drain-first. Partial sprint? Ship only the files that passed.
85 / 15 mixdisjoint files onlymax 2 reviser rounds
Safety rails
It runs on its own, but never off a cliff
Humans keep the keys
| Native builds | routed to a human gate, never auto-shipped |
| SQL & migrations | blocked, queued for human review |
| Can't-see-in-source | renders & runtime go to a device report |
| Each ship | standing authorization, or pause for human approval |
When something breaks
| Regression | a shipped item that breaks reopens, exempt from do-not-propose |
| Bad ship | revert the deploy first, then fix forward |
| P1 crash | preempts the running sprint as a solo hotfix, then resumes |
| Empty sweep | discovery returns nothing valid? pause and notify, never spin |