The Event Horizon of Software Quality. Adapted for Google Antigravity IDE from github/spec-kit. Version: 1.1.0
Welcome to the Antigravity Edition of Spec-Kit. This system is architected to empower your AI pair programmer (Antigravity) to drive the entire Software Development Life Cycle (SDLC) using two powerful mechanisms: Workflows and Skills.
In this edition, Spec-Kit commands have been split into two interactive layers:
- Workflows (
/command): High-level orchestrations that guide the agent through a series of logical steps. The easiest way to run a skill is by typing its corresponding workflow command. - Skills (
@speckit.name): Packaged agentic capabilities. Mentions of a skill give the agent immediate context and autonomous "know-how" to execute the specific toolset associated with that phase.
To understand the power of Skills in Antigravity, read the docs here: https://antigravity.google/docs/skills
To enable these agent capabilities in your project:
- Add the folder: Drop the
.agent/folder into the root of your project workspace. - That's it! Antigravity automatically detects the
.agent/skillsand.agent/workflowsdirectories. It will instantly gain the ability to perform Spec-Driven Development.
💡 Compatibility Note: This toolkit is fully compatible with Claude Code. To use it with Claude, simply rename the
.agentfolder to.claude. The skills and workflows will function identically.
The toolkit is organized into modular components that provide both the logic (Scripts) and the structure (Templates) for the agent.
.agent/
├── skills/ # @ Mentions (Agent Intelligence)
│ ├── speckit.analyze # Consistency Checker
│ ├── speckit.checker # Static Analysis Aggregator
│ ├── speckit.checklist # Requirements Validator
│ ├── speckit.clarify # Ambiguity Resolver
│ ├── speckit.constitution # Governance Manager
│ ├── speckit.diff # Artifact Comparator
│ ├── speckit.implement # Code Builder (Anti-Regression)
│ ├── speckit.migrate # Legacy Code Migrator
│ ├── speckit.plan # Technical Planner
│ ├── speckit.quizme # Logic Challenger (Red Team)
│ ├── speckit.reviewer # Code Reviewer
│ ├── speckit.specify # Feature Definer
│ ├── speckit.status # Progress Dashboard
│ ├── speckit.tasks # Task Breaker
│ ├── speckit.taskstoissues# Issue Tracker Syncer
│ ├── speckit.tester # Test Runner & Coverage
│ └── speckit.validate # Implementation Validator
│
├── workflows/ # / Slash Commands (Orchestration)
│ ├── 00-speckit.all.md # Full Pipeline
│ ├── 01-speckit.constitution.md # Governance
│ ├── 02-speckit.specify.md # Feature Spec
│ ├── ... (Numbered 00-11)
│ ├── speckit.prepare.md # Prep Pipeline
│ └── util-speckit.*.md # Utilities
│
└── scripts/ # Shared Bash Core (Kinetic logic)
| Phase | Workflow Trigger | Antigravity Skill | Role |
|---|---|---|---|
| Pipeline | /00-speckit.all |
N/A | Runs the full SDLC pipeline. |
| Governance | /01-speckit.constitution |
@speckit.constitution |
Establishes project rules & principles. |
| Definition | /02-speckit.specify |
@speckit.specify |
Drafts structured spec.md. |
| Ambiguity | /03-speckit.clarify |
@speckit.clarify |
Resolves gaps post-spec. |
| Architecture | /04-speckit.plan |
@speckit.plan |
Generates technical plan.md. |
| Decomposition | /05-speckit.tasks |
@speckit.tasks |
Breaks plans into atomic tasks. |
| Consistency | /06-speckit.analyze |
@speckit.analyze |
Cross-checks Spec vs Plan vs Tasks. |
| Execution | /07-speckit.implement |
@speckit.implement |
Builds implementation with safety protocols. |
| Quality | /08-speckit.checker |
@speckit.checker |
Runs static analysis (Linting, Security, Types). |
| Testing | /09-speckit.tester |
@speckit.tester |
Runs test suite & reports coverage. |
| Review | /10-speckit.reviewer |
@speckit.reviewer |
Performs code review (Logic, Perf, Style). |
| Validation | /11-speckit.validate |
@speckit.validate |
Verifies implementation matches Spec requirements. |
| Preparation | /speckit.prepare |
N/A | Runs Specify -> Analyze sequence. |
| Checklist | /util-speckit.checklist |
@speckit.checklist |
Generates feature checklists. |
| Diff | /util-speckit.diff |
@speckit.diff |
Compares artifact versions. |
| Migration | /util-speckit.migrate |
@speckit.migrate |
Port existing code to Spec-Kit. |
| Red Team | /util-speckit.quizme |
@speckit.quizme |
Challenges logical flaws. |
| Status | /util-speckit.status |
@speckit.status |
Shows feature completion status. |
| Tracking | /util-speckit.taskstoissues |
@speckit.taskstoissues |
Syncs tasks to GitHub/Jira/etc. |
The following skills are designed to work together as a comprehensive defense against regression and poor quality. Run them in this order:
| Step | Skill | Core Question | Focus |
|---|---|---|---|
| 1. Checker | @speckit.checker |
"Is the code compliant?" | Syntax & Security. Runs compilation, linting (ESLint/GolangCI), and vulnerability scans (npm audit/govulncheck). Catches low-level errors first. |
| 2. Tester | @speckit.tester |
"Does it work?" | Functionality. Executes your test suite (Jest/Pytest/Go Test) to ensure logic performs as expected and tests pass. |
| 3. Reviewer | @speckit.reviewer |
"Is the code written well?" | Quality & Maintainability. Analyzes code structure for complexity, performance bottlenecks, and best practices, acting as a senior peer reviewer. |
| 4. Validate | @speckit.validate |
"Did we build the right thing?" | Requirements. Semantically compares the implementation against the defined spec.md and plan.md to ensure all feature requirements are met. |
🤖 Power User Tip: You can amplify this pipeline by creating a custom Claude Code (MCP) Server or subagent that delegates heavy reasoning to Gemini Pro 3 via the
geminiCLI.
- Use Case: Bind the
@speckit.validateand@speckit.reviewersteps to Gemini Pro 3.- Benefit: Gemini's 1M+ token context and reasoning capabilities excel at analyzing the full project context against the Spec, finding subtle logical flaws that smaller models miss.
- How: Create a wrapper script
scripts/gemini-reviewer.shthat pipes thetasks.mdand codebase togemini chat, then expose this as a tool to Claude.
These workflows function as the "Control Plane" of the project, managing everything from idea inception to status tracking.
| Step | Workflow | Core Question | Focus |
|---|---|---|---|
| 1. Preparation | /speckit.prepare |
"Are we ready?" |
The Macro-Workflow. Runs Skills 02–06 (Specify |
| 2. Migration | /util-speckit.migrate |
"Can we import?" |
Onboarding. Reverse-engineers existing code into spec.md, plan.md, and tasks.md. |
| 3. Red Team | /util-speckit.quizme |
"What did we miss?" | Hardening. Socratic questioning to find logical gaps in your specification before you plan. |
| 4. Export | /util-speckit.taskstoissues |
"Who does what?" |
Handoff. Converts your tasks.md into real GitHub/Jira issues for the team. |
| 5. Status | /util-speckit.status |
"Are we there yet?" | Tracking. Scans all artifacts to report feature completion percentage. |
| 6. Utilities |
/util-speckit.diff /util-speckit.checklist
|
"What changed?" | Support. View artifact diffs or generate quick acceptance checklists. |
Stage 1: Inception
-
Legacy Project?
$\to$ Run/util-speckit.migrate. -
New Feature?
$\to$ Run/speckit.prepare.
Stage 2: Hardening
- Run
/util-speckit.quizmeto catch edge cases. - Run
/speckit.prepareagain to regenerate the Plan based on restricted specs.
Stage 3: Handoff
- Run
/util-speckit.taskstoissuesto sync with your board.
Once the .agent folder is present, you can talk to your agent as a partner. You can trigger a full process using a slash command or reference a specific capability using a skill mention.
Example Conversation:
Developer: "/02-speckit.specify Add a real-time notification system using WebSockets."
Antigravity: "Understood. Executing the @speckit.specify skill. Creating feature branch
005-notificationsand drafting the initial specification..." (Antigravity creates branch, drafts spec.md)Antigravity: "Specification ready. I've identified some ambiguity in the reconnection strategy. Should I use @speckit.clarify to resolve this?"
Developer: "Yes, use @speckit.clarify." (Antigravity executes the skill logic, interviewing the developer and updating the spec)
Antigravity: "The spec is now robust. I'm ready to trigger /04-speckit.plan and /05-speckit.tasks to prepare for implementation."
To get the most out of this system, follow these Spec-Driven Development (SDD) rules:
Never skip /01-speckit.constitution.
- This file is the "Context Window Anchor" for the AI.
- It prevents hallucinations about tech stack (e.g., "Don't use jQuery" or "Always use TypeScript strict mode").
- Tip: If Antigravity makes a style mistake, don't just fix the code—update the Constitution so it never happens again.
Don't rush to code. The workflow exists to catch errors cheaply before they become expensive bugs.
- Ambiguity Layer:
/03-speckit.clarifycatches misunderstandings. - Logic Layer:
/util-speckit.quizmecatches edge cases. - Consistency Layer:
/06-speckit.analyzecatches gaps between Spec and Plan.
When generating tasks.md (Skill 05), ensure tasks are atomic.
- Bad Task: "Implement User Auth" (Too big, AI will get lost).
- Good Task: "Create
UserMongoose schema with email validation" (Perfect). - Rule of Thumb: If a task takes Antigravity more than 3 tool calls to finish, it's too big. Break it down.
If you change your mind mid-project:
- Don't just edit the code.
- Edit the
spec.mdto reflect the new requirement. - Run
/util-speckit.diffto see the drift. - This keeps your documentation alive and truthful.
- Skill-Based Autonomy: Mentions like
@speckit.plantrigger the agent's internalized understanding of how to perform that role. - Shared Script Core: All logic resides in
.agent/scripts/bashfor consistent file and git operations. - Agent-Native: Designed to be invoked via Antigravity tool calls and reasoning rather than just terminal strings.
Built with logic from Spec-Kit. Powered by Antigravity.