SPECTRE is an agentic coding workflow designed for product builders who want consistent, high-quality outcomes from AI coding agents. Built as a slash command framework for Claude Code, it structures the entire software development lifecycle using the SPECTRE sequence: Scope, Plan, Execute, Clean, Test, Rebase, and Evaluate. By providing a step-by-step prompt-based workflow, SPECTRE reduces ambiguity and aligns human intent with AI execution, enabling developers to 10-100x their output. It caters to anyone building software—from indie hackers to technical PMs—with a repeatable process that works on both greenfield projects and legacy codebases spanning hundreds of thousands of lines of code. Its core value is transforming the chaotic, unpredictable nature of AI coding into a disciplined, rapid waterfall methodology that produces working code faster while maintaining quality.
The primary pain point SPECTRE solves is the unpredictability and inconsistency of AI coding agents. When scope, user experience, and implementation plans remain ambiguous, large language models are forced to fill in gaps, often producing spaghetti code, conflicts, and generic output known as AI slop. This ambiguity kills productivity and undermines trust in AI-assisted development. SPECTRE directly addresses this by enforcing specificity through structured prompts and canonical documents. For real product work—not trivial toy features—ambiguity is the enemy. By making it easy to provide detailed context, SPECTRE enables agents to work autonomously for extended periods, delivering results that align with the builder's vision. The result is that developers spend less time correcting errors and more time shipping valuable features.
The first major feature group is the core SPECTRE workflow itself: Scope, Plan, Execute, Clean, Test, Rebase, and Evaluate. Each phase is invoked via slash commands like /spectre:scope, /spectre:plan, and /spectre:execute. These commands guide the user through generating canonical documents stored in docs/tasks/{topic}/specs—such as scope.md, plan.md, tasks.md, and code_review.md. These documents serve as shared context between human and agent, ensuring alignment on what is being built and what is deliberately not built. The workflow automatically suggests the next step, so users never have to remember what command to run next. This structured approach transforms fuzzy feature ideas into actionable, well-defined tasks that an AI can execute without repeatedly asking for clarification, dramatically reducing context-switching and rework.
admin
The second major feature group is session memory and context management, provided by the /spectre:handoff and /spectre:forget commands. Session memory allows SPECTRE to maintain and accumulate context across multiple Claude Code sessions. When the context window approaches 160k tokens, users run /spectre:handoff to generate a status report that automatically loads into the next session. The /spectre:forget command clears memory when switching to a completely different topic. This prevents the agent from losing track of progress, decisions, and pending tasks. Subagents like @spectre:sync review the last three status reports and merge them into a continuous memory. This ensures that complex multi-session feature development remains coherent, and users can pick up exactly where they left off without re-explaining the entire context each time.
The third feature group is the Evaluate and learning system, which combines architecture review with knowledge capture. The /spectre:evaluate command triggers an Opus 4.6 subagent to perform a principal-level architecture review of completed work while simultaneously capturing durable project knowledge into reusable skills. These skills auto-load in future sessions through a SessionStart hook that injects the project's knowledge registry into context. When a task matches a trigger word (e.g., "auth" triggers a feature-auth-flows skill), Claude loads the full skill before searching the codebase. Captured knowledge includes gotchas, architectural decisions, feature dossiers, reusable patterns, and multi-step procedures. This knowledge compounds across sessions, making each subsequent interaction faster and more accurate. Users can also run independent commands like /spectre:learn, /spectre:architecture_review, or /spectre:recall to access specific knowledge on demand.
SPECTRE works through an orchestrated workflow that begins with a single slash command and progresses through each phase with automated suggestions. Users typically start with /spectre:scope to define requirements, constraints, and success criteria. The agent asks targeted questions—only those it cannot answer from codebase research—to produce a crisp scope document. Next, /spectre:plan researches the codebase and creates an implementation plan, which can be a high-level technical design or a concise set of tasks. Execution with /spectre:execute uses parallel subagents (@spectre:dev, @spectre:tester, etc.) to implement features in waves, each subagent producing completion reports for the next. Validation is handled by /spectre:validate, which breaks down tasks and dispatches verification subagents. Throughout, /spectre:handoff keeps context windows clean, and /spectre:ship provides autonomous end-to-end feature delivery from brain dump to pull request with zero confirmation gates.
Concrete use cases include building Subspace, a 250,000-line Tauri/Rust/React desktop application, and New June, a React Native AI Agent with a GPS rangefinder for golfers. Both were developed using SPECTRE as the daily driver workflow. A typical day for the creator involves starting with /spectre:scope for new features, refining UX with /spectre:ux if needed, then planning with /spectre:plan, executing with /spectre:execute, cleaning with /spectre:clean, testing with /spectre:test, rebasing with /spectre:rebase, and finally evaluating with /spectre:evaluate. For low-complexity tasks, /spectre:ship autonomously scopes, implements with TDD, sweeps, rebases, and opens a PR. Bugs are handled with /spectre:fix for structured debugging. This workflow enables an ex-Meta, ex-Amazon technical product manager to build, ship, and iterate on products with 100x the complexity of anything built before, delivering working code quickly and iterating from a solid baseline.
SPECTRE is designed for product builders—technical product managers, indie hackers, full-stack developers, and engineering leads who use Claude Code or Codex as their primary coding agent. It works on both new projects and massive codebases of hundreds of thousands of lines, supporting websites, React Native apps, native desktop apps, and personal software. The tool is installed via marketplace commands within Claude Code or a simple npx command for Codex. It is open source under the MIT license, with an active repository on GitHub where users can report issues and contribute. The core philosophy is that great inputs produce great outputs, and that structured workflows are the easiest way to provide the specificity LLMs need. By reducing ambiguity and accumulating institutional memory, SPECTRE makes high-quality, repeatable AI-driven development accessible to anyone building real products. Whether you are shipping your first feature or managing a complex codebase, SPECTRE helps you ship faster with confidence.
Product builders, technical product managers, indie hackers, full-stack developers, and engineering leads who use Claude Code or Codex as their primary AI coding agent. The workflow is designed for those building real products—from websites and React Native apps to native desktop applications—who need consistent, high-quality output from AI agents. It suits both new projects and large existing codebases with hundreds of thousands of lines of code. The creator, an ex-Meta and ex-Amazon technical product manager, built SPECTRE to enable rapid, repeatable development for anyone who wants to ship features 10-100x faster without sacrificing code quality.