⚡ Getting Started

Quickstart Guide

This guide walks you through a complete CodeSleuth AI session from activating the Orchestrator to receiving a final product critique. The pipeline is driven by human gate commands — you stay in control at every critical transition.

⚠️

Human Gates Are Non-Negotiable

The pipeline never auto-advances between stages. You must issue the appropriate gate command to move forward. This is by design — you retain full control over when each stage runs.

Activating the Pipeline

The pipeline works in any AI CLI or IDE that supports system-prompt loading. The universal activation phrase is:

Start agent 0

This phrase is mapped in CLAUDE.md (and synced to all other AI tools) to load 0__Orchestrator_Agent.md. You can activate any agent directly:

Phrase	Activates	File
`Start agent 0`	Orchestrator	`0__Orchestrator_Agent.md`
`Start agent 1`	Discovery	`1__Product_Discovery_Agent.md`
`Start agent 2`	Planning	`2__Technical_Planning_Agent.md`
`Start agent 3`	Builder	`3__Application_Builder_Agent.md`
`Start agent 4`	Critic	`4__Codebase_Product_Critic_Agent.md`
`Start agent 5`	Security	`5__Application_Security_Agent.md`
`Start agent 6`	Verifier	`6__Codebase_Verifier_Agent.md`

Multi-Tool Compatibility

The agent activation rules are stored in CLAUDE.md and propagated to all AI tools by running:

node .cli/sync/sync-cli-instructions.mjs

This stamps rules to: .clinerules/ (Cline), .continue/rules/ (Continue), .cursor/rules/ (Cursor), .github/copilot-instructions.md (GitHub Copilot), .kiro/steering/ (Kiro), .agents/ (Antigravity), and AGENTS.md (Codex, OpenCode, Devin, Amp, Factory.ai, Zed).

Each tool's rule file includes the full Agent 0 Startup Protocol — the verbatim banner, build targets table, and welcome message — so all models produce consistent output on Start agent 0.

Step-by-Step Session

Activate the Orchestrator

Type "Start agent 0" in your AI CLI or IDE (case-insensitive). The Orchestrator reads config/context.json, checks for registered projects, then outputs the startup banner:

✅ Setup verified — no registered projects found. Starting new project kickoff.

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  ██████╗ ██████╗ ██████╗ ███████╗███████╗██╗     ██╗   ██╗████████╗██╗  ██╗
 ...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  CodeSleuth AI — Autonomous Software Engineering Pipeline
  ┌─────────────────────┬──────────────────────────────────────────────┐
  │ Pipeline            │ Discovery → Planning → Builder → ...         │
  │ Context Backends    │ Coordination: sqlite · ...                   │
  │ Commands            │ !help · !plan · !build · !verify · ...       │
  └─────────────────────┴──────────────────────────────────────────────┘

Agent 0 — Orchestrator is active.
To begin, tell me about the project you'd like to build...

2
Send Your Project Brief

Describe your project. You can be brief or detailed. For briefs over 500 words, Discovery activates fast-track mode and skips some structured questions.
```
I want to build a SaaS invoicing tool for freelancers.
It should support recurring invoices, Stripe payments,
PDF export, and a client portal.
```
3
Complete the Discovery Phase

Discovery Agent (Agent 1) asks one question per message across up to 15 phases — clarifying platform, users, features, monetization, and data model.

ℹ️

Use !braindump to dump all thoughts at once. Use !spec to preview the spec draft. Use !compile when satisfied.

Discovery outputs:
- artifacts/discovery/feature-spec.md — full implementation spec
- artifacts/pipeline/HANDOFF.json (v1) — machine-readable summary
4
Open the Planning Gate: !plan

Issue !plan to transfer control to the Technical Planning Agent. The Planner produces all artifacts in a single pass:
- TDD.md — Technical Design Document with test contracts
- INTERFACES.md — API and component contracts
- SCHEMA.md — Database schema
- TASK-GRAPH.md — Ordered implementation task graph with Parallelism Map
- artifacts/build/contracts/ — Zod schemas + OpenAPI stubs
- artifacts/build/FILE_OWNERSHIP_MAP.md — file → task ownership
5
Open the Build Gate: !build

Review the planning documents, then issue !build. The Builder runs continuously — implementing tasks, checkpointing every 3–5 tasks, and validating against contracts.
```
!build
```
ℹ️

Need to change scope mid-build? Use !change [description]. The Orchestrator produces a blast radius report before any implementation changes.
6
Open the Critic Gate: !critic

Critic Agent (Agent 4) completes the 12-Dimension Product Scorecard and performs a full accountability-driven product survival review — while the codebase is fresh and before security hardening locks in the architecture.
```
!critic
```
Output: artifacts/critique/CRITICISM.md with scorecard, ranked priorities, and product verdict.
7
Open the Security Gate: !security

Security Agent (Agent 5) runs a tiered 20-domain security review. Complexity tier determines scope.
```
!security
```
Simple 5 domains Standard HIGH+ domains Complex all 20 domains
8
Open the Verification Gate: !verify

Verifier Agent (Agent 6) performs QA, checks spec compliance, validates contracts, runs the Performance Budget Gate, and issues a final SHIP or NO-SHIP verdict.
```
!verify
```
Output: artifacts/verification/VERIFICATION_REPORT.md with SHIP/NO-SHIP verdict.

Key Commands at a Glance

Command	What It Does
!help	Show available commands for the current stage
!status	Display current pipeline stage and agent status
!plan	Open Discovery → Planning gate and begin full contract planning
!change [desc]	Initiate a spec change — triggers blast radius report
!pattern-add	Capture current implementation as a reusable pattern
!docs	Generate living documentation from current artifacts
!reset	Reset pipeline to initial state (requires confirmation)

✅

You're ready!

For a deeper understanding of how the pipeline works, read the Architecture Overview. For all available commands, see the Command Reference.