Software built for you, by one AI lead and a crew of cheap agents.

Get interviewed before your agent guesses.

Type /grill-me and your agent stops, interviews you one batch of questions at a time, and ends with a short written summary of what you actually want, which you confirm before any work starts. Each question comes with concrete options and a recommended default, so answering takes seconds. Use it before a big feature, or mid-task when the work is drifting.

A read-only map of the code before anyone writes any.

The first step of any feature. A read-only investigator that returns the files involved, the patterns already in use, the closest existing feature to copy, and the risks, each with a file and line. It never edits anything, so it is safe to run on any repository, and its findings make every later step cheaper.

Turn a rough idea into a story you can approve.

Turns a one-line idea plus the researcher's findings into a one-page user story: who it is for, acceptance criteria you can test, edge cases, and what is explicitly out of scope. Written in plain language for an owner who does not read code, so approving it is a real decision rather than a rubber stamp.

A short technical brief build agents can follow.

Turns an approved story into a short technical brief: files to change, functions to reuse, data and permission rules that apply, and the tests that prove it. It reads your project's rules file first, so the brief follows your architecture instead of inventing one. Hand the brief to any coding agent.

Hard technical calls, decided with reasons.

A read-only judgement agent for the architecture, data-model and trade-off questions your lead agent should not push onto you. Give it the options and the evidence; it returns a decision, the reasons, and what would change its mind. It refuses business-policy questions that belong to the owner, and labels any answer given in your absence as provisional.

Screen designs you approve before anyone builds them.

Designs or redesigns a page or app screen through a retrieve, plan, style, render and critique loop, and delivers labelled artboards at desktop and phone width to approve. It looks at its own screenshots before critiquing them (a helper script renders both widths with headless Chromium). Produces a design to approve, not production code.

Prove every acceptance criterion with a test.

After the build, writes acceptance tests straight from the user story and runs them, so each criterion is either proven or reported as a gap. It works from the story rather than the code, which catches the cases where the builder did something plausible but not what was asked.

Compare what was built with what was approved.

A strict, read-only check of the implementation against the approved story and brief. It reports every gap grouped by severity, with file and line, and never edits a file. Run it before you open a pull request to find what was skipped, misread or quietly invented.

An independent review that names a failing case.

Reviews a pull request or a committed slice against your project's checklist: scope creep, permission and data-scope leaks, exposed errors and secrets, hollow or missing tests, and drift from your architecture rules. Every finding comes with a file, a line and a concrete failing case, so it can be confirmed or dismissed in a minute. It ends by listing what it did not look at. Read-only by design.

Make your test suite read as the app's spec.

Audits and extends a test suite until it reads as a complete, plain-language specification of the application: one named test per behaviour, covering success, validation failure and the edge case. Includes a gap-finding procedure and naming patterns. Useful when you inherit code nobody documented.

From a user's bug report to a verdict or a fix.

Takes a bug report from your app's 'report a problem' form, or any report with what happened and the steps taken, and works it to a written verdict: reproduced or not, the cause, and how sure it is. When the fix is certain and small it opens a pull request. Pairs with a routine so reports are triaged as they arrive.

Every change since the last release, written for users.

Surveys every change since the last version bump, splits it into individual user-facing changes, and writes one plain-language release entry per change, skipping internal refactors. Adapts to how your project stores release notes. No more release notes that just say 'bug fixes'.

Find the stale rules your agent keeps tripping on.

A self-audit of your agent configuration: CLAUDE.md, AGENTS.md, skills, agent-facing docs, settings and recent session history. It finds stale file references, contradictions, rules the code no longer follows and lessons worth writing down, and proposes each fix. Includes a script that checks every file path your rules mention still exists.