2.4 Section 2 Master Takeaway: Antigravity, Gemini CLI & Claude Code Summary

1. Interactive Agentic Developer Switcher: Top 3 Section 2 Design Pitfalls

Click each button below to compare common AI-assisted development pitfalls across Google Antigravity, Gemini CLI, and Claude Code on Google Cloud against the winning architecture:

Why the Naive Design Fails

Stuffing 30 specialized runbooks into the root GEMINI.md or CLAUDE.md file wastes tens of thousands of tokens on every turn; asking the model in English to ignore .env files fails to prevent secret ingestion.

The Winning Architectural Fix

Move task-specific playbooks into On-Demand Custom Skills (progressive disclosure: summary loaded at startup, full instructions loaded only when needed) and block secrets deterministically via ignore files!

2. The 3-Pillar Architecture Summary Grid

2.1 Context & Skills

Hierarchy & Progressive Load

Global = personal prefs; Repo Root = universal build/architecture rules; Subdirectory = package rules. Use Custom Skills for on-demand progressive disclosure & ignore files for secrets.

2.2 MCP & Subagents

Live Schemas & Context Rot

Connect MCP servers (scoped to read-only/dev) to stop schema hallucinations. Cure multi-file context rot with Subagents (Explorer, Coder, Verifier) and Spec -> Plan -> Act -> Verify.

2.3 CI/CD & Sandboxing

Headless & Isolated Runs

Use non-interactive headless mode + read-only tool allowlists + JSON output in CI/CD. Synthesize evalset.json from specs with human review. Isolate auto-execution in Sandboxes.

3. Cross-Tool Master Decision Matrix (Antigravity, Gemini CLI & Claude Code)

Architectural Requirement / Scenario	Recommended Architectural Solution	Anti-Pattern to Avoid
Share universal build, test, and architecture conventions across every developer on a repo	Commit a concise Repository Root context file (`GEMINI.md` / `CLAUDE.md` / Workspace Rules) to Git.	Storing team conventions in a developer’s personal global home-directory config.
Prevent backend Python conventions from colliding with frontend React rules in a monorepo	Place subdirectory-scoped context files inside each respective package directory.	Dumping all conflicting language rules into one giant root context file.
Provide 25 specialized runbooks (migrations, security audits) without bloating every prompt	Package each workflow as an On-Demand Custom Skill (progressive disclosure loads full text only when matched).	Pasting all 25 runbooks directly into the always-on root context file.
Prevent `.env` credentials, private keys, and `node_modules` from entering the AI context	Configure deterministic context exclusion / ignore files (`.geminiignore`, `.aiexclude`, permission deny lists).	Adding a natural-language sentence in the system prompt asking the AI not to read `.env`.
Stop the coding assistant from hallucinating BigQuery/AlloyDB column names or internal APIs	Connect the IDE/CLI to a read-only MCP Server (such as MCP Toolbox for Databases or Cloud Docs MCP).	Manually copying and pasting table schemas into chat on every turn or granting prod DB write access.
Refactor 50+ files across a repository without the agent forgetting instructions mid-task (context rot)	Use Subagent Task Decomposition (Explorer, Implementer, Verifier subagents with isolated context windows).	Forcing a single monolithic chat thread to search, edit, and test all 50 files sequentially.
Prevent an AI coding assistant from generating 20 files based on a flawed architectural assumption	Follow a Spec -> Plan -> Act -> Verify loop where a human architect reviews and approves the Plan before coding starts.	One-shot prompting (“Build the entire microservice now”) without a specification or plan gate.
Run Gemini CLI or Claude Code inside Cloud Build / GitHub Actions without the pipeline hanging	Invoke the CLI in non-interactive headless mode with a pre-approved read-only tool allowlist and JSON output.	Running default interactive mode (which blocks indefinitely waiting for terminal `[y/N]` input).
*Rapidly create unit tests and golden `.evalset.json` trajectory files for a new ADK agent**	Use AI-assisted test synthesis anchored on the specification, followed by mandatory human verification.	Blindly committing AI-generated assertions derived solely from buggy implementation code without review.
Allow an agent to iterate rapidly on terminal commands and package installs without risking the host OS	Run inside an isolated Container / OS Kernel Sandbox (or ephemeral Cloud Workstation) with zero prod credentials.	Enabling unrestricted “auto-approve all commands” directly on a developer’s unisolated host machine with prod IAM keys.