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.
COURSE CONTENT
Chapter 00 | Course Introduction and Panoramic Roadmap (Syllabus)
This session introduces the panoramic learning path of the 30-issue Masterclass, previewing how to build an Agentic development pipeline with strong self-awareness and self-correction capabilities from scratch.
Chapter 01 | The Origin: Intent One-Pager from a Human Perspective
AI is not a mind reader or a psychic. This hands-on session teaches you how to write a concise yet binding 'One-Pager' concept to serve as the super-catalyst for the entire high-level Agent engine.
Chapter 02 | Antigravity Environment Setup and Boundary Delineation
The first step in transforming a regular repository into an Agent-driven framework: Creating the .agents directory and setting clear sub-repo scopes. We don't rely on luck; we rely on engineering architecture to set limits for AI.
Chapter 03 | Soul Implantation: GEMINI.md
This is the constitution for the entire Agent team. It dictates: no flashy code, no altering existing functions arbitrarily, and no deleting old comments. Without this file, you are flying blind.
Chapter 04 | The Ultimate Engine: using-superpowers
This is your 'get-out-of-jail-free card' against AI hallucinations in complex systems. With just one configuration line, it forces the AI to build a good habit: stop guessing and consult the docs first!
Chapter 05 | Physical Hack: planning-with-files
The $2 billion 'Matrix' mode. Transfer the fragile and limited short-term memory (Tokens) of Large Language Models into the nearly infinite capacity of the physical disk (Filesystem).
Chapter 06 | The System's First Pipeline (Workflow)
Connecting discipline, laws, and goals. Teach the Agent not just to take orders, but to understand how to break down tasks, write tests, develop, and self-check. Complete the transformation from a soldier to a squad leader.
Phase 2 / Ep 07 | Human-AI Debate and PRD Fission
Break the habit of manually writing thousand-word Product Requirement Documents. This lesson demonstrates how to use an Agent with a system persona to reverse-engineer your one-page idea and automatically expand it into a rigorous, system-level PRD.
Chapter 08 | Debating the Database Engine Choice
Avoid rash decisions in development. Leverage the large model's broad knowledge to debate and select the best tech stack for your project's constraints, then document the decision in `findings.md`.
Phase 2 / Ep 09: Automating Data Model Schema Design
Stop manually writing complex Prisma files. Learn to create a custom workflow that automatically transforms abstract business objects into concrete table structure entities with relational keys.
Chapter 10 | External Deep Dive: API Research
Discovering third-party limitations halfway through development can doom a project. This lesson shows how to dispatch an Agent using `web_search` to perform reconnaissance deep within API documentation.
Chapter 11 | Large-Scale Operations: Rapid Task Breakdown
With all preliminary strategies complete, we'll use one final command to automatically convert our PRD and research notes into a 30-step technical execution plan, officially kicking off automated development.
Phase 3 / Ep 12: TDD—The Steel Chains to Tame the Beast
If AI is a beast that codes at lightning speed, then a codebase without tests is a cliff edge. This lesson explains why, in the age of Agents, Test-Driven Development has evolved from a 'best practice' to the 'only rule for survival'.
Phase 3 / Ep 13: Configuring the Test-Driven Development Skill
Solidify TDD principles into system specifications. Train the Agent to internalize the Red-Green-Refactor cycle, turning subjective error-checking into objective, terminal-based validation.
Chapter 14 | Your First Line of Local Code: A TDD Algorithm Battle
A universe-first execution! Based on the task board we built in Phase 2, command the Agent to tackle the core challenge: the time block allocation logic. Witness the magic of a self-healing code pipeline.
Chapter 15 | The 3-Strike Fallback Protocol
What happens if an infinite loop occurs? In advanced engineering management, never assume the pipeline won't fail. This lesson teaches you how to implement a physical circuit breaker to prevent overheating and burning through funds: the 3-Strike protocol.
Phase 3 / Ep 16 | The Simple Way to Mock External APIs
To test the calendar sync feature, do you really need to spam Google's servers a hundred times just to get a green light in your tests? Learn to teach your Agent the magic of Mocking in TDD.
Phase 4 / Ep 17 | Security Audit for OAuth 2.0 Implementation
It's easy for an AI to write login code that runs, but extremely difficult to make it secure. This lesson explores how to compel an Agent to write the OAuth flow by following a mandatory Security Checklist, thereby preventing CSRF vulnerabilities.
Phase 4 / Ep 18 | Mental Model for Bidirectional Sync Conflict Resolution
This isn't a coding problem; it's a philosophical one. Let the Agent decide whether Local Wins or Remote Wins should prevail in case of modification conflicts, and establish an architect-level Architecture Decision Record (ADR).
Phase 4 / Ep 19: Building an Autonomous Webhook with a Queueing Model
Teach the large model about asynchronous processing and message queues. Guide it to design a robust event reception layer instead of overwhelming the system with primitive polling.
Chapter 20 | Local Cleanup and Major Refactoring
No project over a thousand lines of code is ever perfectly clean. This lesson teaches you how to pause development and, when code smells become apparent, summon a specialized cleaning Agent to refactor the codebase.
Phase 4 / Ep 21: The Universal Connector for Complex Data (Adapter Pattern)
The ultimate defense against external inconsistencies. We'll compel the AI to use the classic Adapter design pattern, smoothing over the discrepancies between the Google Calendar format and our internal business objects.
Phase 5 / Ep 22 | Building an E2E Headless Testing Automation Workflow
Hand over the final quality assurance to the system's last firewall: the browser. Establish the `e2e-testing.md` workflow to prevent UI rendering disasters caused by careless oversights.
Phase 5 / Ep 23 | Teaching an Agent to Use Playwright Like a Human
Teach a text-based AI to handle mouse operations and assert visual pop-ups, eliminating the need to manually write tedious, step-by-step page-driven code.
Chapter 24 | Injecting a 'Doomsday Assertion Mechanism' into the UI
Top-tier systems always prepare for the worst. This lesson teaches the large model how to verify the UI's graceful degradation and fault tolerance experience during network outages or 500 server errors.
Phase 5 / Ep 25 | The Cyber Code Reviewer Mechanism
It's hard to spot flaws in your own code. Create a harsh virtual peer to mercilessly critique and find hidden code smells before we push this pile of code to the main branch.
Phase 5 / Ep 26: A Standardized Protocol for Bug Fixing: bug-fix.md
What's the most stable way to fix a bug if the system breaks? Establish a fixed paradigm: write a test -> see it fail (red) -> add code -> see it pass (green), creating a virtuous cycle of iteration.
Chapter 27 | Frontend Performance and Bundle Diagnostics
Let an AI agent run a Lighthouse score and split the bundle size. Use a large model to manage your system's bandwidth health.
Phase 5 / Ep 28: Automated Conventional Commits
Instill elegance right from the source. Create a workflow to enforce that the large model generates beautiful, release-log-worthy git commits every time.
Phase 5 / Ep 29 | The Perfect End-of-Day Session Archive
The most effective AI agent teams know how to write their own daily summaries and handovers. Use an automated workflow to complete the end-of-day handover, creating a mental archive for a seamless transition to the next day.
Phase 5 / Ep 30: Project Completion and Handover
Learn how to create comprehensive project documentation for open-source or commercial handover. This final step marks the successful completion of the system's development lifecycle.