Antigravity Masterclass: Building Autonomous Agentic Teams
Break the chat-bot coding paradigm and enter the era of system-level Agentic Development. Master how to embed the using-superpowers skill and planning-with-files long-term memory into your repository to build self-healing, self-planning AI programmer pipelines. Real-world project: Building a Time Management System with deep Google Calendar integration.
Start Learning
Curriculum
Course Introduction and Comprehensive Roadmap (Syllabus)
This section outlines the comprehensive learning roadmap of the 30-session masterclass, providing a preview of how to engineer from scratch an Agentic development pipeline equipped with robust self-awareness and self-correction capabilities.
Phase 1 / Ep 01: Inception (One-Pager from a Human Perspective)
AI is neither a mind reader nor a psychic. This hands-on section teaches you how to write a concise yet strictly bounded "One-Pager" to serve as the ultimate spark for igniting the entire advanced Agent engine.
Phase 1 / Ep 02: Antigravity Environment Preparation and Boundary Delineation
The first step in transforming a standard warehouse into an Agent-driven framework: creating the .agents directory and defining clear sub-warehouse scopes. We do not rely on luck; we rely on engineering architecture to set limits for AI.
Phase 1 / Ep 03: Soul Implantation GEMINI.md
This is the constitution for the entire Agent team. It instructs the system: Here, do not write unnecessarily complex code, do not arbitrarily modify existing functions, and do not delete old comments. Without this document, you are opening a blind box.
Phase 1 / Ep 04: Superpower Engine using-superpowers
This is your silver bullet for preventing AI hallucinations when developing complex systems. With just one line of configuration, compel AI to adopt a good habit: stop making wild guesses; consult the documentation first!
Phase 1 / Ep 05: Physical Plugin planning-with-files
The $2 billion Matrix model. Transferring the fragile and limited short-term memory (Token) of Large Language Models into nearly infinite physical disks (Filesystem).
Phase 1 / Ep 06: The First Workflow of the Generation System
Link discipline, principles, and objectives. Teach the Agent not only to accept orders and fulfill requirements, but also to understand that after taking on a task, it must break it down into steps, write tests, develop, and self-check. Complete the transformation from a soldier to a squad leader.
Phase 2 / Ep 07: Human-Machine Debate and PRD Fission
Abandon the habit of manually writing thousands of words for Product Requirements Documents. This demonstrates how to leverage an Agent with a system persona to reverse infer and automatically expand your one-page idea into a rigorous, system-level PRD design.
Phase 2 / Ep 08: Database Engine Selection Debate
The biggest fear in development projects is making rash decisions. Leveraging the breadth of large models' knowledge bases, we will establish the technology stack that best aligns with our project constraints through adversarial debate, and solidify these technical decisions in findings.md.
Phase 2 / Ep 09: Data Model Schema Design Automation
Reject the tedious manual assembly of Prisma files. We teach you to write a custom workflow that automatically concretizes abstract business objects into table-structured entities with relationship keys.
Phase 2 / Ep 10: External Deep-Sea Early Warning (API Research)
The project is doomed if limitations of the integrated third party are only discovered halfway through system development. Demonstrate how to dispatch an Agent to enable web_search for preliminary reconnaissance, delving into the depths of documentation.
Phase 2 / Ep 11: Large-Scale Operations: Rapid Task Breakdown and Backlog Entry
All preliminary strategies completed! Use the final instruction to automatically convert our PRD, research notes, and outcomes into thirty technical execution steps `[ ]`, truly initiating auto-battle.
Phase 3 / Ep 12: TDD—Steel Chains to Tame the Behemoth
If AI is a lightning-fast code-writing behemoth, then a codebase without tests is a cliff for it. This unpacks why, in the Agent era, Test-Driven Development has transformed from a "best practice" into the "sole survival imperative."
Phase 3 / Ep 13: Configuring test-driven-development skill flow
Solidify TDD principles into system specifications. Train the Agent to develop a Red-Green-Refactor muscle memory, transforming errors that previously relied on human judgment into decision points directly handled by the command-line terminal.
Phase 3 / Ep 14: The First Line of Local Code (TDD: The Battle of Practical Algorithms)
First execution ever! Based on the task board we built in Phase 2, commanding the Agent to tackle the core challenge: time block allocation logic. Witness the magic of the code self-healing pipeline.
Phase 3 / Ep 15: 3-Strike Backstop Agreement
What if an infinite loop occurs? In advanced engineering management, never assume a pipeline will not fail. Learn how to implement physical circuit breaker instructions to prevent costly overheating: the 3-Strike Protocol.
Phase 3 / Ep 16: External Interface Mocking: The Minimalist Way
If you want to test calendar synchronization functionality, is it truly necessary to repeatedly hit Google servers a hundred times just to get the green light in your tests? In TDD, teach the Agent to use the magic of Mock.
Phase 4 / Ep 17: Security Audit of OAuth 2.0 Implementation
AI writing functional login code is straightforward, but writing secure code is exceedingly challenging. This explores how to compel Agents to write OAuth flows by adhering to a Security Checklist, thereby mitigating CSRF vulnerabilities.
Phase 4 / Ep 18: Mental Model (Bidirectional Sync Conflict Resolution)
This is not a code issue, it is a philosophical issue. Let the Agent think on your behalf about whether it should be Local Win or Remote Win when modification conflicts occur, and establish an architect-level ADR archive.
Phase 4 / Ep 19: Building Webhook Autonomy and Queue Model
Impart the concepts of asynchronous operations and message queues to large models. Avoid overwhelming the system with primitive single-point queries; instead, teach it to design and build a robust event reception layer.
Phase 4 / Ep 20: Partial Cleanup and Major Refactoring of the System (Refactoring)
No project with over a thousand lines of code is immune to becoming messy. Learn the art of calling a timeout: when the code starts to exhibit obvious Code Smells, summon a dedicated Cleanup Agent to clean up the battlefield.
Phase 4 / Ep 21: Universal Adapter for Complex Data (Adapter Pattern)
The ultimate weapon against external uncertainties. Force the AI to use the classic Adapter design pattern to bridge the gap between the Google Calendar format and our internal business objects.
Phase 5 / Ep 22: Building an E2E Headless Test Automation Flow
Leave the final quality assurance to the system's last firewall—the browser. Establish the `e2e-testing.md` workflow to prevent UI rendering from becoming a disaster due to egregious oversights.
Phase 5 / Ep 23: Teaching an Agent to Master Playwright Like a Human
Enable text-only AI to control the mouse and assert visual pop-ups. Say goodbye to manually writing verbose, step-and-pause page-driven code.
Phase 5 / Ep 24: The "Doomsday Assertion Mechanism" of the Injected UI
Top-tier systems always prepare for the worst. Teaching large models how to verify the UI system's graceful degradation and fault-tolerant experience during network outages and 500 service crashes.
Phase 5 / Ep 25: Cyber Reviewer Mechanism requesting-code-review.md
It's difficult for one to spot flaws in their own code. Create a rigorous virtual peer to scathingly criticize and find fault with our hidden code smells before we push this large codebase to mainline.
Phase 5 / Ep 26: Unified Bug Fix Format bug-fix.md
If the system ever encounters a bug one day, what is the most reliable way to fix it? Establish a fixed paradigm: a virtuous iterative methodology of Submit test -> Fail (Red) -> Patch code -> Recover.
Phase 5 / Ep 27: Frontend Performance and Bundle Diagnostics
Let AI agents run a Lighthouse benchmark and split the bundle size. Use LLMs to manage your system bandwidth health.
Phase 5 / Ep 28: Automated Conventional Commits
Engrave elegance at the source. Create a workflow that forces the LLM to generate git commits elegant enough for changelogs on every commit.
Phase 5 / Ep 29: The Perfect Daily Reconciliation Ritual session-archive.md
Elite cyber work teams understand how to write their own work summaries for shift handover. They use automated processes to complete end-of-day handovers, leaving a knowledge archive for seamless handover the next day.
Phase 5 / Ep 30: Graduation Season and Final Chapter (Team Handover and Delivery)
Practical project implementation breaks through the closed loop. How to create a descriptive project facade for open-source or commercialization. And thereby serve as the ultimate anthem to celebrate the system finally emerging from its cocoon and going live.