Skip to content
Back to search

google-ai-mode-skill

Use this skill when the user requests current information, documentation, coding examples, or web research beyond the knowledge cutoff. Queries Google's AI Search mode to retrieve comprehensive AI-generated overviews with source citations from 100+ websites. Returns markdown with inline footnoted references [1][2][3]. You will receive a detailed Markdown file with references and information summarized directly from Google's AI search. Ideal for you to get new information and clues for further research.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/pleaseprompto-google-ai-mode-skill/badge.svg)](/listings/pleaseprompto-google-ai-mode-skill)

HTML

<a href="/listings/pleaseprompto-google-ai-mode-skill"><img src="/api/listings/pleaseprompto-google-ai-mode-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

The simplest installation ever:

# 1. Create skills directory (if it doesn't exist)
mkdir -p ~/.claude/skills

# 2. Clone this repository
cd ~/.claude/skills
git clone https://github.com/PleasePrompto/google-ai-mode-skill google-ai-mode

# 3. That's it! Open Claude Code and say:
"What are my skills?"

When you first use the skill, it automatically: - Creates an isolated Python environment (`.venv`) - Installs all dependencies including **Google Chrome** - Sets up browser automation with persistent profile - Everything stays contained in the skill folder

**Note:** The setup uses real Chrome (not Chromium) for cross-platform reliability, consistent browser fingerprinting, and better anti-detection with Google services.

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 213 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: google-ai-mode-skill
  3. description: Use this skill when the user requests current information, documentation, coding examples, or web research beyond the knowledge cutoff. Queries Google's AI Search mode to retrieve comprehensive AI-generated overviews with source citations from 100+ websites. Returns markdown with inline footnoted references [1][2][3]. You will receive a detailed Markdown file with references and information summarized directly from Google's AI search. Ideal for you to get new information and clues for further research.
  4. ---
  5. # Google AI Mode Skill
  6. Query Google's AI Search mode to retrieve comprehensive, source-grounded answers from across the web.
  7. ## When to Use This Skill
  8. Trigger this skill when the user:
  9. - Requests current information beyond the knowledge cutoff (post-January 2025)
  10. - Needs documentation or API references for libraries and frameworks
  11. - Asks for coding examples or implementation patterns
  12. - Wants technical comparisons or best practices
  13. - Requires research with citations and sources
  14. - Mentions "Google AI search", "Google AI mode", or "web research"
  15. ## CLI Flags
  16. ### Essential Flags
  17. **`--debug`** - Enable comprehensive logging
  18. ```bash
  19. python scripts/run.py search.py --query "..." --debug
  20. ```
  21. - Saves detailed logs to `logs/search_YYYY-MM-DD_HH-MM-SS.log`
  22. - Logs every step: browser launch, CAPTCHA detection, AI content waiting, citation extraction
  23. - Essential for troubleshooting CAPTCHA issues or failed searches
  24. - Log file path printed at completion
  25. **`--save`** - Save results to skill folder
  26. ```bash
  27. python scripts/run.py search.py --query "..." --save
  28. ```
  29. - Saves markdown to `results/YYYY-MM-DD_HH-MM-SS_Query_Name.md`
  30. - Timestamped filename for organized storage
  31. - Results preserved in skill directory for future reference
  32. - Use instead of `--output` for automatic naming
  33. **Combined usage** (recommended for debugging):
  34. ```bash
  35. python scripts/run.py search.py --query "..." --debug --save
  36. ```
  37. ### Other Flags
  38. **`--show-browser`** - Show browser window (for CAPTCHA solving)
  39. ```bash
  40. python scripts/run.py search.py --query "..." --show-browser
  41. ```
  42. **`--output <path>`** - Custom output file path
  43. ```bash
  44. python scripts/run.py search.py --query "..." --output result.md
  45. ```
  46. **`--json`** - Include JSON metadata in output
  47. ```bash
  48. python scripts/run.py search.py --query "..." --output result.md --json
  49. ```
  50. ## Query Optimization Strategy
  51. **CRITICAL**: Always optimize user queries before execution. Google AI Mode's quality depends on query precision.
  52. ### Optimization Template
  53. ```
  54. [Technology/Topic] [Version] [Year] ([Specific Aspect 1], [Aspect 2], [Aspect 3]). [Output format request].
  55. ```
  56. ### Optimization Rules
  57. 1. **Include Current Year (2026)** for up-to-date results
  58. 2. **Use parentheses** to list specific aspects needed
  59. 3. **Request structured output** (tables, comparisons, categorized lists)
  60. 4. **Include version numbers** for library/framework queries
  61. ### Examples
  62. | User Query | Optimized Query |
  63. |-----------|----------------|
  64. | "React hooks" | "React hooks best practices 2026 (useState, useEffect, custom hooks, common pitfalls). Provide code examples." |
  65. | "What's new in Rust?" | "Rust 1.75 new features 2026 (async traits, impl Trait improvements, const generics, stabilized APIs). Include migration guide and code examples." |
  66. | "PostgreSQL vs MySQL performance?" | "PostgreSQL vs MySQL performance comparison 2026 (query optimization, indexing strategies, concurrent writes, JSON handling, scaling patterns). Provide benchmark data and use case recommendations." |
  67. | "How to handle errors in Go?" | "Go error handling patterns 2026 (error wrapping, custom errors, sentinel errors, panic vs error, testing error cases). Provide code examples and best practices comparison." |
  68. | "Learn FastAPI basics" | "FastAPI tutorial 2026 (routing, dependency injection, async endpoints, request validation with Pydantic, OpenAPI documentation, testing). Include step-by-step implementation guide." |
  69. **Note:** If user provides an already detailed query with version numbers and requirements, use it as-is.
  70. ### Workflow
  71. 1. Receive user request
  72. 2. Optimize query using template above
  73. 3. Inform user: "Searching for: '[optimized query]'"
  74. 4. Execute search with `--save --debug` flags
  75. 5. Return results with inline citations [1][2][3]
  76. ## Script Execution
  77. **CRITICAL**: Always use the `run.py` wrapper. Direct script execution will fail.
  78. ### Basic Search
  79. ```bash
  80. python scripts/run.py search.py --query "Your search query"
  81. ```
  82. ### Recommended Usage
  83. ```bash
  84. python scripts/run.py search.py --query "..." --save --debug
  85. ```
  86. The `run.py` wrapper automatically:
  87. - Creates `.venv` on first run
  88. - Installs dependencies (patchright, beautifulsoup4, html-to-markdown)
  89. - Activates virtual environment
  90. - Executes search script
  91. - Installs Google Chrome (not Chromium) for anti-detection
  92. ## How It Works
  93. 1. **Persistent Browser Context**: Uses saved browser profile at `~/.cache/google-ai-mode-skill/chrome_profile` to preserve cookies/session between searches
  94. 2. **Eliminates CAPTCHAs**: Persistent context means Google recognizes the browser → rarely triggers CAPTCHA
  95. 3. **AI Content Detection**: Waits for Google AI Overview to appear on page
  96. 4. **Citation Extraction**: Injects JavaScript to extract source links from AI response
  97. 5. **Markdown Conversion**: Converts HTML to markdown with inline citations [1][2][3]
  98. 6. **Fast Results**: Typical search completes in 5-7 seconds (no CAPTCHA)
  99. ## CAPTCHA Handling
  100. **With persistent context, CAPTCHAs are rare.** If encountered:
  101. 1. **Detection**: Multi-layer check (URL `/sorry/index`, page text, content length)
  102. 2. **Automatic Handling**: If CAPTCHA detected in headless mode → script returns `CAPTCHA_REQUIRED` error
  103. 3. **Manual Solution**: Re-run with `--show-browser` flag, solve CAPTCHA in browser, script continues automatically
  104. **Note**: After CAPTCHA is solved once, persistent context preserves the session → future searches won't require CAPTCHA.
  105. ## Output Format
  106. Returns markdown with inline citations and source list. Example:
  107. ```markdown
  108. React 18 introduces concurrent features including Suspense for data fetching[1],
  109. automatic batching for state updates[2], and transitions for non-urgent updates[3].
  110. ---
  111. ## Sources:
  112. [1] React 18 Release Notes
  113. https://react.dev/blog/2022/03/29/react-v18
  114. [2] Automatic Batching Explained
  115. https://github.com/reactwg/react-18/discussions/21
  116. [3] Transitions API Documentation
  117. https://react.dev/reference/react/useTransition
  118. ```
  119. ## Common Use Cases
  120. ### Finding Library Documentation
  121. ```bash
  122. python scripts/run.py search.py --query "Prisma ORM 2026 (schema definition, migrations, client API, relation queries, transactions). Include TypeScript examples." --save --debug
  123. ```
  124. ### Getting Coding Examples
  125. ```bash
  126. python scripts/run.py search.py --query "WebSocket implementation Node.js 2026 (server setup, client connection, message handling, authentication, reconnection logic). Production-ready code examples." --save
  127. ```
  128. ### Technical Comparisons
  129. ```bash
  130. python scripts/run.py search.py --query "GraphQL vs REST API 2026 (performance, caching, tooling, type safety, learning curve). Comparison table with use case recommendations." --save
  131. ```
  132. ### Best Practices Research
  133. ```bash
  134. python scripts/run.py search.py --query "Microservices security patterns 2026 (API gateway authentication, service mesh, mutual TLS, secret management, observability). Architecture diagrams and implementation guide." --save --debug
  135. ```
  136. ## Troubleshooting
  137. | Issue | Solution |
  138. |-------|----------|
  139. | `ModuleNotFoundError` | Use `run.py` wrapper, never execute scripts directly |
  140. | CAPTCHA every time | First-time setup: solve CAPTCHA once with `--show-browser`, then persistent context preserves session |
  141. | No AI overview found | Rephrase query with more specificity using optimization template |
  142. | Browser fails to start | Verify internet connection and Chrome installation |
  143. | Need detailed logs | Use `--debug` flag - log saved to `logs/` folder |
  144. | AI Mode not available | Your region/country doesn't support Google AI Mode. Use a proxy/VPN to access from supported regions (US, UK, Germany, etc.) |
  145. **Exit Codes:**
  146. - `0` - Success
  147. - `1` - General error
  148. - `2` - CAPTCHA required (retry with `--show-browser`)
  149. - `3` - Browser closed by user
  150. - `4` - AI Mode not available in region (use proxy/VPN)
  151. - `130` - User interrupted (Ctrl+C)
  152. ## Best Practices
  153. 1. **Always optimize queries** - Specificity determines result quality
  154. 2. **Use `--save --debug` for important searches** - Preserves results and provides audit trail
  155. 3. **Include version numbers** for library/framework queries
  156. 4. **Request structured output** - Tables and comparisons improve usability
  157. 5. **Solve CAPTCHA once** - Persistent context eliminates future CAPTCHAs
  158. 6. **Verify citations** - Check provided sources for accuracy
README.md · README · 513 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. > [!WARNING]
  2. > **This project is no longer maintained.** As of September 2026 the repository is archived: no updates, bug fixes or support. It may stop working when the upstream services change. Feel free to fork.
  3. <div align="center">
  4. # Google AI Mode Skill
  5. ### **Supercharge Claude Code's Web Research with Google AI Mode**
  6. **For: Claude Code CLI users only**
  7. Transform your LLM's online research capabilities by connecting Claude Code directly to Google's AI Mode—getting AI-synthesized answers from 100+ sources instead of scattered search results.
  8. [![Python](https://img.shields.io/badge/Python-3.8+-blue.svg)](https://www.python.org/)
  9. [![Claude Code Skill](https://img.shields.io/badge/Claude%20Code-Skill-purple.svg)](https://www.anthropic.com/news/skills)
  10. [![Based on](https://img.shields.io/badge/Based%20on-Google%20AI%20Mode%20MCP-green.svg)](https://github.com/PleasePrompto/google-ai-mode-mcp)
  11. ### Why This Matters
  12. Most built-in web research is mediocre. This skill gives Claude Code **professional-grade research** by tapping into Google's AI Mode—the same technology that synthesizes information from dozens of websites into one cited answer.
  13. **Example Use Cases:**
  14. ```
  15. "Next.js 15 App Router best practices 2026 with server components examples"
  16. → AI-synthesized coding guide with inline citations [1][2][3]
  17. "Compare PostgreSQL vs MySQL JSON performance 2026, include benchmarks"
  18. → Technical comparison table with real-world data
  19. "Find the latest EU AI regulations 2026 and their impact on startups"
  20. → Legal overview with official government sources
  21. "Best noise-cancelling headphones under €300, compare Sony vs Bose"
  22. → Product comparison with reviews and specs
  23. "Intermittent fasting protocols 2026, include recent scientific studies"
  24. → Health guide with medical research citations
  25. ```
  26. **Result:** Research on **ANY topic**—coding, tech comparisons, regulations, product reviews, health, finance, travel. Curated answers with sources. Saves tokens. Superior to generic web search.
  27. [Installation](#installation) • [Quick Start](#quick-start) • [How It Works](#how-it-works) • [MCP Alternative](#mcp-server-alternative)
  28. </div>
  29. ---
  30. ## 📋 Last Updates (2026-01-08)
  31. **v2.0 - Multi-Language & Detection Overhaul**
  32. ✅ **4-Stage Completion Detection** - SVG thumbs-up → aria-label → text → 40s timeout
  33. ✅ **Multi-Language Support** - Works in DE/EN/NL/ES/FR/IT browser locales
  34. ✅ **87% Faster** - Average 4s detection (was 30s+)
  35. ✅ **AI Mode Availability Check** - Detects region restrictions with proxy suggestion
  36. ✅ **17 Citation Selectors** - Language-agnostic fallback chain
  37. ✅ **15 Cutoff Markers** - Cleaner content extraction across languages
  38. <details>
  39. <summary>📖 Show previous updates</summary>
  40. **v1.5** - Persistent browser profile, CAPTCHA elimination
  41. **v1.0** - Initial release with basic Google AI Mode integration
  42. </details>
  43. ---
  44. ## ⚠️ Important: Local Claude Code Only
  45. **This skill works ONLY with local [Claude Code](https://github.com/anthropics/claude-code) installations, NOT in the web UI.**
  46. The web UI runs skills in a sandbox without network access, which this skill requires for browser automation. You must use Claude Code locally on your machine.
  47. ---
  48. ## What This Is
  49. A Claude Code skill that connects your agent to **Google AI Mode**—Google's AI-powered search that synthesizes information from dozens of web sources into a single, cited answer.
  50. Instead of Claude reading page after page, Google does the heavy lifting. Claude gets one clean, structured response with inline citations.
  51. **The advantage:** Free, token-efficient research with grounded sources. No API keys needed.
  52. ---
  53. ## How It Works
  54. ```
  55. Claude asks a question
  56. ↓
  57. Skill launches stealth browser
  58. ↓
  59. Google AI Mode searches & synthesizes dozens of sources
  60. ↓
  61. Skill extracts AI answer + citations
  62. ↓
  63. Converts to clean Markdown with [1][2][3] references
  64. ↓
  65. Claude receives final answer
  66. ```
  67. **The key difference:**
  68. Traditional web research:
  69. - Claude searches Google → gets 10 links
  70. - Claude reads 5-10 full pages → thousands of tokens consumed
  71. - Claude synthesizes manually → risks missing details or hallucinating
  72. - You pay for all those tokens
  73. With this skill:
  74. - Google AI Mode searches + synthesizes → one request
  75. - Claude receives one clean, cited answer → minimal tokens
  76. - Google's sources are preserved → verifiable, grounded
  77. - It's free (uses public Google Search)
  78. ---
  79. ## Why This Matters
  80. Google AI Mode (the `udm=50` parameter) makes Google search work like a research assistant. It:
  81. - Reads and analyzes dozens of websites automatically
  82. - Synthesizes findings into structured answers
  83. - Cites every claim with source links
  84. - Handles follow-up context across queries
  85. Claude gets the benefits without doing the work—or burning the tokens.
  86. ---
  87. ## Installation
  88. ### The simplest installation ever:
  89. ```bash
  90. # 1. Create skills directory (if it doesn't exist)
  91. mkdir -p ~/.claude/skills
  92. # 2. Clone this repository
  93. cd ~/.claude/skills
  94. git clone https://github.com/PleasePrompto/google-ai-mode-skill google-ai-mode
  95. # 3. That's it! Open Claude Code and say:
  96. "What are my skills?"
  97. ```
  98. When you first use the skill, it automatically:
  99. - Creates an isolated Python environment (`.venv`)
  100. - Installs all dependencies including **Google Chrome**
  101. - Sets up browser automation with persistent profile
  102. - Everything stays contained in the skill folder
  103. **Note:** The setup uses real Chrome (not Chromium) for cross-platform reliability, consistent browser fingerprinting, and better anti-detection with Google services.
  104. ---
  105. ## Quick Start
  106. ### 1. Check your skills
  107. Say in Claude Code:
  108. ```
  109. "What skills do I have?"
  110. ```
  111. Claude will list your available skills including Google AI Mode.
  112. ### 2. Start researching
  113. ```
  114. "Search Google AI Mode for: Next.js 15 App Router best practices"
  115. ```
  116. ```
  117. "What are the new features in Astro 4.0?"
  118. ```
  119. ```
  120. "Research React Server Components"
  121. ```
  122. Claude will automatically use the skill to query Google AI Mode and return a clean, cited answer.
  123. ### 3. Get better results
  124. Be specific with your queries:
  125. **Instead of:** "React hooks"
  126. **Try:** "React hooks best practices 2026 (useState, useEffect, custom hooks). Include code examples."
  127. **Instead of:** "PostgreSQL features"
  128. **Try:** "PostgreSQL 16 JSON features and performance improvements 2026"
  129. ---
  130. ## First Run: CAPTCHA Handling
  131. On your first query, Google may show a CAPTCHA to verify you're human. This is normal when the browser profile is created.
  132. **If Claude reports a CAPTCHA error:**
  133. 1. Tell Claude: "Run that search with visible browser"
  134. 2. The browser will open visibly
  135. 3. Solve the CAPTCHA manually
  136. 4. The skill continues automatically
  137. 5. Next queries will work smoothly without CAPTCHAs
  138. After the first CAPTCHA, searches typically run smoothly. The skill uses a persistent browser profile to eliminate future CAPTCHAs.
  139. ---
  140. ## How the Skill Works
  141. This is a **Claude Code Skill**—a local folder containing instructions and scripts that Claude Code can use when needed. Unlike the [MCP server version](https://github.com/PleasePrompto/google-ai-mode-mcp), this runs directly in Claude Code without needing a separate server.
  142. ### Key Differences from MCP Server
  143. | Feature | This Skill | MCP Server |
  144. |---------|------------|------------|
  145. | **Protocol** | Claude Skills | Model Context Protocol |
  146. | **Installation** | Clone to `~/.claude/skills` | `claude mcp add ...` |
  147. | **Compatibility** | Claude Code only (local) | Claude Code, Codex, Cursor, Cline, etc. |
  148. | **Language** | Python | TypeScript |
  149. | **Browser Profile** | Persistent (eliminates CAPTCHAs) | Per-request context |
  150. | **Distribution** | Git clone | npm package |
  151. ### Architecture
  152. ```
  153. ~/.claude/skills/google-ai-mode/
  154. ├── SKILL.md # Instructions for Claude
  155. ├── scripts/ # Python automation scripts
  156. │ ├── run.py # Universal venv wrapper
  157. │ ├── search.py # Main search implementation
  158. │ ├── browser_utils.py # Browser automation
  159. │ └── config.py # Configuration
  160. ├── .venv/ # Isolated Python environment (auto-created)
  161. └── results/ # Saved search results (optional)
  162. ```
  163. When Claude needs web research:
  164. 1. Loads the skill instructions from SKILL.md
  165. 2. Runs the Python search script via run.py wrapper
  166. 3. Opens browser with persistent profile (Chrome)
  167. 4. Extracts AI answer + citations from Google
  168. 5. Returns clean Markdown to Claude
  169. 6. Claude uses that knowledge to help with your task
  170. ---
  171. ## Core Features
  172. **Source-Grounded Responses:**
  173. Google AI Mode synthesizes information from dozens of sources with inline citations. Every claim is backed by a source link.
  174. **Direct Integration:**
  175. No copy-paste between browser and editor. Claude queries and receives answers programmatically.
  176. **Persistent Browser Profile:**
  177. After solving the first CAPTCHA (if any), the browser profile is saved. Future searches run smoothly without interruption.
  178. **Zero Configuration:**
  179. Works out of the box. No API keys, no external services, no configuration files needed.
  180. **Self-Contained:**
  181. Everything runs in the skill folder with an isolated Python environment. No global installations.
  182. **Token Efficient:**
  183. One query returns one synthesized answer instead of Claude reading 5-10 full pages.
  184. ---
  185. ## Troubleshooting
  186. **Skill not found:**
  187. ```bash
  188. # Make sure it's in the right location
  189. ls ~/.claude/skills/google-ai-mode/
  190. # Should show: SKILL.md, scripts/, requirements.txt, etc.
  191. ```
  192. **Repeated CAPTCHAs:**
  193. If Google keeps showing CAPTCHAs:
  194. - Tell Claude: "Use visible browser for this search"
  195. - Add 10-30 second delays between searches
  196. - Make sure the persistent profile isn't corrupted
  197. **Browser won't launch:**
  198. Clear the browser profile:
  199. ```bash
  200. # Linux/macOS
  201. rm -rf ~/.cache/google-ai-mode-skill/chrome_profile
  202. # Windows
  203. rmdir /s "%LOCALAPPDATA%\google-ai-mode-skill\chrome_profile"
  204. ```
  205. **Dependencies issues:**
  206. ```bash
  207. # Manual reinstall if needed
  208. cd ~/.claude/skills/google-ai-mode
  209. rm -rf .venv
  210. python -m venv .venv
  211. source .venv/bin/activate # or .venv\Scripts\activate on Windows
  212. pip install -r requirements.txt
  213. python -m patchright install chrome
  214. ```
  215. **Wrong language results:**
  216. The skill forces English results. If you still get wrong languages, clear the browser profile (see above).
  217. ---
  218. ## Tips for Better Results
  219. **Be specific with your queries:**
  220. Instead of: "React hooks"
  221. Try: "React hooks best practices 2026 (useState, useEffect, custom hooks, common pitfalls)"
  222. **Include version numbers:**
  223. Instead of: "Next.js features"
  224. Try: "Next.js 15 new features and breaking changes"
  225. **Request structured output:**
  226. "Compare PostgreSQL vs MySQL 2026 with a performance comparison table"
  227. **Ask for examples:**
  228. "Show me TypeScript discriminated union examples with type narrowing"
  229. **Use the query template:**
  230. ```
  231. [Technology/Topic] [Version] [Year] ([Aspect 1], [Aspect 2], [Aspect 3]). [Format request].
  232. ```
  233. ---
  234. ## Example Use Case
  235. You need to implement OAuth2 in a framework you've never used before.
  236. **Traditional approach:**
  237. - Claude searches Google, gets 10 links
  238. - Reads multiple documentation pages and blog posts
  239. - Consumes thousands of tokens
  240. - May miss important details or synthesize incorrectly
  241. **With this skill:**
  242. ```
  243. "Search Google AI Mode for: Hono OAuth2 implementation guide"
  244. ```
  245. - Google reads and synthesizes sources automatically
  246. - Claude gets one structured answer with code examples and citations
  247. - Minimal token usage
  248. - Sources are linked for verification
  249. Claude can then use this grounded information to write the actual implementation.
  250. ---
  251. ## Technical Details
  252. **Core Technology:**
  253. - **Patchright**: Browser automation library (Playwright-based)
  254. - **Python 3.8+**: Implementation language
  255. - **Real Chrome**: Uses Google Chrome (not Chromium) for better reliability
  256. - **Persistent Context**: Saves browser profile to eliminate CAPTCHAs
  257. **Dependencies:**
  258. - `patchright==1.57.2` - Browser automation
  259. - `beautifulsoup4==4.14.3` - HTML parsing
  260. - `html-to-markdown==2.19.6` - HTML conversion
  261. **Data Storage:**
  262. All data is stored locally within the skill directory:
  263. ```
  264. ~/.cache/google-ai-mode-skill/
  265. └── chrome_profile/ - Persistent browser profile (cookies, session)
  266. ```
  267. ---
  268. ## Limitations
  269. **Skill-Specific:**
  270. - **Local Claude Code only** - Does not work in web UI (sandbox restrictions)
  271. - **Manual CAPTCHA solving** - First query may require human verification
  272. - **Python dependency** - Requires Python 3.8+ on your system
  273. **Google AI Mode:**
  274. - **Rate limits** - Frequent searches may trigger CAPTCHAs
  275. - **Public search only** - No authentication required or supported
  276. - **Query quality matters** - Vague queries may not trigger AI overviews
  277. ---
  278. ## FAQ
  279. **Why doesn't this work in the Claude web UI?**
  280. The web UI runs skills in a sandbox without network access. Browser automation requires network access to reach Google.
  281. **How is this different from the MCP server?**
  282. This is a simpler, Python-based implementation that runs directly as a Claude Skill. The MCP server is more feature-rich and works with multiple tools (Codex, Cursor, etc.).
  283. **Can I use both this skill and the MCP server?**
  284. Yes, but you probably don't need both. Use the skill for Claude Code, use the MCP server if you want multi-agent support (Cursor, Cline, etc.).
  285. **Is it free?**
  286. Yes. The skill is open source, and it uses public Google Search. No API keys or subscriptions needed.
  287. **Is my data private?**
  288. Everything runs locally on your machine. The browser profile stays on your computer. No credentials or external services required beyond Google Search.
  289. **What if the browser keeps crashing?**
  290. Clear the browser profile (see Troubleshooting section) and try again.
  291. ---
  292. ## Important Notes
  293. **CAPTCHA handling:**
  294. Google may show a CAPTCHA on first use. Tell Claude to show the browser, solve it manually, and you're good to go for future searches.
  295. **Responsible use:**
  296. This tool automates browser interactions with Google Search. Use it responsibly and be mindful of Google's Terms of Service. Add delays between heavy search sessions if needed.
  297. **Verification:**
  298. While results come from Google's AI Mode with source citations, always verify critical information via the linked sources. This is a research tool, not a source of truth.
  299. ---
  300. ## MCP Server Alternative
  301. **Using other code agents (Cursor, Codex, Cline, Windsurf)?**
  302. There's a full **MCP server version** of this tool that works with any MCP-compatible agent, not just Claude Code.
  303. **Check it out:** [google-ai-mode-mcp](https://github.com/PleasePrompto/google-ai-mode-mcp)
  304. The MCP version offers:
  305. - Works with Claude Code, Codex, Cursor, Cline, Windsurf, Zed, etc.
  306. - TypeScript implementation
  307. - npm package distribution
  308. - One-line installation: `claude mcp add google-ai-search npx google-ai-mode-mcp@latest`
  309. If you only use Claude Code, this skill is perfect. If you use multiple agents, consider the MCP server instead.
  310. ---
  311. ## Contributing
  312. Found an issue or want to contribute?
  313. - Report bugs: [GitHub Issues](https://github.com/PleasePrompto/google-ai-mode-skill/issues)
  314. - Pull requests: Welcome
  315. - Contact: See parent repository
  316. ---
  317. ## License
  318. MIT License - see LICENSE file for details
  319. ---
  320. ## Credits
  321. This skill is inspired by the [**Google AI Mode MCP Server**](https://github.com/PleasePrompto/google-ai-mode-mcp) and provides an alternative implementation as a Claude Code Skill:
  322. - Both use Patchright for browser automation (MCP uses TypeScript, Skill uses Python)
  323. - Skill version runs directly in Claude Code without MCP protocol
  324. - Optimized for Claude Code's skill architecture
  325. If you need:
  326. - **Multi-agent support** (Cursor, Cline, etc.) → Use the [MCP Server](https://github.com/PleasePrompto/google-ai-mode-mcp)
  327. - **Claude Code only** → Use this skill
  328. - **npm distribution** → Use the [MCP Server](https://github.com/PleasePrompto/google-ai-mode-mcp)
  329. - **Git clone simplicity** → Use this skill
  330. ---
  331. ## The Bottom Line
  332. **Without this skill**: Claude searches Google → Gets links → Reads 5-10 pages → Thousands of tokens → Potential hallucinations
  333. **With this skill**: Claude queries Google AI Mode → Gets one synthesized answer with citations → Minimal tokens → Grounded results
  334. Stop burning tokens on web research. Start getting accurate, cited answers directly in Claude Code.
  335. ```bash
  336. # Get started in 30 seconds
  337. cd ~/.claude/skills
  338. git clone https://github.com/PleasePrompto/google-ai-mode-skill google-ai-mode
  339. # Open Claude Code: "What are my skills?"
  340. ```
  341. ---
  342. <div align="center">
  343. Built as a Claude Code Skill adaptation of the [Google AI Mode MCP Server](https://github.com/PleasePrompto/google-ai-mode-mcp)
  344. For free, token-efficient web research directly in Claude Code
  345. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.