SPECTRE

Every piece of feature work enters through a single scope command. You don't memorize a sprawling menu of steps. Just one. So what does the slash command workflow actually do? The scope flow explores the edges of your idea and separates what's in, what's out, what's future, and what's explicitly anti-scope. For someone juggling several projects, that single entry point is the whole point.

SPECTRE ships as a set of slash commands, from /spectre:spectre-kickoff for hazy new features to /spectre:spectre-ship for final closeout. Plan, execute, prove, and handoff all live here too. The agent suggests the next command at the end of each response. So you rarely have to think about which one comes next.

SPECTRE routes specific jobs to specialized subagents: one to implement, one to analyze how existing code works, one to find reusable patterns, one to research the web, and one to review. The prompts call them for you, so you don't have to. That's a real time saver. Handing each subagent only the context its task needs keeps it focused. Less noise, fewer wrong turns.

Before you call a feature done, the prove step turns the scope and user flows into acceptance criteria and checks them through your test setup. It captures screenshots or video for visual work and builds a reviewable proof page. Anyone who's shipped a feature that "passed" but broke in the browser will see the value here.

Run a handoff command when your context window fills up or you switch tasks. SPECTRE writes a status snapshot and loads it into your next session automatically, merging the last few snapshots into one continuous memory. That means you can clear the window without losing the thread. Nice. No more re-explaining the whole project to a fresh session.

SPECTRE captures verified gotchas, decisions, patterns, and blockers as structured records. A size-bounded startup index surfaces only the relevant ones for a given task. The agent then loads the full record after checking it still applies. Over time your project accumulates context. It doesn't reset to zero each session.

Execute splits the plan into tasks, dispatches them to parallel subagents, and runs verification after each wave. Then it adds an opposite-runtime adversarial code review, followed by a repair pass. In plain terms, a different model checks the work. That catches blind spots a single agent tends to miss. It's not a guarantee. But it's a lot better than hoping.