Stop Passive AI Rewrites: Agentic Coaching in Google Docs with gdocumentor

A Go CLI and MCP server that turns Gemini and any AI agent into a Socratic writing and code review coach

Figure 1. Overview of the gdocumentor architecture and its four core pillars.

In my previous two articles—Building a Multimodal, Suggestion-Based AI Writing Coach with Gemini and Google Docs (Ref) and Beyond Passive AI Rewrites and Vibe Coding in Google Docs (Ref)—I introduced the Google Apps Script add-on DocuMentor AI (Ref). Those earlier articles explain the foundational inspiration behind the project, how programmatic Google Docs API (v1) suggestions and comments (Ref) can replace passive AI ghostwriting with active learning, and how a single Google Docs container-bound or Marketplace script can serve both individuals and school/enterprise domains. For background on those foundational concepts and the Google Apps Script implementation, please refer to those two published articles (Ref, Ref).

In this third installment, I introduce gdocumentor (Ref)—a high-performance Golang CLI tool, Global Model Context Protocol (MCP) Server (gdocumentor mcp), and Google Antigravity Agent Skill / Plugin (with support for 7 major AI agent environments) that liberates DocuMentor AI from the confines of a single open browser tab and transforms it into a 1-to-N scriptable, terminal-native, and autonomous AI-agent-driven coaching and document automation platform.

The 4 Core Pillars (Figure 1)

• 1. Multi-Source Input & Scoped Workspace: Ingests local files (.md, .pdf, .docx, .txt, source code), stdin, Web/GitHub URLs (#Lstart-Lend), and Google Docs (-d <docId>), with scoped line/character ranges (-t, --range) and automatic cross-file dependency discovery (--auto-deps).
• 2. Parallel Pipeline, RAG Persona & Dual AI Engine: Runs concurrent Go goroutine I/O (sync.WaitGroup) with custom personas (--persona) and RAG rulebooks (-r). Standalone CLI Mode calls the built-in Gemini API (gemini-3.8-flash / gemini-4-argon) via GEMINI_API_KEY, while MCP Server Mode (gdocumentor mcp) uses the client AI agent's own LLM (Host AI) (no GEMINI_API_KEY required).
• 3. Dual Coaching Modes, 0-Token Direct Editing & Decision Record: Supports Google Docs OAuth2 Mode (bottom-up UTF-16 WriteMode.SUGGEST inline edits, Socratic --hint comments, and a 🎓 DocuMentor AI Summary tab via --summary-tab), Zero-Auth Local Mode (--no-auth) for local Markdown reports (-o), 0-Token Direct Editing (edit) for Markdown/table/image insertion and resizing, and Decision Record tracking (Accepted, Edited, Rejected, Expired).
• 4. Universal Interfaces & Multi-Agent MCP: Provides an interactive CLI TUI, a pure JSON stream (--json), and 6 MCP tools (proofread, summary, inspect, draft, edit, manage).

1. Defining the Problem & Why Move Beyond a Browser Add-on

Why Passive AI Rewrites Fail

• Cognitive Debt (MIT Media Lab, June 2025): Passively accepting AI text measurably reduces brain activity and neural connectivity (Ref).
• The "Shortcut Trap" (CMU, Wharton & MIT, 2026): Just 10 minutes of passive AI reliance drops independent problem-solving performance by 20% (Ref, Ref).
• Declining Thinking Skills (Nikkei XTECH, Oct 2026): 42.1% of AI users cite declining thinking ability as their #1 concern (Ref).

Instead of silently overwriting text, gdocumentor enforces active human judgment:

• Suggest Mode: Proposes inline diffs (WriteMode.SUGGEST) paired with 💡 Reason and 🎓 Learning Point replies.
• Socratic Hint Mode (--hint): Withholds the rewritten answer and attaches only diagnostic hints so the human author writes the fix.

Two Limits of a Browser Add-on

• 1. 1-to-1 Browser Constraint: A Google Apps Script sidebar only works on one open browser tab at a time (with a 6-minute execution limit).
• 2. Locked to Internal Gemini API: A browser add-on cannot delegate reasoning to external AI agents (Antigravity, Claude Desktop, Cursor, VS Code) that you already use.

Figure 2. Paradigm shift from a 1-to-1 browser add-on to 1-to-N autonomous agentic coaching across classrooms, engineering teams, and research labs.

What gdocumentor Unlocks (Figure 2)

• Classrooms (1 Instructor ➔ N Student Docs): Batch-deliver Socratic hints (--hint), course rubrics (-r), and Summary Tabs (--summary-tab) across dozens of essays from the terminal or an AI agent.
• Engineering Teams (Local Repos & GitHub): Review exact line ranges (-t, #L1-L35) with automatic import resolution (--auto-deps) and team coding standards (-r), bridging code reviews directly into Pageless Google Docs.
• Research Labs & Individual Writers: Cross-check prose, tables (TABLE_1), and figures (VISUAL_1), track author growth via the Decision Record, or run 100% locally via --no-auth.

2. Architecture: 4-Stage Pipeline & Dual-Engine MCP

A. The 4-Stage Processing Pipeline

Figure 3. End-to-end workflow and 4-stage processing pipeline of gdocumentor.

• Stage 1 — Input, Scope & Context: Loads targets, marks --target / --range blocks editable (retaining surrounding lines as read-only context), resolves --auto-deps and -r RAG rules, and converts Markdown + local images into Pageless Google Docs.
• Stage 2 — Dual-Engine AI Inference: Standalone CLI packs text rules/context into XML blocks, uploads PDFs/visuals to the Gemini File API, and calls gemini-3.8-flash / gemini-4-argon; MCP Server delegates reasoning to the client AI agent's own LLM (model: "agent-ai").
• Stage 3 — Surrogate-Pair-Safe UTF-16 Matching (utf16idx): Maps edits to exact UTF-16 [StartIndex, EndIndex) offsets, filters out read-only scopes, and sorts bottom-to-top (StartIndex descending) to prevent index drift.
• Stage 4 — Two-Phase Application: Phase 1 applies WriteMode.SUGGEST replacements + addCommentReply rationales (or insertComment in --hint mode); Phase 2 re-fetches coordinates to anchor VISUAL_N / TABLE_N comments, builds the 🎓 DocuMentor AI Summary tab, and updates the Decision Record (or writes a local Markdown report in --no-auth mode).

B. Standalone CLI vs. MCP Server

Figure 4. Agentic ecosystem and dual-engine MCP architecture connecting AI orchestrators to Google Workspace and local filesystems.

C. 10 Standout Capabilities of gdocumentor

• 1. Zero-GEMINI_API_KEY Host-AI MCP + Standalone CLI Dual Engine: Delegates reasoning to your AI agent's own LLM (gdocumentor mcp) with no extra API key, or runs as a self-contained CLI via GEMINI_API_KEY.
• 2. Zero-Drift UTF-16 Coordinate Matching (utf16idx): Converts UTF-8 to surrogate-pair-safe UTF-16 offsets and applies batchUpdate edits bottom-to-top (StartIndex descending) so character indices never shift.
• 3. Socratic --hint Mode & Rationale Replies: Replaces passive ghostwriting with WriteMode.SUGGEST diffs + 💡 Reason / 🎓 Learning Point replies, or withholds answers entirely (--hint) so authors revise text themselves.
• 4. Multimodal Prose × Table (TABLE_1) × Figure (VISUAL_1) Verification: Cross-checks narrative claims against embedded images and tables, anchoring comments directly onto mismatched figures or tables.
• 5. Fail-Closed Line/Char Scoping (--target) + Auto-Dependencies (--auto-deps): Restricts edits strictly to specified ranges (#L1-L35, @0:2500) while automatically attaching imported files as read-only context.
• 6. 4-State Decision Record & Learning from Both AI (🤖 AI) and Human (👤 Human) Reviews (summary): Tracks Accepted, Edited (via bigram similarity), Rejected, and Expired outcomes, while gdocumentor summary analyzes existing suggestions and comments—including those written by human colleagues, instructors, or peer reviewers (👤 Human) as well as AI (🤖 AI)—to synthesize personalized writing/coding habits and actionable learning advice.
• 7. Zero-Auth Local Mode (--no-auth): Runs 100% locally without Google Cloud or OAuth2 tokens to output Markdown diff reports (-o).
• 8. 0-Token Direct Google Docs Editor (gdocumentor edit): Creates Pageless Docs, converts/inserts rich Markdown + tables + local images, and resizes VISUAL_1 in place without consuming a single LLM token.
• 9. 7-Client Installer (gdocumentor setup) & Windows 11 ↔ WSL2 Bridge (--wsl-host): Auto-configures Antigravity, Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, and Gemini CLI—including a 1-command wsl.exe bridge with automatic C:\... ⇄ /mnt/c/... path translation.
• 10. 1-to-N Parallel Batch Scaling & Multi-Language Coaching (-l): Processes multiple Google Docs concurrently and outputs coaching feedback in any target language (-l en, ja, de, fr, es, zh, ko, auto).

D. Why Build gdocumentor in Go (Golang)?

• Zero-Dependency Single Static Binary (CGO_ENABLED=0): No Python venv or Node.js node_modules—a single binary runs out of the box on macOS, Linux, and Windows (amd64 / arm64).
• Millisecond Cold Starts for MCP stdio & WSL2 Bridges: Instant subprocess startup keeps multi-step MCP tool chains (inspect ➔ edit ➔ proofread) snappy even across wsl.exe.
• Goroutine Concurrency (sync.WaitGroup) with No Time Limits: Loads files, converts Base64 images, uploads Gemini File API assets, and processes 1-to-N Google Docs in parallel without GAS's 6-minute ceiling.
• Native rune & unicode/utf16 Precision: Fast, type-safe conversion between UTF-8 strings and Google Docs API UTF-16 code units.
• Guaranteed defer Cleanup & Shared Type Safety: Automatically cleans up temporary cloud/local files on exit (defer) and shares 100% identical structs across Standalone CLI and MCP Server modes.

E. Why Self-Provisioning (gdocumentor setup) & WSL2 ↔ Windows Cross-OS Bridging Are Unique

• Push-Based Self-Provisioning Binary (Zero npx / uv Dependencies): Unlike client-side pull commands (claude mcp add, code --add-mcp) or external Node/Python installers (Smithery, FastMCP), the compiled gdocumentor binary itself knows every client's OS config path and JSON schema (mcpServers vs. VS Code's servers) and non-destructively merges its own setup in one command.
• Simultaneous MCP Server + Native Agent Skill/Rule Deployment: Existing MCP installers only register JSON server entries, leaving the Host AI unaware of workflow rules; gdocumentor setup simultaneously installs native coaching skills, rules, and subagents across all 7 clients (SKILL.md, .cursor/rules/gdocumentor-workflow.mdc, .github/instructions/gdocumentor.instructions.md, .windsurf/rules/gdocumentor-workflow.md, rules/gdocumentor-workflow.md, agents/gdocumentor-coach.md).
• 1-Command WSL2 ➔ Windows Host Cross-OS Bridge (--wsl-host): Previously, connecting Windows GUI clients (Claude Desktop, Cursor, VS Code, Windsurf) to a WSL2 MCP server required manually editing %APPDATA% JSON files or fragile bash -c scripts; running gdocumentor setup --all --wsl-host inside WSL2 auto-detects the Windows user profile under /mnt/c/Users/<WinUser>, updates Windows-side config files directly, and injects a shell-free wsl.exe --exec bridge.
• Unified OAuth2 Credentials & Lifecycle Management (--status / --uninstall): All Windows GUI clients and WSL2 CLI agents share a single Linux-side gdocumentor binary, Google Application Default Credentials (~/.config/gcloud/application_default_credentials.json), and Decision Records (~/.config/gdocumentor/decision_records/), with built-in cross-OS status diagnostics (--status) and clean non-destructive removal (--uninstall).

3. Quick Setup: Isolated Test Workspace (./gdocumentor_test)

Pre-compiled static binaries (CGO_ENABLED=0) for macOS, Linux, and Windows (amd64 / arm64) are available on GitHub Releases.

# 1. Install binary (Linux amd64 example; or use go install github.com/tanaikech/gdocumentor@latest) curl -L https://github.com/tanaikech/gdocumentor/releases/latest/download/gdocumentor_linux_amd64 -o gdocumentor chmod +x gdocumentor && sudo mv gdocumentor /usr/local/bin/ # 2. Install as an Antigravity CLI Plugin (or run: gdocumentor setup --all) agy plugin install https://github.com/tanaikech/gdocumentor # 3. Set Gemini API Key (Required for Part 1 CLI commands; NOT needed for Part 2 MCP prompts) export GEMINI_API_KEY="your-gemini-api-key" # 4. Create an isolated test workspace and copy sample files mkdir -p gdocumentor_test && cd gdocumentor_test git clone --depth 1 https://github.com/tanaikech/gdocumentor.git _repo cp -r _repo/sample . && cp "$(command -v gdocumentor)" ./gdocumentor && rm -rf _repo 

• Individual OAuth2 setup (gcloud auth application-default login): INSTALL_INDIVIDUAL.md
• Organization / school setup: INSTALL_ORGANIZATION.md

4. Part 1: 6 Foundational CLI Commands

Command 1: Zero-Auth Local Mode (--no-auth)

• 🔑 Credentials: GEMINI_API_KEY: Required | Google OAuth2: Not Required
• 🎯 What it does: Proofreads ./sample/sample_article.md (including TABLE_1 and local diagram VISUAL_1) 100% locally and saves ./my_first_review.md.

./gdocumentor --no-auth -i ./sample/sample_article.md -o ./my_first_review.md 

Figure 5. Terminal execution result of Command 1 in Zero-Auth local mode (--no-auth).

• Pipeline Execution (Figure 5): Confirms AUTH BYPASSED (--no-auth) and processes TargetFiles=1, EditableBlocks=9, Visuals=1, Tables=1.
• Learning Summary & Inline Suggestions: Catches fillers ('basically'), double superlatives ('most biggest'), and uncountable nouns ('softwares'), listing 6 bottom-to-top UTF-16 inline suggestions (#1–#6) with - Original, + Suggested, 💡 Reason, and 🎓 Learning.
• Multimodal Cross-Check (VISUAL_1 & TABLE_1): Detects that VISUAL_1 shows a 120-minute manual baseline in its chart while TABLE_1 omits that baseline row.

Command 2: Interactive Pageless Google Docs + Summary Tab (--summary-tab)

• 🔑 Credentials: GEMINI_API_KEY: Required | Google OAuth2: Required
• 🎯 What it does: Converts ./sample/sample_article.md (with its table and local PNG) into a Pageless Google Document, applies WriteMode.SUGGEST inline edits + rationale replies, and creates a 🎓 DocuMentor AI Summary tab.

./gdocumentor -i ./sample/sample_article.md \ -o ./interactive_coach_report.md \ --title "My Interactive Writing Coach Demo" \ --summary-tab 

Figure 6. Terminal execution result of Command 2 creating a Pageless Google Document and a dedicated Summary Tab.

Figure 7. Pageless Google Document created by Command 2 with native inline Suggested Edits and educational rationale replies.

• Terminal Output (Figure 6): Converts Markdown + image into a Pageless Doc, applies 8 coaching items, creates the Summary Tab, initializes the Decision Record (Pending AI: 6), and prints clickable URLs.
• Google Docs Canvas (Figure 7): Awkward phrases are replaced via green WriteMode.SUGGEST edits, each paired with a threaded 💡 Reason for Revision and 🎓 Learning Point reply on the right.

Command 3: Socratic Hint-Only Mode (--hint) + Persona + RAG Rubric

• 🔑 Credentials: GEMINI_API_KEY: Required | Google OAuth2: Required
• 🎯 What it does: Adopts a supportive professor persona (--persona), enforces ./sample/rules/writing_guidelines.md (-r), withholds all rewritten answers (--hint), and attaches Socratic questions as anchored Google Docs comments.

./gdocumentor -i ./sample/sample_article.md \ --hint \ --persona "You are a supportive university writing professor. Encourage critical thinking and explain structural weaknesses clearly without giving away the rewritten sentence." \ -r ./sample/rules/writing_guidelines.md \ --summary-tab \ -o ./socratic_hints_report.md \ --title "Student Essay - Socratic Hint Coaching" 

Figure 8. Terminal execution result of Command 3 in Socratic Hint-Only Mode (--hint) with a custom professor persona and RAG writing guidelines.

Figure 9. Google Document created by Command 3 showing anchored Socratic coaching hints without forced text rewrites.

• Terminal Output (Figure 8): Shows MODE hint and RAGRules=1. Every card omits + Suggested and instead cites the exact rule violated (Guideline 1–Guideline 5) with a Socratic prompt.
• Google Docs Canvas (Figure 9): Not a single word of the student's Google Doc is overwritten. Yellow-highlighted comments show the 🎯 Flagged Phrase, 💡 Issue to Check, and 🎓 Coaching Hint (Try Rewriting Yourself!).

Command 4: Scoped GitHub Code Review (#L1-L35) + Auto-Dependencies (--auto-deps)

• 🔑 Credentials: GEMINI_API_KEY: Required | Google OAuth2: Required
• 🎯 What it does: Reviews only lines 1–35 of a remote GitHub file, shallow-clones the repo in the background to attach imported files as read-only context (--auto-deps), and posts line-by-line WriteMode.SUGGEST code diffs into Google Docs.

./gdocumentor \ -t "https://github.com/tanaikech/DocuMentorAI/blob/main/src/code.js#L1-L35" \ --auto-deps \ -p "Focus on readability, maintainability, and modern JavaScript / Google Apps Script best practices." \ -o ./github_code_review.md \ --title "GitHub Scoped Code Review (#L1-L35)" 

Figure 10. Terminal execution result of Command 4 performing a scoped GitHub code review (#L1-L35) with automatic dependency resolution (--auto-deps).

Figure 11. Google Document created by Command 4 with line-by-line inline code suggestions and V8 best-practice rationales.

• Terminal Output (Figure 10): Resolves TargetFiles=1, ContextFiles=1, EditableBlocks=30 and proposes 2 scoped improvements: wrapping ALLOWED_MODELS in Object.freeze(...) (src/code.js:31) and documenting millisecond units on DECISION_STALE_TTL_MS (src/code.js:27).
• Google Docs Canvas (Figure 11): Renders clean line-by-line code in Google Docs with green WriteMode.SUGGEST diffs strictly inside lines 1–35.

Command 5: Structural Inspection, Decision Record & Learning from AI + Human Reviews (inspect, manage, & summary)

• 🔑 Credentials: inspect / manage: 0 Gemini tokens (GEMINI_API_KEY Not Required) | summary: GEMINI_API_KEY Required in CLI mode (or 0 GEMINI_API_KEY via Host-AI MCP) | Google OAuth2: Required
• 🎯 What it does: Inspects exact UTF-16 coordinates (inspect), tracks how authors respond to suggestions (manage), and analyzes both AI-generated (🤖 AI) and human-authored (👤 Human) suggestions and comments on a Google Doc (summary) to give the author actionable learning advice.

# 1. Inspect paragraph coordinates (@start:end), visual/table IDs, and pending AI/Human suggestions (0 LLM tokens) ./gdocumentor inspect -d "<YOUR_GOOGLE_DOC_ID>" # 2. Analyze existing suggestions & comments (from BOTH AI and human reviewers, including resolved history) to get learning advice ./gdocumentor summary -d "<YOUR_GOOGLE_DOC_ID>" --include-resolved --summary-tab # 3. Accept all pending suggestions and update the Coach Impact & Decision Record (0 LLM tokens) ./gdocumentor manage -d "<YOUR_GOOGLE_DOC_ID>" --accept-all 

• Structural Inspection (inspect): Prints all tabs, paragraph UTF-16 @start:end coordinates, VISUAL_N / TABLE_N IDs, active suggestions (🤖 AI vs. 👤 Human), and Decision Record counters with 0 LLM tokens.
• Learning Advice from AI & Human Reviews (summary): Reads all open and resolved (--include-resolved) inline suggestions and comment threads on the Google Document—not only those created by generative AI (🤖 AI), but also edits and comments left by human colleagues, teachers, or editors (👤 Human)—and generates a Writing Coach & Learning Summary (explaining why each human or AI edit matters, recurring weak points/habits, and concrete tips for future writing) without modifying the document text.
• Decision Reconciliation (manage --accept-all): Accepts pending suggestions and reconciles ~/.config/gdocumentor/decision_records/<docId>.json into ✅ Accepted, ✏️ Edited (author refined the text), ❌ Rejected, or 🗑️ Expired (>7 days or deleted), computing the Draft Improvement Rate while separating AI (🤖 AI) from human (👤 Human) edits.

Command 6: Zero-Token Direct Google Docs, Markdown & Image Editing (edit)

• 🔑 Credentials: GEMINI_API_KEY: Not Required (0 tokens) | Google OAuth2: Required
• 🎯 What it does: Creates a Google Doc, inserts initial text, converts and inserts rich Markdown (headings, formatting, checklist, 2×2 table, and ./sample/sample_figure.png) before Paragraph 2, and resizes VISUAL_1 to 320pt.

# 1. Create a new Google Document and insert initial paragraphs DOC_ID=$(./gdocumentor edit --create-doc --title "Live Release Notes" --json | jq -r '.documentId') printf "Paragraph 1: Introduction\nParagraph 2: Conclusion" | ./gdocumentor edit -d "$DOC_ID" # 2. Convert and insert rich Markdown (with a native table & local image) right before Paragraph 2 ./gdocumentor edit -d "$DOC_ID" --before-paragraph 2 --markdown << 'EOF' ## Key Highlights (Inserted from Markdown) This section includes **bold**, *italic*, `inline_code_var`, and a [Google Docs API](https://developers.google.com/docs/api) link. - Automated Coaching Pipeline - Supports Socratic `--hint` mode - [x] Direct Markdown & Image Insertion | Feature | Status | | :--- | :---: | | Native Markdown Conversion | **Ready** | | Image Insert / Replace / Delete | `Active` | ![Architecture Diagram](./sample/sample_figure.png) EOF # 3. Replace the first image (VISUAL_1) with a resized 320pt width version ./gdocumentor edit -d "$DOC_ID" --replace-image VISUAL_1 --with-image ./sample/sample_figure.png --image-width 320 

Figure 12. Terminal execution result of Command 6 executing deterministic 0-token Google Docs creation, rich Markdown insertion, and image resizing via gdocumentor edit.

Figure 13. Google Document created by Command 6 showing converted rich Markdown, a native 2×2 table, and a 320pt resized diagram placed between the introduction and conclusion.

• Terminal Output (Figure 12): Executes insert, insert-markdown, and replace-image deterministically in seconds with 0 Gemini tokens.
• Google Docs Canvas (Figure 13): Renders native Heading 2, bold/italic/code/link styling, nested bullets + checkbox, a 2×2 table, and VISUAL_1 resized to 320pt right between Paragraph 1 and Paragraph 2.

5. Part 2: 6 Autonomous AI Agent Prompts (Zero GEMINI_API_KEY via Host-AI MCP)

How Multi-Client AI Agents Work Without GEMINI_API_KEY

Figure 14. 3-stage visual workflow of the gdocumentor MCP Server in Zero-GEMINI_API_KEY Host-AI Mode across multi-client AI agents, showing Stage 1 (Your AI Client / Host AI), Stage 2 (gdocumentor MCP Engine), and Stage 3 (Mode A: Without Google Docs vs. Mode B: With Google Docs).

• Stage 1 — Your AI Client (Host AI • Zero GEMINI_API_KEY): Antigravity (agy), Claude Desktop, Claude Code, VS Code (Copilot), Cursor, Windsurf, or Gemini CLI uses its own active LLM (model: "agent-ai") to generate the coaching JSON (aiResult) in Suggest Mode or Socratic Hint Mode.
• Stage 2 — gdocumentor MCP Engine (MCP JSON-RPC stdio): Loads workspace/RAG context, maps originalText to bottom-up UTF-16 coordinates (utf16idx), and exposes 6 MCP tools (proofread, summary, inspect, draft, edit, manage).
• Stage 3 (🟢 Mode A — Without Google Docs / noAuth: true): Needs no GEMINI_API_KEY and no Google OAuth token, outputting local Markdown reports (-o) and direct chat tables.
• Stage 3 (🔵 Mode B — With Google Docs / OAuth2): Creates/updates Pageless Google Docs with inline WriteMode.SUGGEST edits or Socratic hints (Tab 1), a 🎓 DocuMentor AI Summary tab (Tab 2), and the Decision Record.

# View detailed setup help & cross-platform (WSL2 <-> Windows 11) guide: gdocumentor setup --help # Install & configure ALL supported AI clients on Linux / macOS / WSL2: gdocumentor setup --all # Inside WSL2, configure Windows 11 GUI apps (Claude Desktop, Cursor, VS Code, Windsurf) via wsl.exe bridge: gdocumentor setup --all --wsl-host 

Prompt 1: Zero-Auth Local Proofreading in ./

• 🔑 Credentials: GEMINI_API_KEY: Not Required | Google OAuth2: Not Required (noAuth: true)

Use gdocumentor without a Google OAuth access token (--no-auth) to proofread ./sample/sample_article.md (including its table and diagram) and save the coaching report to ./article_coaching.md in the current working directory. Then summarize the top 3 writing improvements and habits it found. 

Figure 15. Execution result of Prompt 1 in Antigravity CLI (agy) performing Zero-Auth local proofreading via Host-AI MCP and summarizing top writing habits.

• Host-AI MCP Execution (Figure 15): agy runs gdocumentor_proofread (noAuth: true) using its own Host AI, applying 10 coaching items (8 text + TABLE_1 + VISUAL_1) into ./article_coaching.md.
• Top 3 Habits Identified: Summarizes (1) removing colloquial fillers ("basically", "super simple"), (2) fixing uncountable nouns ("softwares" ➔ "software") and double superlatives ("most biggest"), and (3) integrating VISUAL_1 and TABLE_1 into the narrative prose.

Prompt 2: Socratic Hint-Only Mode + Summary Tab for Educators

• 🔑 Credentials: GEMINI_API_KEY: Not Required | Google OAuth2: Required

I am a university writing i...