SNIPER

Appearance

What is SNIPER? ​

SNIPER is an AI-powered framework for orchestrating Claude Code agent teams through structured project phases. It transforms how you build software with AI by replacing ad-hoc prompting with a governed, repeatable lifecycle.

The Problem ​

When you use Claude Code to build a project, you typically have a single conversation that handles everything -- research, planning, architecture, implementation. This works for small tasks but breaks down on real projects:

  • Context gets lost across long conversations
  • Architecture decisions are made without sufficient analysis
  • No quality gates catch bad decisions before they cascade
  • A single agent cannot hold the full context of a complex system

How SNIPER Solves This ​

SNIPER introduces a structured lifecycle with specialized agent teams. Instead of one agent doing everything, SNIPER spawns parallel teams of agents -- each with a specific role, persona, and file ownership boundary -- coordinated by a team lead.

The Protocol Phases ​

SNIPER breaks projects into seven protocol-driven phases:

  1. Discover -- A single agent (analyst) researches the codebase, assesses the problem space, and produces a discovery brief and codebase overview
  2. Define -- The product-manager produces the PRD and requirements specification
  3. Design -- The architect produces system architecture aligned with the PRD
  4. Solve -- Stories are sharded into implementable units with acceptance criteria
  5. Implement -- A 2-agent team (fullstack-dev, qa-engineer) writes code and tests in isolated worktrees
  6. Review -- A single agent (code-reviewer) performs multi-faceted code review with scope validation, standards enforcement, and risk scoring
  7. Retro -- The retro-analyst captures learnings and codifies them into project memory

Each phase produces concrete artifacts (markdown files in docs/) and passes through a review gate before the next phase can begin.

Agent Teams ​

A SNIPER agent team consists of:

  • A team lead (you, via Claude Code) who coordinates but does not produce artifacts
  • Teammates spawned as sub-agents, each with a composed persona
  • Tasks with explicit dependencies, file ownership, and output targets
  • Coordination rules that define which teammates need to align

The team lead enters Claude Code's delegate mode (Shift+Tab) and manages the team -- unblocking dependencies, facilitating API contract alignment, and enforcing quality.

Persona Composition ​

Each teammate's identity is assembled from four layers:

  • Process layer -- their role (analyst, architect, developer, QA engineer)
  • Technical layer -- their expertise (backend, frontend, security, AI/ML)
  • Cognitive layer -- their thinking style (systems thinker, devil's advocate, user empathetic)
  • Domain layer -- industry-specific knowledge from a domain pack

These layers are merged into a spawn prompt template that gives the agent deep, focused context for their specific task.

Review Gates ​

Before any phase advances, its output passes through a review gate. Gates have three modes:

  • Strict -- the human must explicitly approve (used for architecture and code)
  • Flexible -- auto-advance with async review (used for discovery and story creation)
  • Auto -- no gate (not recommended for critical phases)

Each gate evaluates the phase's artifacts against a checklist of quality criteria, producing a structured PASS/WARN/FAIL report.

What Makes SNIPER Different ​

Structured, not ad-hoc. Every phase has a defined team, defined outputs, and a quality gate. There is no ambiguity about what happens next.

Parallel, not serial. Discovery agents research simultaneously. Planning agents work in parallel (with dependency management). Implement phase developers write code concurrently.

Self-contained stories. The plan phase produces stories that embed all context from the PRD and architecture. A developer reading only the story file has everything needed to implement it.

File ownership boundaries. Each agent owns specific directories. Backend developers cannot modify frontend code and vice versa. This prevents conflicts and maintains separation of concerns.

Memory and learning. SNIPER tracks conventions, anti-patterns, and decisions across executions. Retrospectives automatically codify lessons learned into the memory system, which is injected into future spawn prompts.

When to Use SNIPER ​

SNIPER works best for:

  • Greenfield projects that need full planning and governance
  • Major rewrites of existing systems
  • Projects with clear phases (research, plan, build)
  • Teams that want repeatable, auditable AI-assisted development

For smaller tasks, SNIPER also offers lightweight protocols:

  • feature -- plan, implement, and review a well-understood feature with clear requirements
  • patch -- implement and review a small change to existing code
  • ingest -- reverse-engineer documentation from an existing codebase
  • explore -- research and analysis only (discover phase)
  • refactor -- analyze, implement, and review code restructuring
  • hotfix -- emergency fix with no gate checks (implement only)

Next Steps ​