SPECTRE: A Workflow for Product Builders

Scope → Plan → Execute → Clean → Test → Rebase → Evaluate

SPECTRE is a slash command based workflow for Claude Code designed to help you do ONE THING more, faster, and with higher quality.

🚀 Ship Product Features

SPECTRE's workflow covers the complete software development lifecycle - from scoping a feature, finalizing user flows, writing the technical design, generating tasks, executing the tasks, code review, validating the work, cleaning up and testing the work, and finally generating documentation as Skills your agent auto-loads when relevant.

It has been tested on brand new codebases and codebases with hundreds of thousands of lines of code. Its been tested building websites, react native apps, native desktop apps, and personal software.

SPECTRE helps you get higher quality and more consistent results from your coding agent, while they work autonomously for much longer, so 10-100x'ing your typical output feels easy and more importantly, repeatable.

SPECTRE hero

⚡ Quick Start

Within Claude Code

# Add marketplace and install
/plugin marketplace add Codename-Inc/spectre
/plugin install spectre@codename

Then start building:

/spectre:scope

That's it. You just start with 1 command to build features.

Within Codex

npx @codename_inc/spectre install codex

When prompted, choose project to install into the current repo's .codex, or user to install into ~/.codex.

If you choose project, run codex from that repo.

If you choose user, restart or open your normal Codex session.

Then run a Spectre command such as:

spectre-scope

Current Codex behavior:

user scope installs Spectre workflow skills, runtime, agents, hooks, and shared skills under ~/.codex
project scope installs the same Codex home structure inside ./.codex
project installs create .spectre/manifest.json and project-local Codex config
session continuity uses Codex's official SessionStart hook for the visible status line and keeps the latest handoff in a managed AGENTS.override.md block
learned project skills still live under .agents/skills/ and are synced into Codex config

Capability matrix: docs/codex-capability-matrix.md Session continuity deep dive: docs/codex-sessionstart-memory.md

SPECTRE scope command

🔁 How It Works

run one of the kickoff prompts in Claude Code - /spectre:scope is the main command for building new features, but also /spectre:kickoff for high ambiguity new features (includes web research), /spectre:research for codebase research "how might we build …” style Qs, or /spectre:ux_spec to define user flows, components, and layout for a new feature.
follow the prompts/instructions to create the related canonical document and Claude Code will suggest the next step in the SPECTRE workflow automatically (e.g., going from scope to plan to tasks and so on)
turn off auto-compact in Claude Code settings (/config) and run /spectre:handoff when the context window is getting full, then run /clear to start the next session. (/spectre:forget when you are switching gears)
SPECTRE saves canonical docs to a docs/tasks/{topic}/specs directory, and status updates from /spectre:handoff to docs/tasks/{topic}/session_logs directory. We recommend keeping this directory checked into git to be able to reference docs in the future.
thats it. scope features, plan features, build features, clean up/test features, document features, learn from features, repeat.

🎯 Core SPECTRE Principles

Great Inputs → Great Outputs
Ambiguity is Death
One Workflow, Every Feature, Any Size, Any Codebase
Obvious > Clever

👻 SPECTRE Purpose

AI coding is changing product development, but why is it that Claude Code can still go off the rails? Why is it that some developers claim AI has 100x'd their output, while others still complain about the quality of the code it generates?

Let me introduce you to a very simple concept that you need to drill into your head. With coding agents:

💀 AMBIGUITY IS DEATH.

When the scope, ux, and plan are ambiguous, you must rely on the LLM to fill in the blanks. And while sometimes you can get lucky - especially for smaller features - for any real technology or product work, ambiguity is how you end up with spaghetti code, conflicts, and AI slop.

LLMs need specificity. And typically, providing the right level of specificity is a lot of work. Just think about the most detailed spec or technical design you’ve ever written. Takes days and sometimes weeks.

BUT --- you can use LLMs to make it EASY to provide that specificity. And that is exactly what SPECTRE does.

✅ Workflows = Easy Button

Prompt based workflows that generate canonical docs that you and your Agents are aligned on are how you get the best, highest quality, and most consistent results from AI Coding Agents.

They provide the necessary context, detail, and structure for the agent to ask the right questions, investigate the right details, and generate the right requirements, plans, tasks, code, tests, and more.

The better your prompt based workflows, the lower the ambiguity, the more AI can take on, the longer AI can work autonomously, the more easily you can multi-task, and suddenly you are 100x'ing your output.

📄 Canonical Docs

As a former PM I've lived the value of Canonical Docs (shout out Naomi Gleit). The reasons they work for Humans are the same reasons they work with AI Agents (see 💀 Ambiguity is Death)

In SPECTRE, the structured workflows generate some combination of the following canonical docs stored in docs/tasks/{topic/feature}/specs

scope.md - what are we building and importantly what are we NOT building
ux.md - the core user flows and components/layouts/interactions
plan.md - high level technical design and phasing
tasks.md - specific parent & sub-tasks to execute
code_review.md - prioritized code review feedback
gaps.md - task list of gaps identified from validation
.claude/skills/{feature_name}/skill.md - a skill for agents to auto-reference the work

Not all are required. Sometimes I have scope.md and then use Claude Code's plan mode. Sometimes I have a ux.md and a tasks.md. The key thing to remember is that docs are the context in context engineering.

💧 So.... Waterfall?

Yeah basically Rapid Waterfall.

Specificity up front forces clarity, reduces ambiguity, and leads to better 1st pass results.

THEN -- you can iterate on the feature set, ux, architecture, etc. at lightning speed. AI coding agents are 10x better at working around working existing code. It's why they are so good at refactors. Because they are working with a working established baseline.

Workflows make it easier and faster to get to working code.

From there, you can iterate and adapt before you ship.

📖 Background & Philosophy

About

SPECTRE is the result of over 12 months of daily Claude Code use.

These are the actual prompts I use and iterate upon non stop every day to build products.

With SPECTRE, I built a React Native based AI Agent + GPS Rangefinder for Golfers (New June (in closed Alpha)) and a 250k line Tauri/Rust/React desktop application called Subspace (in open Beta - https://www.subspace.build).

💡 Why

I created SPECTRE because I wanted:

a repeatable daily driver workflow that works on brand new projects, and large existing codebases.
a single workflow that works on both small & big features without being overwhelmed with process
a workflow that delivers robust engineering plans when needed, or a concise set of tasks if not
hands on planning but hands off execution
higher quality INPUT with LESS WORK so i can ensure the outputs are more aligned with my vision
a workflow that lets Agents learn my codebase, features, patterns, bugs, so I don't have to remember everything
stupid. simple. memory. agent sessions are aware of the ongoing thread of work (/spectre:handoff)

My Workflow Iteration Process

I improve these prompts daily, and I didn't just prompt Claude Code to generate these prompts. I iterated over many months, adjusting the prompts based on both the user experience of using them, and the quality of results that I got.

For example:

I iterated on /spectre:scope until I felt like the types of questions actually help me get clear on what I'm building, without asking questions that it could easily get from codebase research
I iterated on the /spectre:execute workflow until it successfully delivered large tasks in a single context window using subagents that deliver completion reports to handoff to the next subagents, use TDD effectively, and autonomously adapt the tasks based on what was discovered DURING development instead of blindly
I iterated on the /spectre:clean and /spectre:test workflows until it felt automatic that we were sticking to our linting rules, every new feature was well tested/covered, the commits were grouped logically with the appropriate amount of detail.
I iterated on the /spectre:evaluate learning workflow until 1) the agent automatically reached for the skills generated at the start of every conversation, 2) captured the right details and insights, and 3) proactively updated relevant skills as we make changes and learn more.
I iterated on the /spectre:handoff workflow until the status update had the appropriate detail/context, and worked perfectly if I'm working across MANY sessions or just one.

SPECTRE made products like New June and Subspace possible, and it is making it possible for me, an ex-Meta, ex-Amazon Technical Product Manager to build, ship, and

Spectre

Install / Use

README