System Overview
Antigravity Kit is a modular AI agent system consisting of:
- 20 Specialist Agents - Role-based AI personas
- 36 Skills - Domain-specific knowledge modules
- 11 Workflows - Slash command procedures
- 2 Master Scripts - Validation and verification
High-Level Architecture
┌─────────────────────────────────────────────────────────────┐
│ USER REQUEST │
└────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ REQUEST CLASSIFICATION │
│ • Analyze intent (build, debug, test, deploy) │
│ • Identify domain (frontend, backend, mobile) │
│ • Detect complexity (simple, medium, complex) │
└────────────────────────┬────────────────────────────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌──────────────────┐ ┌──────────────────┐
│ WORKFLOW COMMAND │ │ DIRECT AGENT │
│ (Slash Command) │ │ ASSIGNMENT │
└────────┬─────────┘ └────────┬─────────┘
│ │
└────────────┬────────────┘
│
▼
┌──────────────────────────────────────┐
│ AGENT INITIALIZATION │
│ • Load agent persona │
│ • Load required skills │
│ • Set behavioral mode │
└─────────────┬────────────────────────┘
│
▼
┌──────────────────────────────────────┐
│ SKILL LOADING PROTOCOL │
│ 1. Read SKILL.md metadata │
│ 2. Load references/ (if needed) │
│ 3. Execute scripts/ (if needed) │
│ 4. Apply rules and patterns │
└─────────────┬────────────────────────┘
│
▼
┌──────────────────────────────────────┐
│ TASK EXECUTION │
│ • Analyze codebase │
│ • Apply best practices │
│ • Generate/modify code │
│ • Run validations │
└─────────────┬────────────────────────┘
│
▼
┌──────────────────────────────────────┐
│ VALIDATION LAYER │
│ • Security scan │
│ • Code quality (lint/types) │
│ • Test suite │
│ • Performance check │
└─────────────┬────────────────────────┘
│
▼
┌──────────────────────────────────────┐
│ RESULT DELIVERY │
│ • Present changes │
│ • Provide explanations │
│ • Suggest next steps │
└──────────────────────────────────────┘
Directory Structure
.agent/
├── ARCHITECTURE.md # System architecture
├── agents/ # 20 Specialist Agents
│ ├── frontend-specialist.md
│ ├── backend-specialist.md
│ ├── database-architect.md
│ └── ...
├── skills/ # 36 Skills
│ ├── react-best-practices/
│ │ ├── SKILL.md
│ │ ├── scripts/
│ │ └── references/
│ ├── api-patterns/
│ └── ...
├── workflows/ # 11 Slash Commands
│ ├── brainstorm.md
│ ├── create.md
│ ├── orchestrate.md
│ └── ...
├── rules/ # Global Rules
└── scripts/ # Master Validation Scripts
├── checklist.py
└── verify_all.py
Request Flow Diagram
Example: “Build a React dashboard with authentication”
1. REQUEST CLASSIFICATION
├─ Type: Build new feature
├─ Domain: Frontend + Backend
├─ Complexity: Medium-High
└─ Suggested: /create or /orchestrate
2. WORKFLOW SELECTION
└─ User chooses: /orchestrate (multi-agent approach)
3. ORCHESTRATOR DECOMPOSITION
├─ Frontend: Dashboard UI (React components)
├─ Backend: Auth API (JWT, session management)
├─ Database: User schema (Prisma)
└─ Testing: E2E auth flow
4. AGENT ASSIGNMENT
├─ frontend-specialist
│ └─ Skills: react-best-practices, tailwind-patterns, frontend-design
├─ backend-specialist
│ └─ Skills: api-patterns, nodejs-best-practices
├─ database-architect
│ └─ Skills: database-design, prisma-expert
└─ test-engineer
└─ Skills: testing-patterns, webapp-testing
5. SEQUENTIAL EXECUTION
├─ Frontend builds:
│ ├─ app/dashboard/page.tsx
│ ├─ components/DashboardLayout.tsx
│ └─ components/LoginForm.tsx
├─ Backend builds:
│ ├─ app/api/auth/login/route.ts
│ ├─ lib/jwt.ts
│ └─ middleware.ts
├─ Database builds:
│ └─ prisma/schema.prisma
└─ Testing builds:
└─ tests/auth.spec.ts
6. VALIDATION
├─ checklist.py
│ ✓ Security: No leaked secrets
│ ✓ Lint: No ESLint errors
│ ✓ Types: TypeScript passes
└─ verify_all.py
✓ E2E: Login → Dashboard works
✓ Accessibility: WCAG AA compliant
7. RESULT DELIVERY
└─ Complete codebase + documentation + test reports
Agent Selection
Routing Logic
The system uses multiple signals to select the right agent:
| Signal | Example | Selected Agent |
|---|
| Keywords | ”component”, “react”, “ui” | frontend-specialist |
| File context | Editing *.tsx files | frontend-specialist |
| Explicit mention | ”API”, “endpoint”, “server” | backend-specialist |
| Task type | ”debug”, “error”, “crash” | debugger |
| Domain | ”database”, “schema”, “sql” | database-architect |
Agent Selection Matrix
Request Domain → Agent Mapping:
┌──────────────────────┬─────────────────────┬──────────────────────────┐
│ Domain │ Primary Agent │ Skills Loaded │
├──────────────────────┼─────────────────────┼──────────────────────────┤
│ UI/UX Design │ frontend-specialist │ react-best-practices │
│ │ │ frontend-design │
│ │ │ tailwind-patterns │
├──────────────────────┼─────────────────────┼──────────────────────────┤
│ API Development │ backend-specialist │ api-patterns │
│ │ │ nodejs-best-practices │
├──────────────────────┼─────────────────────┼──────────────────────────┤
│ Database Design │ database-architect │ database-design │
│ │ │ prisma-expert │
├──────────────────────┼─────────────────────┼──────────────────────────┤
│ Mobile App │ mobile-developer │ mobile-design │
├──────────────────────┼─────────────────────┼──────────────────────────┤
│ Testing │ test-engineer │ testing-patterns │
│ │ │ webapp-testing │
├──────────────────────┼─────────────────────┼──────────────────────────┤
│ Debugging │ debugger │ systematic-debugging │
├──────────────────────┼─────────────────────┼──────────────────────────┤
│ Security Audit │ security-auditor │ vulnerability-scanner │
└──────────────────────┴─────────────────────┴──────────────────────────┘
Skill Loading Protocol
How Skills are Loaded
User Request → Skill Description Match → Load SKILL.md
↓
Read references/
↓
Read scripts/
↓
Apply Knowledge
Skill Structure
Each skill contains:
skill-name/
├── SKILL.md # (Required) Metadata & instructions
├── scripts/ # (Optional) Python/Bash scripts
├── references/ # (Optional) Templates, docs
└── assets/ # (Optional) Images, logos
Example: API Patterns Skill Loading
Step 1: Match Request to Skill
┌──────────────────────────────────────────┐
│ User: "Build a REST API" │
│ ↓ │
│ Keyword Match: "API" → api-patterns │
└──────────────────────────────────────────┘
↓
Step 2: Load Skill Metadata
┌──────────────────────────────────────────┐
│ Read: .agent/skills/api-patterns/ │
│ └── SKILL.md (main instructions) │
└──────────────────────────────────────────┘
↓
Step 3: Load References
┌──────────────────────────────────────────┐
│ Read: api-patterns/rest.md │
│ api-patterns/graphql.md │
│ api-patterns/auth.md │
└──────────────────────────────────────────┘
↓
Step 4: Execute Scripts (with approval)
┌──────────────────────────────────────────┐
│ Suggest: scripts/api_validator.py │
│ (validates API design) │
└──────────────────────────────────────────┘
↓
Step 5: Apply Knowledge
┌──────────────────────────────────────────┐
│ Agent now has: │
│ • API design patterns │
│ • Authentication strategies │
│ • Documentation templates │
│ • Validation scripts │
└──────────────────────────────────────────┘
Validation Layer
Two-Tier Validation System
Quick Check (checklist.py)
For development and pre-commit:
python .agent/scripts/checklist.py .
- ✓ Security (vulnerabilities, secrets)
- ✓ Code Quality (lint, types)
- ✓ Schema Validation
- ✓ Test Suite
- ✓ UX Audit
- ✓ SEO Check
Time: ~30 seconds
Full Verification (verify_all.py)
For pre-deployment and releases:
python .agent/scripts/verify_all.py . --url http://localhost:3000
- ✓ Everything in checklist.py PLUS:
- ✓ Lighthouse (Core Web Vitals)
- ✓ Playwright E2E
- ✓ Bundle Analysis
- ✓ Mobile Audit
- ✓ i18n Check
Time: ~3-5 minutes
Validation Pipeline
┌─────────────────────────────────────────────────────────────┐
│ VALIDATION PIPELINE │
└─────────────────────────────────────────────────────────────┘
During Development (Quick Checks):
┌──────────────────────────────────────────┐
│ python .agent/scripts/checklist.py . │
├──────────────────────────────────────────┤
│ ✓ Security Scan (vulnerabilities) │
│ ✓ Code Quality (ESLint, TypeScript) │
│ ✓ Schema Validation (Prisma/DB) │
│ ✓ Test Suite (Unit tests) │
│ ✓ UX Audit (Accessibility) │
│ ✓ SEO Check (Meta tags) │
└──────────────────────────────────────────┘
Time: ~30 seconds
Pre-Deployment (Full Verification):
┌──────────────────────────────────────────────────────┐
│ python .agent/scripts/verify_all.py . │
│ --url http://localhost:3000 │
├──────────────────────────────────────────────────────┤
│ ✓ All Quick Checks │
│ ✓ Lighthouse Audit (Core Web Vitals) │
│ ✓ Playwright E2E Tests │
│ ✓ Bundle Analysis (Size, tree-shaking) │
│ ✓ Mobile Audit (Responsive, touch) │
│ ✓ i18n Check (Translations, locale) │
└──────────────────────────────────────────────────────┘
Time: ~3-5 minutes
Multi-Agent Orchestration
How Multiple Agents Work Together
Complex Task → /orchestrate → Multiple Specialist Personas
Example: "Build a full-stack e-commerce app"
┌─────────────────────────────────────────────────────────────┐
│ ORCHESTRATOR AGENT │
│ Decomposes task into sequential workstreams │
└─────────────────────────────────────────────────────────────┘
│
┌─────────────────────┼─────────────────────┐
│ │ │
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ FRONTEND │ │ BACKEND │ │ DATABASE │
│ SPECIALIST │ │ SPECIALIST │ │ ARCHITECT │
│ │ │ │ │ │
│ Skills: │ │ Skills: │ │ Skills: │
│ • react-* │ │ • api-* │ │ • database-* │
│ • tailwind-* │ │ • nodejs-* │ │ • prisma-* │
│ │ │ │ │ │
│ Builds: │ │ Builds: │ │ Builds: │
│ • UI/UX │ │ • REST API │ │ • Schema │
│ • Components │ │ • Auth │ │ • Migrations │
└───────┬───────┘ └───────┬───────┘ └───────┬───────┘
│ │ │
└─────────────────┬─┴───────────────────┘
│
▼
┌─────────────────────────────────────┐
│ VALIDATION (All Agents) │
│ • test-engineer → Tests │
│ • security-auditor → Security │
└─────────────────────────────────────┘
Important: This is NOT true parallel execution. The AI processes each domain sequentially, switching context between specialist “personas.”
Statistics
| Metric | Value |
|---|
| Total Agents | 20 |
| Total Skills | 36 |
| Total Workflows | 11 |
| Master Scripts | 2 |
| Skill-Level Scripts | 18 |
| Coverage | ~90% web/mobile development |
Supported Technologies
Frontend
- React, Next.js, Vue, Nuxt, Astro
- Tailwind CSS, CSS-in-JS
- TypeScript, JavaScript
Backend
- Node.js, NestJS, Fastify, Express
- Python, FastAPI, Django
- Rust (experimental)
Mobile
- React Native, Flutter
- iOS, Android
Database
- PostgreSQL, MySQL, SQLite
- Prisma, Drizzle, TypeORM
- Redis, MongoDB
Testing
- Jest, Vitest, Playwright, Cypress
- Unit, Integration, E2E
DevOps
- Docker, Kubernetes
- Vercel, AWS, GitHub Actions
- CI/CD pipelines
Next Steps
Agents
Learn about specialist agents
Skills
Discover modular skills
Workflows
Explore slash commands
