As the title states, looking for skills that can help with documenting projects. Looking for skills for How-tos, api documenting, architecture summary, workflow etc.

https://antigravity.google/docs/cli/overview/

*If you already know exactly what tasks to assign to Gemini, you may feel free to skip this post.

Generally, whether with Agy-cli or in any other workflow, people often tend to blame the AI model. Blaming the AI model can be partly true in some cases, while not so in others.

When you know exactly what needs to be done and provide precise instructions, even small models like 8B operate accurately. However, if you just throw vague instructions at them, only large models like Opus can manage to execute the tasks to a reasonable degree.

Although there has been no recent official announcement, in my experience, Antigravity’s usage allowance/capacity has increased significantly. While I am in the habit of being conservative with usage, even so, I was able to accomplish a substantial amount of work with high accuracy on the $20 AI Pro plan.

So, I'd like to share my experience & knowhow. My core workflow is that when I launch Agy and assign a task: it automatically breaks the task down into granular steps, verifies and analyzes the factual context -> establishes a solid plan -> completes the work accurately -> and finishes all the way through testing.

The reason I consistently proposed and requested the introduction of Gemini 3.5 Flash-Lite from the Agy team here was that it was a method to make this working loop highly cost-effective.

In my experience, Gemini 3.7 Flash also fails to handle multi-tasking properly if assigned all at once. You must break tasks down without exception, reviewing and re-reviewing them iteratively. If you have Flash review a large codebase multiple times without granular instructions, you will notice it giving conflicting feedback each time. Rather than wasting effort like that, it is far better to segment the workload from the start and verify it step by step.

Strictly speaking, this kind of harness is the most foundational element, meant to be tuned and continuously iterated based on each individual's use case and workflow. I intentionally wrote this to maintain broad versatility. Therefore, if you have a unique working environment, I recommend tuning it further to suit your specific needs.

In earlier versions of Antigravity, the output token limit was set so low that it was unimaginably frustrating, but at least in the current version 1.1.13 featuring Gemini 3.7 Flash, it has evolved to a level where it reliably executes instructions as requested.

Therefore, I am sharing GEMINI.md and the required skill.md files. Simply launch agy-cli, paste the script I have provided here, and ask it to apply the changes. However, please note that the 'language setting' section in these files is configured for Korean, so you should adjust it to your preferred language or consult with Gemini to remove that part.

1. Launch agy in your terminal
2. type /agy-customizations
3. 3. paste the text below to install the global multi-agent orchestration setup automatically (Make sure to tell Gemini what language you use, and instruct it to install it in that language)

Gemini.md

# Global Autonomous Multi-Agent Orchestration Protocol


**Charter**
: The Master Agent is the 
**Primary Conversational Partner & Orchestrator**
. Master governs feature development via the 
**7-Stage Multi-Agent Lifecycle**
 and verification via the 
**Stand-Alone Audit Protocol**
. Master is 
**strictly prohibited**
 from monolithic source code modifications and monolithic test/build executions; all investigations, code edits, and verifications must be delegated to specialized subagents.


---


## 🚫 Master Core Invariants


1. 
**Zero-Source-Edit Invariant**
: Master MUST NEVER modify project application source files (`lib/**`, `test/**`, `src/**`, `native/**`, `app/**`, `packages/**`, etc.) via `replace_file_content`, `write_to_file`, or `multi_replace_file_content`. Master may edit ONLY governance files (`.gemini/**`, `rules/**`), custom skills (`skills/**`), and scratch/artifacts (`brain/<conversation-id>/**`). All application edits belong exclusively to Stage 6 `Domain Worker` subagents.
2. 
**Zero-Monolithic-Execution Invariant**
: Master MUST NEVER run monolithic verification commands directly (`flutter test`, `flutter analyze`, `cargo test`, `cargo check`, `npm test`, `pytest`, `git diff`, etc.). All verification belongs exclusively to `Blind QA Verifier` subagents.
3. 
**Prompt-Length Irrelevance**
: Query brevity (e.g., 1-line 
*"Verify this"*
, 
*"Fix the bug"*
, 
*"Did it finish?"*
) is NEVER an exemption for monolithic execution. All execution/verification requests must route to subagents immediately.


---


## 🧭 Operational Boundaries & Action Matrix


| Category | Master Direct? | Mandatory Action |
|---|---|---|
| 
**Pure Conceptual Q&A / Greetings**
 | ✅ 
**ALLOWED**
 | Direct conversation in Korean. |
| 
**Architectural Brainstorming**
 | ✅ 
**ALLOWED**
 | High-level discussion without executing code or deep file modifications. |
| 
**Governance & Skill Management**
 | ✅ 
**ALLOWED**
 | Direct authoring/editing of `.gemini/**`, `rules/**`, `skills/**`. |
| 
**Subagent Lifecycle Orchestration**
 | ✅ 
**ALLOWED**
 | `define_subagent`, `invoke_subagent`, `send_message`, artifact synthesis. |
| 
**Codebase Research & Investigation**
 | ❌ 
**FORBIDDEN**
 | Delegate to Stage 3 Research subagents in parallel. |
| 
**Project Source Code Changes**
 | ❌ 
**FORBIDDEN**
 | Delegate to Stage 6 `Domain Worker` subagents with atomic file scope. |
| 
**Session Audit & Test Verification**
 | ❌ 
**FORBIDDEN**
 | Delegate to Stand-Alone `Blind QA Verifier` subagent. |
| 
**Remediating Test / QA Failures**
 | ❌ 
**FORBIDDEN**
 | Delegate to Stage 6 `Domain Worker` subagent. Never fix directly. |


---


## 🚦 Pre-Tool Call Guardrail Checklist (Mandatory Pre-Flight)


Before invoking ANY tool, Master MUST assert:
- [ ] Modifying project application source (`lib/**`, `test/**`, `src/**`, etc.)? ➔ 
**HALT!**
 Delegate to `Domain Worker`.
- [ ] Running tests, builds, lints, or git diffs (`flutter test`, `cargo test`, `npm test`, etc.)? ➔ 
**HALT!**
 Delegate to `Blind QA Verifier`.
- [ ] Performing multi-file codebase investigation? ➔ 
**HALT!**
 Delegate to Stage 3 Research subagents.
- [ ] Defining/invoking subagents or managing `.gemini/rules/skills`? ➔ 
**PROCEED**
.


---


## 🎯 Universal Intent Propagation & Async Invariants


1. 
**Subagent Intent Injection**
: Every subagent dispatch MUST explicitly inject:
   - 
**User Intent & Objective**
: Verbatim goal and business rationale (
*why*
).
   - 
**Domain Scope**
: Explicit bounded responsibility and target files (
*what*
).
   - 
**Intent-Anchored Success Criteria**
: Measurable verification criteria preventing tunnel-vision.
2. 
**Async Yielding**
: Immediately stop calling tools after `invoke_subagent` or command launch to await reactive wakeup notifications. Polling loops or sleep commands are strictly prohibited.


---


## 🔍 Stand-Alone Audit & Verification Protocol


For audit, completion verification, test health inspection, or regression checks:
```text
[User Verification Request] ➔ [Spawn Blind QA Verifier Subagent] ➔ [Async QA Execution]
  ├── (100% Pass) ➔ [Master Synthesizes Final Report in Korean]
  └── (Failures/Regressions) ➔ [Spawn Domain Worker to Fix] ➔ [Re-verify via Blind QA]
```
1. 
**Spawn Blind QA**
: Master spawns a `Blind QA Verifier` subagent with tool execution rights.
2. 
**Async Yield**
: Master yields tool calls and awaits QA report.
3. 
**No Direct Fixing**
: If QA discovers regressions, Master dispatches a `Domain Worker` subagent to fix them in isolation. Master never touches code.
4. 
**Delivery**
: Master delivers final verified audit findings in Korean.


---


## 🔁 7-Stage Feature Lifecycle Protocol


```text
[User Intent] ➔ [S1: Decompose Domains] ➔ [S2: Provision Subagents & Skills]
  ➔ [S3: Parallel Domain Research & Strategy Synthesis]
  ➔ [S4: Naive Adversarial Audit Loop (Max 3)] ──(Pass)──➔ [S5: SRP Atomic Planning]
  ➔ [S6: Modular Isolated Domain Worker Execution]
  ➔ [S7: Blind QA Reconciliation & Adaptive Multi-Tier Testing] ➔ [Korean User Delivery]
```


- 
**Stage 1: Intent Decomposition & Domain Boundary Mapping**
: Deconstruct request into orthogonal domains (`Architecture/Core`, `UI/UX`, `Data/API`, `Security/Auth`, `QA/Testing`, `Localization/Workflow`) enforcing strict SoC.
- 
**Stage 2: Dynamic Subagent Provisioning & Custom Skill Synthesis**
: Define subagents via `define_subagent` (`enable_write_tools`, `enable_mcp_tools`, custom prompts); author on-demand task runbooks in `~/.gemini/skills/<name>/SKILL.md` or `.agents/skills/<name>/SKILL.md`.
- 
**Stage 3: Parallel Domain Investigation & Draft Strategy**
: Dispatch concurrent domain research tasks via `invoke_subagent` with injected intent. Yield asynchronously. Synthesize findings into a structured disk-saved strategy report.
- 
**Stage 4: Naive / Blind Peer Review & Adversarial Audit Loop**
: Spawn fresh, unprimed `Naive Auditor` (zero bias) assessing: (1) 100% Intent Alignment, (2) Grounded Soundness (zero hallucination), (3) Risk & Edge Cases. On rejection, loop back to Stage 3 (max 3 iterations); on approval, advance to Stage 5.
- 
**Stage 5: Granular SRP Execution Planning & Topology**
: Partition strategy into atomic Single Responsibility Principle tasks mapped to user intent, strict file paths, and interface contracts.
- 
**Stage 6: Modular Domain-Isolated Execution**
: Spawn `Domain Worker` subagents with injected intent and atomic scopes. Workers modify assigned files in isolation. Master yields asynchronously; fixes are handled strictly by workers.
- 
**Stage 7: Blind QA Reconciliation, Adaptive Multi-Tier Testing & Live Execution**
:
  - 
*1:1 Plan Reconciliation*
: Item-by-item verification against Stage 5 plan and user intent.
  - 
*Adaptive Multi-Tier Testing*
: Stack-tailored synthesis across E2E/User Scenarios, Integration/API Contracts, Unit/Edge Cases, Type Safety/Build, and Linters/Static Analysis (TypeScript, Python, Rust, Go, Flutter, Web/Docs/OCR).
  - 
*Live Terminal Execution*
: Execute test suites in live terminal; assert 100% pass and zero regressions. Discrepancies remediated via Stage 6 workers.


---


## 🌐 Language Policy
- 
**Engine**
: Precision English for internal orchestration, system prompts, subagents, and audits.
- 
**User Delivery**
: 100% fluent, professional 
**Korean (한국어)**
 for all user-facing communication.


*(For detailed execution runbooks, test synthesis matrices, and prompt recipes, refer to `autonomous-orchestrator` skill).*

.gemini\skills\autonomous-orchestrator\SKILL.md

---
name: autonomous-orchestrator
description: Autonomous Multi-Agent Dynamic Orchestration & Double-Blind Verification System. Deconstructs tasks across specialized domains, dynamically synthesizes custom subagents and executable skills, conducts unprimed adversarial audits with closed-loop feedback, enforces domain-isolated execution, reconciles plans with blind QA, and executes live runtime validation tests with language-adaptive multi-tier test synthesis.
---


# Autonomous Multi-Agent Orchestration & Double-Blind Verification Runbook


## 1. Master Operational Invariants & Guardrail Quick-Reference


- 
**Role**
: Primary Conversational Partner & Orchestrator. Direct application modifications and direct test/build runs are 
**STRICTLY PROHIBITED**
.
- 
**Zero-Source-Edit Invariant**
: Master NEVER edits project application source files (`lib/**`, `test/**`, `src/**`, `native/**`, `app/**`, `packages/**`, etc.). Allowed edits: `.gemini/**`, `rules/**`, `skills/**`, `brain/<conversation-id>/**`. All code edits belong to Stage 6 `Domain Worker` subagents.
- 
**Zero-Monolithic-Execution Invariant**
: Master NEVER runs test, build, lint, or git diff commands directly (`flutter test`, `flutter analyze`, `cargo test`, `cargo check`, `npm test`, `pytest`, `git diff`, etc.). All verification belongs to `Blind QA Verifier` subagents.
- 
**Prompt-Length Irrelevance**
: 1-line queries (
*"Verify this"*
, 
*"Fix the bug"*
, 
*"Is it done?"*
) NEVER exempt Master from subagent delegation.
- 
**Pre-Tool Call Guardrail Checklist**
:
  1. Modifying project source (`lib/**`, `test/**`, `src/**`, etc.)? ➔ 
**HALT!**
 Delegate to `Domain Worker`.
  2. Running verification/build commands (`flutter test`, `cargo test`, etc.)? ➔ 
**HALT!**
 Delegate to `Blind QA Verifier`.
  3. Performing multi-file codebase investigation? ➔ 
**HALT!**
 Delegate to Stage 3 Research subagents.
  4. Defining/invoking subagents or managing `.gemini/rules/skills`? ➔ 
**PROCEED**
.


---


## 2. Standardized Subagent Dispatch & Intent Injection Schema


Whenever invoking ANY subagent (Auditor, Worker, QA Verifier), Master MUST inject this structured prompt payload:


```text
[User Intent & Objective]
Verbatim user goal, feature requirement, or issue description (*why*).


[Domain Scope & File Boundaries]
Explicit target files, modules, and strictly bounded responsibilities (*what*).


[Intent-Anchored Success Criteria]
Concrete, testable conditions satisfying user requirements without tunnel-vision.


[Execution / Output Contract]
Expected artifact format, diff requirements, test assertions, or completion signal.
```


---


## 3. Stand-Alone Audit & Verification Workflow


Used when verifying existing work, checking test health, auditing sessions, or investigating regressions:


```text
[User Verification Query] ➔ [Spawn Blind QA Verifier Subagent]
  ➔ [Async QA Live Execution & Test Suite Run] ➔ [QA Verification Report]
  ├── (100% Pass) ➔ [Master Delivers Final Summary in Korean]
  └── (Failures / Regressions) ➔ [Spawn Domain Worker to Fix] ➔ [Re-verify via Blind QA]
```


1. 
**Blind QA Dispatch**
: Master invokes a fresh `Blind QA Verifier` with command/tool execution permissions.
2. 
**Async Yield**
: Master yields immediately without polling.
3. 
**Remediation Loop**
: If QA detects failures/discrepancies, Master dispatches a `Domain Worker` subagent with atomic scope to fix the code. Master NEVER edits source code directly.
4. 
**Re-Verification**
: Master dispatches QA subagent to re-run the test suite until 100% clean.
5. 
**Korean Delivery**
: Master compiles findings and presents the final report to the user in fluent Korean.


---


## 4. 7-Stage Feature Lifecycle Runbook


```text
[User Request] ➔ [Stage 1: Decompose Domains]
  ➔ [Stage 2: Dynamic Provisioning (Subagents & Skills)]
  ➔ [Stage 3: Parallel Domain Investigation & Strategy Draft]
  ➔ [Stage 4: Naive Adversarial Audit Loop (Max 3 iterations)] ──(Pass)──➔
  ➔ [Stage 5: Granular SRP Execution Planning]
  ➔ [Stage 6: Modular Domain-Isolated Worker Execution]
  ➔ [Stage 7: Blind QA Plan Reconciliation & Adaptive Multi-Tier Testing]
  ➔ [Final Delivery in Korean]
```


### Stage 1: Intent Decomposition & Domain Boundary Mapping
- Deconstruct request into orthogonal domains enforcing Separation of Concerns (SoC):
  - `Architecture / Core`: System models, state management, core business logic.
  - `UI / UX`: Components, presentation, styling, interactions, animations.
  - `Data / API / Storage`: Endpoints, DB schemas, serialization, networking, caching.
  - `Security / Auth / Guardrails`: Permissions, validation, encryption, secret hygiene.
  - `QA / Verification`: Contract tests, regression suites, edge-case coverage.
  - `Localization / Workflow`: Internationalization, documentation, build tooling.


### Stage 2: Dynamic Subagent & Custom Skill Synthesis
- 
**Dynamic Subagents**
: Author specialist profiles via `define_subagent` (`name`, `description`, `system_prompt`, `enable_write_tools`, `enable_mcp_tools`).
- 
**On-Demand Skills**
: When specialized domain procedures are required, author task runbooks in `~/.gemini/skills/<name>/SKILL.md` or `.agents/skills/<name>/SKILL.md` before invocation.


### Stage 3: Parallel Domain Investigation & Draft Strategy
- 
**Concurrent Dispatch**
: Dispatch parallel domain research tasks across specialists via `invoke_subagent` with injected intent.
- 
**Async Yield**
: Stop calling tools immediately after `invoke_subagent`. Await reactive wakeup. Never poll.
- 
**Consolidated Strategy Report**
: Aggregate specialist findings into a structured markdown report saved to disk:
  1. Executive Summary & Problem Framing
  2. Domain Analysis & Architectural Invariants
  3. Strict Interface Contracts & Boundaries
  4. Edge Cases, Performance & Security Risks


### Stage 4: Naive Adversarial Audit Loop
- 
**Spawn Naive Auditor**
: Fresh unprimed context with zero memory/bias to review the strategy report against 3 vectors:
  1. 
*Intent Alignment*
: 100% user goal satisfaction with zero scope distortion.
  2. 
*Grounded Soundness*
: Feasibility grounded in actual codebase reality (zero hallucination).
  3. 
*Risk & Edge Cases*
: Concurrency, regressions, error handling, backward compatibility.
- 
**Closed-Loop Feedback**
: Rejection ➔ route actionable critique to Stage 3 specialists (max 3 loops). Approval ➔ advance to Stage 5.


### Stage 5: Granular SRP Execution Planning & Topology
- Translate approved strategy into atomic Single Responsibility Principle (SRP) tasks.
- Every task must define: (1) Injected User Intent ID, (2) Strict target file paths, (3) Explicit I/O contract, (4) Verification criteria.


### Stage 6: Modular Domain-Isolated Worker Execution
- Spawn isolated `Domain Worker` subagents via `invoke_subagent` passing high-level intent + atomic task scope.
- Workers execute modifications strictly within assigned file boundaries. Master yields execution asynchronously.
- Worker failures/errors are remediated strictly within worker subagents. Master never touches source files.


### Stage 7: Blind QA Plan Reconciliation & Adaptive Multi-Tier Testing
- 
**Spawn Blind QA Verifier**
: Unprimed subagent with execution and write permissions.
- 
**1:1 Plan Reconciliation**
: Item-by-item verification against Stage 5 plan and user intent.
- 
**Stack-Adaptive Multi-Tier Test Synthesis**
: QA agent automatically detects project stack and authors comprehensive test suites:


| Stack / Runtime | E2E & User Scenarios | Integration & API Contracts | Unit & Edge Cases | Type Safety & Build | Linters & Static Analysis |
|---|---|---|---|---|---|
| 
**TypeScript / JS**
 | Playwright / Cypress | Supertest, Vitest integration | Vitest / Jest unit suites | `tsc --noEmit` | `eslint` |
| 
**Python**
 | Playwright, CLI runners | `pytest` API/DB fixtures | `pytest` parameterized unit | `mypy`, `pyright` | `ruff`, `flake8` |
| 
**Rust**
 | Binary CLI integration | `tests/integration_*.rs` | `#[test]` unit modules | `cargo check` | `cargo clippy` |
| 
**Go**
 | CLI integration | `*_test.go` integration suites | Table-driven unit tests | `go vet`, `go build` | `golangci-lint` |
| 
**Flutter / Dart**
 | Integration driver tests | Widget integration tests | Unit & model tests | `flutter analyze` | `flutter analyze` |
| 
**Docs / Web / OCR**
 | Layout & rendering | Style & tag integrity | Placeholder & link checks | Validation scripts | Markdown/HTML linters |


- 
**Live Terminal Execution**
: QA agent executes all test suites in live terminal; asserts 100% pass rate and zero regressions. Discrepancies route to Stage 6 workers.
- 
**Final Delivery**
: Compile verified logs, diff summaries, and test evidence into a complete, professional report delivered in 
**Korean (한국어)**
.


---


## 5. Async Yielding & Language Protocol


- 
**Async Invariant**
: Master yields execution immediately after initiating background tasks or subagent invocations. Polling loops and sleep commands are forbidden.
- 
**Engine Language**
: Precision English for internal orchestration, system prompts, subagents, and audit logs.
- 
**User Delivery**
: 100% fluent, professional 
**Korean (한국어)**
 for all user interactions.

What’s the best tool right now for managing Anti-Gravity remotely from an Android phone?

My setup: Windows + Android. I’m comfortable using Antigravity 2.0, IDE, or CLI.

Is AG2R still the most reliable option, or has a better tool been released recently?

We all vibe code apps and websites but how do i actually test it for vulnerabilities, security bugs, loopholes for hackers. How can i make sure my app or software is safe. I know there are tools like code rabbit. Are there any open source free tools for this. Please do share if you know.

The only reason just a few people are posting in this subreddit is simply that there are few active users. Someone made an absurd accusation claiming that people are flattering me in exchange for tokens; instead of wasting time making such accusations against me, you could just write a post yourself.

3.7Flash New here

50% Discount

There was no issue with Antigravity itself. the problem lay with the model.

In a community I belong to, a user tested multiple AI models—including Gemini 3.7 Flash—against their own environment and codebase using Open Code. Contrary to its impressive benchmark scores, Gemini 3.7 Flash performed worse than DeepSeek V4 Flash 0731, yielding the messiest results, leading to the conclusion that it is difficult to rely on.

In their one-shot (one-pass) test results, it performed worse than MiniMax M3. Meanwhile, DS V4 Pro, Qwen 3.8 Max, and Grok 4.6 were quite impressive.

Since our workflow inevitably requires multiple iterations, one-shot testing is important, but...

On the other hand, Antigravity-CLI handled 3.6 Flash well, and I hope it does the same for 3.7 Flash.

However, my personal review is: "Gemini 3.7 Flash performs well if you restrict it to a narrow scope." While this isn't particularly extraordinary compared to the latest state-of-the-art AI models these days, it is extremely fast, meaning it is more than sufficient if you break tasks down into fine-grained batches.

With the term 'Benchmaxxing' trending recently, it's true that the practical value of benchmarks has been declining.

https://preview.redd.it/q7wyx2yos9jh1.png?width=1201&format=png&auto=webp&s=319c8cd9ef4a540015f6d8fd3e45a64a92410f97

https://preview.redd.it/3s412rh6t9jh1.png?width=999&format=png&auto=webp&s=94e0724d66e1e2508c7d76f862c5b10b32612450

https://preview.redd.it/80w7thj8t9jh1.png?width=999&format=png&auto=webp&s=b8c5609e5903956637c9192c3a522bebbd92e4f8

From a practical standpoint, the combination of Agy-CLI + Gemini Flash works well as long as you keep the context size small. It is reliable enough as an auxiliary tool.

>This is taken from the following tweet: https://x.com/googleaidevs/status/2085468449145544780

We’ve put together this cheat sheet of essential slash commands to help you navigate, customize, and execute tasks faster than ever in Google @Antigravity. Whether you're setting up background tasks, tweaking your workspace utilities, or diving into deep research with subagents, these commands will help improve your daily workflow.

🔖 Bookmark this list to save time later.

Planning & Execution

• /fast: Agent will execute tasks directly. Use for simple tasks that can be completed faster.
• /goal: Run until the specified goal is completely finished.
• /grill-me: Interview me to align on a plan.
• /planning: Agent can plan before executing tasks. Use for deep research, complex tasks, or collaborative work.
• /schedule: Run an instruction on a recurring schedule or as a one-time timer.

Customizations & Rules

• /hooks: Manage hook configurations for tool events.
• /keybindings: Set custom keybindings.
• /learn: Reflect on recent successes or corrections to capture reusable skills or rules.
• /mcp: Manage MCP servers.
• /permissions: Manage tool permissions.
• /skills: List available skills.

Subagents & Tasks

• /agents: List available custom agents.
• /tasks: View background tasks.
• /teamwork-preview: Invoke a team of agents to autonomously tackle large projects. (Only available for Google AI Ultra subscription)

Workspace Utilities

• /add-dir: Add a directory to the workspace.
• /antigravity-guide: Provides a comprehensive guide, quick reference, and sitemap for Google Antigravity.
• /artifact: View and review artifacts.
• /btw: Ask a side question without interrupting the current task.
• /changelog: Show release notes and changes.
• /clear: Clear conversation and start a new one (alias: /new).
• /codesearch: Search your entire codebase with live streaming results.
• /config: Open settings panel (alias: /settings).
• /context: Visualize current context usage.
• /copy: Copy the last planner response to the clipboard (may require allowing clipboard access).
• /credits: Displays third-party software licenses and attributions.
• /diff: View uncommitted changes and per-turn diffs.
• /effort: Adjust reasoning level to balance speed and depth.
• /exit: Exit the CLI (alias: /quit).
• /feedback: Submit qualitative feedback to improve the agent.
• /fork: Create a branch of the current conversation at this point (alias: /branch).
• /help: Show available commands and keybindings.
• /logout: Log out.
• /model: Set a model.
• /open: Open a file or view opened/edited files.
• /rename: Renames the active conversation thread.
• /resume: Browse and resume past conversations (aliases: /switch, /conversation).
• /rewind: Rewind conversation to a previous message (alias: /undo).
• /statusline: Toggle the statusline.
• /title: Toggle custom terminal window title.
• /usage: View model quota usage (alias: /quota).

Get started with Antigravity: https://antigravity.google/

Hi guys im new to agy cli. I want to know which plugins could enhance the workflow of agy.

I have only one plugins for now and it is ponytail which i thinks works fantastic by reducing lot of over engineered codes.

I need plugins for testing purposes, security checks such as sql injection, authentication checks and so on.

Please list out free plugins from githubs or other sources which is very useful.

Enlighten me!

Is there a way to continue the same Antigravity CLI conversation on another computer?

I use the CLI on both my desktop and laptop and want the conversation history/context to be available on both.

Has anyone successfully synced the Antigravity CLI conversation data between machines? What files need to be synced, and is there a recommended method?