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.
Badge for your README
Markdown
[](/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
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)
- ---
- name: google-ai-mode-skill
- 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.
- ---
- # Google AI Mode Skill
- Query Google's AI Search mode to retrieve comprehensive, source-grounded answers from across the web.
- ## When to Use This Skill
- Trigger this skill when the user:
- - Requests current information beyond the knowledge cutoff (post-January 2025)
- - Needs documentation or API references for libraries and frameworks
- - Asks for coding examples or implementation patterns
- - Wants technical comparisons or best practices
- - Requires research with citations and sources
- - Mentions "Google AI search", "Google AI mode", or "web research"
- ## CLI Flags
- ### Essential Flags
- **`--debug`** - Enable comprehensive logging
- ```bash
- python scripts/run.py search.py --query "..." --debug
- ```
- - Saves detailed logs to `logs/search_YYYY-MM-DD_HH-MM-SS.log`
- - Logs every step: browser launch, CAPTCHA detection, AI content waiting, citation extraction
- - Essential for troubleshooting CAPTCHA issues or failed searches
- - Log file path printed at completion
- **`--save`** - Save results to skill folder
- ```bash
- python scripts/run.py search.py --query "..." --save
- ```
- - Saves markdown to `results/YYYY-MM-DD_HH-MM-SS_Query_Name.md`
- - Timestamped filename for organized storage
- - Results preserved in skill directory for future reference
- - Use instead of `--output` for automatic naming
- **Combined usage** (recommended for debugging):
- ```bash
- python scripts/run.py search.py --query "..." --debug --save
- ```
- ### Other Flags
- **`--show-browser`** - Show browser window (for CAPTCHA solving)
- ```bash
- python scripts/run.py search.py --query "..." --show-browser
- ```
- **`--output <path>`** - Custom output file path
- ```bash
- python scripts/run.py search.py --query "..." --output result.md
- ```
- **`--json`** - Include JSON metadata in output
- ```bash
- python scripts/run.py search.py --query "..." --output result.md --json
- ```
- ## Query Optimization Strategy
- **CRITICAL**: Always optimize user queries before execution. Google AI Mode's quality depends on query precision.
- ### Optimization Template
- ```
- [Technology/Topic] [Version] [Year] ([Specific Aspect 1], [Aspect 2], [Aspect 3]). [Output format request].
- ```
- ### Optimization Rules
- 1. **Include Current Year (2026)** for up-to-date results
- 2. **Use parentheses** to list specific aspects needed
- 3. **Request structured output** (tables, comparisons, categorized lists)
- 4. **Include version numbers** for library/framework queries
- ### Examples
- | User Query | Optimized Query |
- |-----------|----------------|
- | "React hooks" | "React hooks best practices 2026 (useState, useEffect, custom hooks, common pitfalls). Provide code examples." |
- | "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." |
- | "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." |
- | "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." |
- | "Learn FastAPI basics" | "FastAPI tutorial 2026 (routing, dependency injection, async endpoints, request validation with Pydantic, OpenAPI documentation, testing). Include step-by-step implementation guide." |
- **Note:** If user provides an already detailed query with version numbers and requirements, use it as-is.
- ### Workflow
- 1. Receive user request
- 2. Optimize query using template above
- 3. Inform user: "Searching for: '[optimized query]'"
- 4. Execute search with `--save --debug` flags
- 5. Return results with inline citations [1][2][3]
- ## Script Execution
- **CRITICAL**: Always use the `run.py` wrapper. Direct script execution will fail.
- ### Basic Search
- ```bash
- python scripts/run.py search.py --query "Your search query"
- ```
- ### Recommended Usage
- ```bash
- python scripts/run.py search.py --query "..." --save --debug
- ```
- The `run.py` wrapper automatically:
- - Creates `.venv` on first run
- - Installs dependencies (patchright, beautifulsoup4, html-to-markdown)
- - Activates virtual environment
- - Executes search script
- - Installs Google Chrome (not Chromium) for anti-detection
- ## How It Works
- 1. **Persistent Browser Context**: Uses saved browser profile at `~/.cache/google-ai-mode-skill/chrome_profile` to preserve cookies/session between searches
- 2. **Eliminates CAPTCHAs**: Persistent context means Google recognizes the browser → rarely triggers CAPTCHA
- 3. **AI Content Detection**: Waits for Google AI Overview to appear on page
- 4. **Citation Extraction**: Injects JavaScript to extract source links from AI response
- 5. **Markdown Conversion**: Converts HTML to markdown with inline citations [1][2][3]
- 6. **Fast Results**: Typical search completes in 5-7 seconds (no CAPTCHA)
- ## CAPTCHA Handling
- **With persistent context, CAPTCHAs are rare.** If encountered:
- 1. **Detection**: Multi-layer check (URL `/sorry/index`, page text, content length)
- 2. **Automatic Handling**: If CAPTCHA detected in headless mode → script returns `CAPTCHA_REQUIRED` error
- 3. **Manual Solution**: Re-run with `--show-browser` flag, solve CAPTCHA in browser, script continues automatically
- **Note**: After CAPTCHA is solved once, persistent context preserves the session → future searches won't require CAPTCHA.
- ## Output Format
- Returns markdown with inline citations and source list. Example:
- ```markdown
- React 18 introduces concurrent features including Suspense for data fetching[1],
- automatic batching for state updates[2], and transitions for non-urgent updates[3].
- ---
- ## Sources:
- [1] React 18 Release Notes
- https://react.dev/blog/2022/03/29/react-v18
- [2] Automatic Batching Explained
- https://github.com/reactwg/react-18/discussions/21
- [3] Transitions API Documentation
- https://react.dev/reference/react/useTransition
- ```
- ## Common Use Cases
- ### Finding Library Documentation
- ```bash
- python scripts/run.py search.py --query "Prisma ORM 2026 (schema definition, migrations, client API, relation queries, transactions). Include TypeScript examples." --save --debug
- ```
- ### Getting Coding Examples
- ```bash
- 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
- ```
- ### Technical Comparisons
- ```bash
- 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
- ```
- ### Best Practices Research
- ```bash
- 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
- ```
- ## Troubleshooting
- | Issue | Solution |
- |-------|----------|
- | `ModuleNotFoundError` | Use `run.py` wrapper, never execute scripts directly |
- | CAPTCHA every time | First-time setup: solve CAPTCHA once with `--show-browser`, then persistent context preserves session |
- | No AI overview found | Rephrase query with more specificity using optimization template |
- | Browser fails to start | Verify internet connection and Chrome installation |
- | Need detailed logs | Use `--debug` flag - log saved to `logs/` folder |
- | 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.) |
- **Exit Codes:**
- - `0` - Success
- - `1` - General error
- - `2` - CAPTCHA required (retry with `--show-browser`)
- - `3` - Browser closed by user
- - `4` - AI Mode not available in region (use proxy/VPN)
- - `130` - User interrupted (Ctrl+C)
- ## Best Practices
- 1. **Always optimize queries** - Specificity determines result quality
- 2. **Use `--save --debug` for important searches** - Preserves results and provides audit trail
- 3. **Include version numbers** for library/framework queries
- 4. **Request structured output** - Tables and comparisons improve usability
- 5. **Solve CAPTCHA once** - Persistent context eliminates future CAPTCHAs
- 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)
- > [!WARNING]
- > **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.
- <div align="center">
- # Google AI Mode Skill
- ### **Supercharge Claude Code's Web Research with Google AI Mode**
- **For: Claude Code CLI users only**
- 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.
- [](https://www.python.org/)
- [](https://www.anthropic.com/news/skills)
- [](https://github.com/PleasePrompto/google-ai-mode-mcp)
- ### Why This Matters
- 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.
- **Example Use Cases:**
- ```
- "Next.js 15 App Router best practices 2026 with server components examples"
- → AI-synthesized coding guide with inline citations [1][2][3]
- "Compare PostgreSQL vs MySQL JSON performance 2026, include benchmarks"
- → Technical comparison table with real-world data
- "Find the latest EU AI regulations 2026 and their impact on startups"
- → Legal overview with official government sources
- "Best noise-cancelling headphones under €300, compare Sony vs Bose"
- → Product comparison with reviews and specs
- "Intermittent fasting protocols 2026, include recent scientific studies"
- → Health guide with medical research citations
- ```
- **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.
- [Installation](#installation) • [Quick Start](#quick-start) • [How It Works](#how-it-works) • [MCP Alternative](#mcp-server-alternative)
- </div>
- ---
- ## 📋 Last Updates (2026-01-08)
- **v2.0 - Multi-Language & Detection Overhaul**
- ✅ **4-Stage Completion Detection** - SVG thumbs-up → aria-label → text → 40s timeout
- ✅ **Multi-Language Support** - Works in DE/EN/NL/ES/FR/IT browser locales
- ✅ **87% Faster** - Average 4s detection (was 30s+)
- ✅ **AI Mode Availability Check** - Detects region restrictions with proxy suggestion
- ✅ **17 Citation Selectors** - Language-agnostic fallback chain
- ✅ **15 Cutoff Markers** - Cleaner content extraction across languages
- <details>
- <summary>📖 Show previous updates</summary>
- **v1.5** - Persistent browser profile, CAPTCHA elimination
- **v1.0** - Initial release with basic Google AI Mode integration
- </details>
- ---
- ## ⚠️ Important: Local Claude Code Only
- **This skill works ONLY with local [Claude Code](https://github.com/anthropics/claude-code) installations, NOT in the web UI.**
- 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.
- ---
- ## What This Is
- 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.
- Instead of Claude reading page after page, Google does the heavy lifting. Claude gets one clean, structured response with inline citations.
- **The advantage:** Free, token-efficient research with grounded sources. No API keys needed.
- ---
- ## How It Works
- ```
- Claude asks a question
- ↓
- Skill launches stealth browser
- ↓
- Google AI Mode searches & synthesizes dozens of sources
- ↓
- Skill extracts AI answer + citations
- ↓
- Converts to clean Markdown with [1][2][3] references
- ↓
- Claude receives final answer
- ```
- **The key difference:**
- Traditional web research:
- - Claude searches Google → gets 10 links
- - Claude reads 5-10 full pages → thousands of tokens consumed
- - Claude synthesizes manually → risks missing details or hallucinating
- - You pay for all those tokens
- With this skill:
- - Google AI Mode searches + synthesizes → one request
- - Claude receives one clean, cited answer → minimal tokens
- - Google's sources are preserved → verifiable, grounded
- - It's free (uses public Google Search)
- ---
- ## Why This Matters
- Google AI Mode (the `udm=50` parameter) makes Google search work like a research assistant. It:
- - Reads and analyzes dozens of websites automatically
- - Synthesizes findings into structured answers
- - Cites every claim with source links
- - Handles follow-up context across queries
- Claude gets the benefits without doing the work—or burning the tokens.
- ---
- ## Installation
- ### The simplest installation ever:
- ```bash
- # 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.
- ---
- ## Quick Start
- ### 1. Check your skills
- Say in Claude Code:
- ```
- "What skills do I have?"
- ```
- Claude will list your available skills including Google AI Mode.
- ### 2. Start researching
- ```
- "Search Google AI Mode for: Next.js 15 App Router best practices"
- ```
- ```
- "What are the new features in Astro 4.0?"
- ```
- ```
- "Research React Server Components"
- ```
- Claude will automatically use the skill to query Google AI Mode and return a clean, cited answer.
- ### 3. Get better results
- Be specific with your queries:
- **Instead of:** "React hooks"
- **Try:** "React hooks best practices 2026 (useState, useEffect, custom hooks). Include code examples."
- **Instead of:** "PostgreSQL features"
- **Try:** "PostgreSQL 16 JSON features and performance improvements 2026"
- ---
- ## First Run: CAPTCHA Handling
- On your first query, Google may show a CAPTCHA to verify you're human. This is normal when the browser profile is created.
- **If Claude reports a CAPTCHA error:**
- 1. Tell Claude: "Run that search with visible browser"
- 2. The browser will open visibly
- 3. Solve the CAPTCHA manually
- 4. The skill continues automatically
- 5. Next queries will work smoothly without CAPTCHAs
- After the first CAPTCHA, searches typically run smoothly. The skill uses a persistent browser profile to eliminate future CAPTCHAs.
- ---
- ## How the Skill Works
- 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.
- ### Key Differences from MCP Server
- | Feature | This Skill | MCP Server |
- |---------|------------|------------|
- | **Protocol** | Claude Skills | Model Context Protocol |
- | **Installation** | Clone to `~/.claude/skills` | `claude mcp add ...` |
- | **Compatibility** | Claude Code only (local) | Claude Code, Codex, Cursor, Cline, etc. |
- | **Language** | Python | TypeScript |
- | **Browser Profile** | Persistent (eliminates CAPTCHAs) | Per-request context |
- | **Distribution** | Git clone | npm package |
- ### Architecture
- ```
- ~/.claude/skills/google-ai-mode/
- ├── SKILL.md # Instructions for Claude
- ├── scripts/ # Python automation scripts
- │ ├── run.py # Universal venv wrapper
- │ ├── search.py # Main search implementation
- │ ├── browser_utils.py # Browser automation
- │ └── config.py # Configuration
- ├── .venv/ # Isolated Python environment (auto-created)
- └── results/ # Saved search results (optional)
- ```
- When Claude needs web research:
- 1. Loads the skill instructions from SKILL.md
- 2. Runs the Python search script via run.py wrapper
- 3. Opens browser with persistent profile (Chrome)
- 4. Extracts AI answer + citations from Google
- 5. Returns clean Markdown to Claude
- 6. Claude uses that knowledge to help with your task
- ---
- ## Core Features
- **Source-Grounded Responses:**
- Google AI Mode synthesizes information from dozens of sources with inline citations. Every claim is backed by a source link.
- **Direct Integration:**
- No copy-paste between browser and editor. Claude queries and receives answers programmatically.
- **Persistent Browser Profile:**
- After solving the first CAPTCHA (if any), the browser profile is saved. Future searches run smoothly without interruption.
- **Zero Configuration:**
- Works out of the box. No API keys, no external services, no configuration files needed.
- **Self-Contained:**
- Everything runs in the skill folder with an isolated Python environment. No global installations.
- **Token Efficient:**
- One query returns one synthesized answer instead of Claude reading 5-10 full pages.
- ---
- ## Troubleshooting
- **Skill not found:**
- ```bash
- # Make sure it's in the right location
- ls ~/.claude/skills/google-ai-mode/
- # Should show: SKILL.md, scripts/, requirements.txt, etc.
- ```
- **Repeated CAPTCHAs:**
- If Google keeps showing CAPTCHAs:
- - Tell Claude: "Use visible browser for this search"
- - Add 10-30 second delays between searches
- - Make sure the persistent profile isn't corrupted
- **Browser won't launch:**
- Clear the browser profile:
- ```bash
- # Linux/macOS
- rm -rf ~/.cache/google-ai-mode-skill/chrome_profile
- # Windows
- rmdir /s "%LOCALAPPDATA%\google-ai-mode-skill\chrome_profile"
- ```
- **Dependencies issues:**
- ```bash
- # Manual reinstall if needed
- cd ~/.claude/skills/google-ai-mode
- rm -rf .venv
- python -m venv .venv
- source .venv/bin/activate # or .venv\Scripts\activate on Windows
- pip install -r requirements.txt
- python -m patchright install chrome
- ```
- **Wrong language results:**
- The skill forces English results. If you still get wrong languages, clear the browser profile (see above).
- ---
- ## Tips for Better Results
- **Be specific with your queries:**
- Instead of: "React hooks"
- Try: "React hooks best practices 2026 (useState, useEffect, custom hooks, common pitfalls)"
- **Include version numbers:**
- Instead of: "Next.js features"
- Try: "Next.js 15 new features and breaking changes"
- **Request structured output:**
- "Compare PostgreSQL vs MySQL 2026 with a performance comparison table"
- **Ask for examples:**
- "Show me TypeScript discriminated union examples with type narrowing"
- **Use the query template:**
- ```
- [Technology/Topic] [Version] [Year] ([Aspect 1], [Aspect 2], [Aspect 3]). [Format request].
- ```
- ---
- ## Example Use Case
- You need to implement OAuth2 in a framework you've never used before.
- **Traditional approach:**
- - Claude searches Google, gets 10 links
- - Reads multiple documentation pages and blog posts
- - Consumes thousands of tokens
- - May miss important details or synthesize incorrectly
- **With this skill:**
- ```
- "Search Google AI Mode for: Hono OAuth2 implementation guide"
- ```
- - Google reads and synthesizes sources automatically
- - Claude gets one structured answer with code examples and citations
- - Minimal token usage
- - Sources are linked for verification
- Claude can then use this grounded information to write the actual implementation.
- ---
- ## Technical Details
- **Core Technology:**
- - **Patchright**: Browser automation library (Playwright-based)
- - **Python 3.8+**: Implementation language
- - **Real Chrome**: Uses Google Chrome (not Chromium) for better reliability
- - **Persistent Context**: Saves browser profile to eliminate CAPTCHAs
- **Dependencies:**
- - `patchright==1.57.2` - Browser automation
- - `beautifulsoup4==4.14.3` - HTML parsing
- - `html-to-markdown==2.19.6` - HTML conversion
- **Data Storage:**
- All data is stored locally within the skill directory:
- ```
- ~/.cache/google-ai-mode-skill/
- └── chrome_profile/ - Persistent browser profile (cookies, session)
- ```
- ---
- ## Limitations
- **Skill-Specific:**
- - **Local Claude Code only** - Does not work in web UI (sandbox restrictions)
- - **Manual CAPTCHA solving** - First query may require human verification
- - **Python dependency** - Requires Python 3.8+ on your system
- **Google AI Mode:**
- - **Rate limits** - Frequent searches may trigger CAPTCHAs
- - **Public search only** - No authentication required or supported
- - **Query quality matters** - Vague queries may not trigger AI overviews
- ---
- ## FAQ
- **Why doesn't this work in the Claude web UI?**
- The web UI runs skills in a sandbox without network access. Browser automation requires network access to reach Google.
- **How is this different from the MCP server?**
- 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.).
- **Can I use both this skill and the MCP server?**
- 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.).
- **Is it free?**
- Yes. The skill is open source, and it uses public Google Search. No API keys or subscriptions needed.
- **Is my data private?**
- Everything runs locally on your machine. The browser profile stays on your computer. No credentials or external services required beyond Google Search.
- **What if the browser keeps crashing?**
- Clear the browser profile (see Troubleshooting section) and try again.
- ---
- ## Important Notes
- **CAPTCHA handling:**
- 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.
- **Responsible use:**
- 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.
- **Verification:**
- 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.
- ---
- ## MCP Server Alternative
- **Using other code agents (Cursor, Codex, Cline, Windsurf)?**
- There's a full **MCP server version** of this tool that works with any MCP-compatible agent, not just Claude Code.
- **Check it out:** [google-ai-mode-mcp](https://github.com/PleasePrompto/google-ai-mode-mcp)
- The MCP version offers:
- - Works with Claude Code, Codex, Cursor, Cline, Windsurf, Zed, etc.
- - TypeScript implementation
- - npm package distribution
- - One-line installation: `claude mcp add google-ai-search npx google-ai-mode-mcp@latest`
- If you only use Claude Code, this skill is perfect. If you use multiple agents, consider the MCP server instead.
- ---
- ## Contributing
- Found an issue or want to contribute?
- - Report bugs: [GitHub Issues](https://github.com/PleasePrompto/google-ai-mode-skill/issues)
- - Pull requests: Welcome
- - Contact: See parent repository
- ---
- ## License
- MIT License - see LICENSE file for details
- ---
- ## Credits
- 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:
- - Both use Patchright for browser automation (MCP uses TypeScript, Skill uses Python)
- - Skill version runs directly in Claude Code without MCP protocol
- - Optimized for Claude Code's skill architecture
- If you need:
- - **Multi-agent support** (Cursor, Cline, etc.) → Use the [MCP Server](https://github.com/PleasePrompto/google-ai-mode-mcp)
- - **Claude Code only** → Use this skill
- - **npm distribution** → Use the [MCP Server](https://github.com/PleasePrompto/google-ai-mode-mcp)
- - **Git clone simplicity** → Use this skill
- ---
- ## The Bottom Line
- **Without this skill**: Claude searches Google → Gets links → Reads 5-10 pages → Thousands of tokens → Potential hallucinations
- **With this skill**: Claude queries Google AI Mode → Gets one synthesized answer with citations → Minimal tokens → Grounded results
- Stop burning tokens on web research. Start getting accurate, cited answers directly in Claude Code.
- ```bash
- # Get started in 30 seconds
- cd ~/.claude/skills
- git clone https://github.com/PleasePrompto/google-ai-mode-skill google-ai-mode
- # Open Claude Code: "What are my skills?"
- ```
- ---
- <div align="center">
- Built as a Claude Code Skill adaptation of the [Google AI Mode MCP Server](https://github.com/PleasePrompto/google-ai-mode-mcp)
- For free, token-efficient web research directly in Claude Code
- </div>
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.