[Guide] Antigravity Protocol: Mastering Global Rules, Skills, and Agentic Workflows (2026 Guide)

by

[SEO & TONE GUIDELINES]

  1. Title: Authoritative and keyword-rich for search visibility in 2026.
  2. Visual Branding: Bold Navy headers and Teal Highlight for mission-critical logic.
  3. Compatibility: High-fidelity US English with 4-backtick fencing to prevent rendering artifacts.

[!NOTE]
Author’s Note: Rendering Compatibility
To ensure correct display on WordPress or other blog platforms, it is recommended to render Mermaid diagrams as images. All custom HTML should be verified with your specific theme.

1. EXECUTIVE SUMMARY (TL;DR)

In 2026, the primary barrier to AI-driven wealth is Context Drift. We solve this by implementing the Antigravity Protocol, a rigid governance engine. This guide provides the 1:1 blueprint for 6 North Star documents, 6 automated workflows, and 9 specialist skills for a Supervised Autonomous Engineering Unit.

2. TECHNICAL ARCHITECTURE

The Antigravity Engine acts as a Structured Information Layer mapping intent to execution.

graph TD
    A["Global Core (GEMINI.md)"] --> B{"Analysis Tier"}
    B -->|Tier 2: Strategic| C["Strategic Planning"]
    B -->|Tier 1: Minor| D["Tactical Execution"]
    C --> E[("North Star Docs (6 Sync Files)")]
    E --> F{"Specialist Logic (9 Skills)"}
    F --> G["Agentic Workflows (6 Workflows)"]
    G --> H["Verified Build Output"]

STEP 1: THE CORE PROTOCOL (GEMINI.md)

1. 1. Expected Result

A global rule file stored in ~/.gemini/ that mandates the Real Engineer’s Path.

1. 2. The Prompt

“In my user home directory (~/.gemini/), create a file named GEMINI.md. This is our Global Constitution. Set the primary language to US English, implement a 3-Tiered Request Classifier, and mandate the Socratic Gate for complex tasks.”

`MARKDOWN
ANTIGRAVITY CORE PROTOCOL: GEMINI.md

  Primary Protocol: Single source of truth for all global instructions.
  Language Policy: Use Professional US English for all interactions.

REQUEST CLASSIFIER (ANTIGRAVITY TIERING)
  Tier 0 (Knowledge): Analysis and research.
  Tier 1 (Tactical): Single file edits or minor debugging.
  Tier 2 (Strategic): Complex implementations. Always require task.md and plan.

THE REAL ENGINEER'S PATH
  1. Socratic Gate: Ask 2-3 strategic questions to verify intent.
  2. Read Understand Plan Apply: Perform codebase analysis first.
  3. Deep Modules: Prioritize high-density logic behind clean interfaces.

QUALITY & INTEGRITY
  TDD (Test-Driven Development): Mandate Red-Green-Refactor loop.
  UTF-8 Integrity: Strictly UTF-8 for all documents.

STEP 2: THE NAVIGATION (6 NORTH STAR DOCUMENTS)

Synchronization ensures the AI never suffers from “context amnesia.” These 6 files act as the Institutional Memory of your project.

2. 1. [PLAN.md] Strategic Roadmap

`MARKDOWN
PLAN: STRATEGIC ROADMAP
  Goals: High-level outcome and MVP scope.
  Milestones: Timelined objectives for Phase 1-3.

2. 2. [CONTEXT.md] Technical Environment

`MARKDOWN
CONTEXT: TECHNICAL STACK & CONSTRAINTS
  Stack: Languages, frameworks, and versions.
  Rules: Strict engineering constraints (e.g., No external dependencies).

2. 3. [TODO.md] Atomic Task Checklist

`MARKDOWN
TODO: ATOMIC TASK CHECKLIST
  [ ] Tasks to be done.
  [/] Tasks in progress (Active Focus).
  [x] Tasks verified and completed.

2. 4. [STYLE_GUIDE.md] Engineering Aesthetics

`MARKDOWN
STYLE GUIDE: DESIGN & UI
  Persona: Professional US Tech Analyst.
  Visuals: Dark Mode, Glassmorphism, Teal highlights.

2. 5. [DEBUG_LOG.md] Troubleshooting History

`MARKDOWN
DEBUG LOG: LESSONS & FAILURES
  Issue: Historical errors/bugs encountered.
  Solution: Validated fixes to prevent recurrence.

2. 6. [FLOW_SKETCH.md] Logic Visualization

`MARKDOWN
FLOW SKETCH: VISUAL LOGIC STATE
  A: Input
  B: Logic Processor
  C: Output

STEP 3: COMMAND REGISTRY (6 AGENTIC WORKFLOWS)

3. 1. Workflow /vibe-plan: Document Synchronization

Expected Result: Automatic initialization or synchronization of the 6 North Star documents.

The Prompt:

“Create a workflow file .agent/workflows/vibe-plan.md to initialize the 6 project governance documents for Vibe Coding.”

Original MD Content:

`MARKDOWN
---
description: Initialize or Sync the 6 North Star documents (PLAN, CONTEXT, etc.)
---

1. Check if the project root contains Vibe Coding specific documents.
2. If documents are missing, create `PLAN.md`, `CONTEXT.md`, `TODO.md`, `STYLE_GUIDE.md`, `DEBUG_LOG.md`, and `FLOW_SKETCH.md` following standard templates (UTF-8).
3. If documents exist, update all files based on the current user request and latest codebase state.
// turbo
4. Extract the most urgent 'Atomic Task' from the updated `TODO.md` and propose it to the user.

3. 2. Workflow /grill-me: Relentless Intent Verification

Expected Result: A relentless design interview session to clarify intent and resolve dependencies.

The Prompt:

“Create a workflow file .agent/workflows/grill-me.md to conduct strategic design interviews.”

Original MD Content:

`MARKDOWN
---
description: Start a relentless interviewing session to clarify intent and resolve design dependencies.
---

1. Analyze the user's initial idea and the existing `PLAN.md`.
2. Follow the "Design Tree" branches and ask consecutive questions in US English:
    - "How does this decision impact other modules?"
    - "Between Option A and B, which do you prefer and why?"
    - "What is the Definition of Done (DoD) for this feature?"
3. If the answers can be found in the codebase, explore it first before asking the user.
4. Continue the interview until a shared understanding is reached (minimum 3 questions).
5. Update `CONTEXT.md` and `PLAN.md` in US English with the interview results.

3. 3. Workflow /write-prd: Comprehensive PRD Generation

Expected Result: A detailed Product Requirements Document based on conversation and exploration.

The Prompt:

“Create a workflow file .agent/workflows/write-prd.md to generate a structured PRD.”

Original MD Content:

`MARKDOWN
---
description: Create a detailed Product Requirements Document (PRD) in US English.
---

1. Gather long detailed descriptions from the user or previous `grill-me` interview sessions.
2. Explore the codebase to verify user assertions and identify base modules.
3. Invoke `/grill-me` if any ambiguity remains.
4. Write a comprehensive PRD in US English following this structure:
    - **Problem Statement**: What are we solving and why?
    - **Solution**: Feature visualization and explanation.
    - **User Stories**: Functional/UX requirements in small units.
    - **Implementation Decisions**: Tech choices and constraints.
5. Submit the document as a GitHub issue or `docs/PRD.md`.

3. 4. Workflow /prd-to-issues: Vertical Slice Decomposition

Expected Result: Decomposition of a PRD into small, actionable vertical slices (Issues).

The Prompt:

“Create a workflow file .agent/workflows/prd-to-issues.md to decompose the PRD into tasks.”

Original MD Content:

`MARKDOWN
---
description: Decompose the written PRD into small, actionable vertical slices (Issues).
---

1. Identify the PRD's destination and set the current codebase state as context.
2. Split tasks into "Vertical Slices" (Tracer Bullets) following these principles:
    - Each task must be independently executable.
    - Arrange tasks in an order that flushes out "Unknown Unknowns" as early as possible.
3. Establish blocking relationships and priorities between tasks.
// turbo
4. Update `/TODO.md` in US English or create GitHub issues.

3. 5. Workflow /improve-arch: Architecture Deepening

Expected Result: Identification of “Shallow Modules” and suggestion of “Deep Module” improvements.

The Prompt:

“Create a workflow file .agent/workflows/improve-arch.md for architecture review.”

Original MD Content:

`MARKDOWN
---
description: Analyze the codebase architecture, identify "Shallow Modules", and suggest improvements.
---

1. Explore the current project structure and find areas of high complexity or redundancy.
2. Formulate candidates for improvement based on these questions:
    - "Does understanding one concept require jumping between too many files?"
    - "Do pure functions extracted for testability hide real integration bugs?"
    - "What is the level of integration risk between tightly coupled modules?"
3. Present at least 3 improvement candidates in US English, numbered.
4. If the user picks one, propose at least 3 different interface designs for the deep module.
5. Create a refactor RFC (Request for Comments) or start implementation based on the final choice.
// turbo
6. Update `ARCHITECTURE.md` if it exists.

3. 6. Workflow /wrap-up: Session Review & Learning

Expected Result: Capture feedback before ending the session and update the global learning log.

The Prompt:

“Create a workflow file .agent/workflows/wrap-up.md for session feedback collection.”

Original MD Content:

`MARKDOWN
---
description: Capture feedback before ending the session and update the global `learnings.md`.
---

1. Summarize completed tasks and remaining items for the current session.
2. Ask the user for specific feedback in US English (e.g., tone, depth, style).
3. Record the feedback in `~/.gemini/learnings.md`.
4. Propose direct updates to core rules or skills if the same feedback persists across sessions.
5. Propose the "Next Step" for the next session and conclude the session.

STEP 4: MODULAR INTELLIGENCE (9 SPECIALIST SKILLS)

4. 1. Skill: tdd – Test-Driven Development

Original MD Content:

`MARKDOWN
TDD SKILL (TEST-DRIVEN DEVELOPMENT)

This skill forces the agent to follow a red-green-refactor loop.

INSTRUCTIONS
  Confirm with the user which interface changes are needed.
  Confirm with the user which behaviors to test.
  Mandatory: Red-Green-Refactor loop.
  Red: Write a failing test first.
  Green: Write the minimum code to make the test pass.
  Refactor: Rewrite and improve the code while keeping tests green.
  Encourage deep modules with thin interfaces for better testability.

USAGE
  When the user asks for "TDD", "unit tests", or "implement feature with tests".

4. 2. Skill: grill_me – Strategic Interviewing

Original MD Content:

`MARKDOWN
GRILL ME SKILL (STRATEGIC INTERVIEWING)

This skill allows the agent to conduct a relentless interview with the user to reach a shared understanding.

INSTRUCTIONS
  Interview the user relentlessly about every aspect of their plan until shared understanding is reached.
  Walk down each branch of the Design Tree, resolving dependencies one by one.
  Ask questions in US English but maintain internal logic in English.
  If a question can be answered by exploring the codebase, explore that instead of asking the user.
  Focus on uncovering Unknown Unknowns and edge cases.

USAGE
  When the user asks to "grill" them, investigate a feature, or use /grill-me.

4. 3. Skill: improve_architecture – Design Refining

Original MD Content:

`MARKDOWN
IMPROVE ARCHITECTURE SKILL (DESIGN REFINING)

This skill allows the agent to analyze architecture and suggest deepening opportunities.

INSTRUCTIONS
  Explore the codebase naturally as an agent.
  Find areas of confusion: Concept jumps, Shallow modules, High integration risks.
  Present candidates for Deepening Opportunities in US English.
  If the user selects a candidate, spawn subagents to suggest 3 focus interface designs.
  Recommend the strongest design based on taste and maintainability.
  Update ARCHITECTURE.md in US English.

USAGE
  When the user asks to "improve architecture", "refactor structure", or uses /improve-arch.

4. 4. Skill: kanban – Board Management

Original MD Content:

`MARKDOWN
KANBAN SKILL (BOARD MANAGEMENT)

This skill allows the agent to maintain a flexible Kanban task board.

INSTRUCTIONS
  Instead of rigid upfront plans, promote a flexible Kanban board.
  Divide tasks into Todo, In Progress, and Done.
  Update /TODO.md in US English consistently.
  Focus on the Next Step as the most important task.
  Regularly review and update the board during the session.

USAGE
  When the user asks to "update tasks", "manage Kanban", or uses /kanban.

4. 5. Skill: prototype – Rapid POCs

Original MD Content:

`MARKDOWN
PROTOTYPE SKILL (RAPID POCS)

This skill allows the agent to create a rapid prototype before full integration.

INSTRUCTIONS
  Create a small, standalone proof-of-concept (POC) for complex features.
  Focus on the Happy Path to validate technical feasibility.
  Document prototype findings and how they impact the final design in US English.
  If success, use it as reference. If fail, document alternatives.

USAGE
  When the user asks to "prototype", "POC", or "start a small test build".

4. 6. Skill: ralph – Autonomous Execution

Original MD Content:

`MARKDOWN
RALPH WIGGUM SKILL (AUTONOMOUS EXECUTION)

This skill allows the agent to operate autonomously (AFK mode) in a safe sandbox.

INSTRUCTIONS
  Pull tasks from the backlogs / /TODO.md / GitHub Issues.
  Operate in AFK Mode (Autonomous) or HITL Mode (Human-In-The-Loop).
  If in HITL Mode, provide visibility and control to the user.
  If in AFK Mode, ensure a safe sandbox for operations.
  Prioritize fixes and features and commit changes to branches.
  Communicate progress and final results in US English.

USAGE
  When the user asks to "run autonomously", "start Ralph loop", or uses /ralph.

4. 7. Skill: research – Deep Investigation

Original MD Content:

`MARKDOWN
RESEARCH SKILL (DEEP INVESTIGATION)

This skill allows the agent to conduct deep research before implementation.

INSTRUCTIONS
  Explore the codebase or external documentation rigorously.
  Identify potential risks, dependencies, and alternative approaches.
  Formulate research questions and answer them before starting code.
  Report all research findings in US English.
  If necessary, summarize findings into PLAN.md.

USAGE
  When the user asks to "research", "investigate", or "look into" a new feature.

4. 8. Skill: prd_to_issues – Task Decomposition

Original MD Content:

`MARKDOWN
PRD TO ISSUES SKILL (TASK DECOMPOSITION)

This skill allows the agent to decompose a PRD into small vertical slices (Issues).

INSTRUCTIONS
  Identify the PRD's destination and set the current codebase state.
  Split tasks into Vertical Slices (Tracer Bullets):
    Each task must be independently executable.
    Arrange tasks to flush out unknown unknowns early.
  Establish blocking relationships and priorities between tasks.
  Mandatory: All task descriptions and issue titles must be in US English.
  Update /TODO.md in US English or create GitHub issues.

USAGE
  When the user asks to "convert PRD to issues" or uses /prd-to-issues.

4. 9. Skill: write_prd – Requirements Documentation

Original MD Content:

`MARKDOWN
WRITE PRD SKILL (REQUIREMENTS DOCUMENTATION)

This skill allows the agent to create a comprehensive PRD.

INSTRUCTIONS
  Ask the user for a long detailed description if not already provided.
  Explore the repository to verify assertions and identify affected modules.
  Use the Grill Me skill to resolve any remaining ambiguities.
  Write the PRD in US English with sections:
    Problem Statement, Solution, User Stories, Implementation Decisions.
  Provide a clear destination document for the project.

USAGE
  When the user asks to "write a PRD", "document requirements", or uses /write-prd.

4. VERIFICATION & VALIDATION

How do we prove the Antigravity Engine is active? Run the initialization sequence and verify the symbolic link integrity.

[VERIFIED OUTPUT]

TEXT
[2026-03-30] Success: Symbolic Junction (.agent) linked to global C:\Users\Jyoung\.gemini\.agent
[2026-03-30] Success: 9 Specialist Skills and 6 Agentic Workflows initialized.

5. REFERENCE & ARTIFACTS

Maintain link integrity. Always include the source URL for transparency.

  1. VibeAlgoLab: The 6-Document Strategy for AI Success
  2. VibeAlgoLab: Precision Architecture — Grounded Blueprints
  3. Antigravity-Customization: Official GitHub Repository

[IMPORTANT DISCLAIMER]

  1. Educational Purpose: All content, including code and strategies, is for educational and research purposes only.
  2. No Financial Advice: This is not financial advice. We are not financial advisors.
  3. Risk Warning: Investing involves significant risk. Past performance does not guarantee future results.
  4. Software Liability: Any tools or code provided are “as-is” without warranty. Use at your own risk.

[Architect’s Final Note]
Consistency is the only defense against context drift. Run /vibe-plan daily to keep the AI aligned.

[Open Source Update]
All rules, skills, and workflows defined in this guide are open-sourced for the community. You can clone and adapt the configuration for your own agentic setup by visiting our official repository: Antigravity-Customization.

Post Views: 7

Leave a Comment