Skip to main content
SuperAntigravity structures every feature as a linear pipeline: brainstorm → plan → implement → review → git. Each stage has a hard gate — you cannot advance until the gate condition is met. This prevents rework by ensuring decisions are validated before effort is spent on them.

​
Pipeline diagram

┌─────────────┐    ┌──────────────┐    ┌─────────────────┐
│ /brainstorm │───▶│    /plan     │───▶│   /implement    │
│             │    │              │    │                  │
│ Skill:      │    │ Skill:       │    │ Skills (loop):   │
│ brainstorm- │    │ writing-     │    │ confidence-check │
│ ing         │    │ plans        │    │ test-driven-dev  │
│             │    │              │    │ requesting-code- │
│ Output:     │    │ Output:      │    │ review           │
│ Design doc  │    │ Plan file    │    │                  │
│ APPROVED    │    │ docs/plans/  │    │ Output: commits  │
└─────────────┘    └──────────────┘    └────────┬────────┘
                                                 │
       ┌─────────────────────────────────────────┘
       ▼
┌─────────────┐    ┌──────────────┐
│   /review   │───▶│    /git      │
│             │    │              │
│ Agent:      │    │ Skill:       │
│ code-       │    │ (built-in)   │
│ reviewer    │    │              │
│             │    │ Output:      │
│ Output:     │    │ Merged PR or │
│ APPROVED or │    │ pushed branch│
│ CHANGES     │    │              │
└─────────────┘    └──────────────┘

​
Stage reference

StageCommandSkill / agentGateOutput
Design/brainstormbrainstorming, deep-research, architecture-designUser explicitly approves design docdocs/plans/*-design.md
Plan/planwriting-plansUser explicitly approves plandocs/plans/*-plan.md
Implement/implementconfidence-check, test-driven-development, requesting-code-reviewAll tasks complete, all tests greenFeature commits on branch
Review/reviewcode-reviewer agent, security-engineer agentAPPROVED or APPROVED WITH SUGGESTIONS verdictReview report
Ship/gitverification-before-completion, finishing-a-development-branchBranch is clean, verification passesMerged PR or pushed branch

​
Stage gates

Every transition between stages requires an explicit gate to pass. SuperAntigravity will not proceed until the condition is met.
  1. Design → Plan. You explicitly approve the design document. Acknowledging it is not enough — you must say you approve it.
  2. Plan → Implement. The plan file exists and every task has exact file paths and commands.
  3. Implement → Review. All tasks in the plan are complete and the full test suite is green.
  4. Review → Ship. The code-reviewer agent returns a verdict of APPROVED or APPROVED WITH SUGGESTIONS. A verdict of CHANGES REQUIRED blocks the gate.
  5. Ship. The verification-before-completion skill passes and the finishing-a-development-branch skill executes the merge or PR.
Gates protect you from the most expensive mistake in software development: spending hours implementing something that was poorly defined. The 10–15 minutes a design takes consistently saves hours of rework.

​
Interrupt protocols

Three situations can interrupt an in-progress pipeline: Bug discovered mid-implementation. SuperAntigravity loads the systematic-debugging skill, fixes the bug, adds a regression test, then resumes the plan from where it left off. It does not start a new pipeline stage. Scope change requested. Implementation stops immediately. The scope change returns to /brainstorm — it does not get silently absorbed into the current plan. The existing plan is not modified without a new approved design. Test suite fails catastrophically (more than 20 failures). SuperAntigravity loads the systematic-debugging skill and identifies the root cause of the mass failure before attempting individual fixes.

​
Explore each stage

/brainstorm

Turn vague ideas into approved designs before any code is written.

/plan

Write a detailed, bite-sized implementation plan before touching the codebase.

/implement

Drive feature implementation through TDD with per-task review gates.

/review

Validate implementation against the plan using specialist agents.

/git

Smart git operations with pre-ship verification and safe defaults.

Build docs developers (and LLMs) love

Get started for freeTalk to us