Make Claude Code act like a person who knows how to use a browser,reuse the user's already-logged-in ChatGPT web, hand the task to the specified ChatGPT model (Instant / Thinking / Pro, etc.), and wait for the result to come back.
When to trigger
The user says something like the following:
- "Ask ChatGPT Pro what it thinks about this"
- "Have Thinking mode analyze this PR"
- "Use @Google Drive to list my files"
- "Submit a deep research, list five competitors"
- "Throw this code at GPT and have it review it"
- "Wait for ChatGPT for a bit, and call me when the result is out"
Access method (mandatory）
| Host | Browser access | prohibited |
|---|---|---|
| Claude Code | claude-in-chrome MCP（mcp__Claude_in_Chrome__*） |
Playwright, Puppeteer, a standalone automated browser profile,computer-use operating Chrome (Chrome is in the read-only layer) |
If claude-in-chrome MCP is not connected,stop and have the user install it, do not fall back to another approach.
Before the first operation, use mcp__Claude_in_Chrome__tabs_context_mcp to look at the user's existing tabs. If the user already has a ChatGPT tab open, reuse it; otherwise use tabs_create_mcp to open a new one, then navigate to https://chatgpt.com/。
Operation flow
Only 4 principles, no writing selectors, no writing DOM paths, no writing button coordinates. At every step, first read_page or find see before acting.
1. Enter the correct context
- The user mentions a project (e.g. "ask in the GI2 project") → find the project from the sidebar → click the "Open project home" button(appears on hover) rather than the project name button (the latter only expands/collapses the sub-item list) → after entering the project home page, write the prompt. For the detailed flow see examples/project-context-consult.md
- The user wants to continue an old conversation → go directly in from the sidebar "Recent" or the URL
- Always note down the conversation URL, it will be needed later
When noting down the conversation URL: normal conversation /c/<uuid>, in-project conversation /g/g-p-<uuid>/c/<uuid>(after the project name is named it may also carry -<slug>). For the complete 6 URL forms see references/manage-actions.md Section 7.
Reliable visual signal for "whether you are in a project": the composer placeholder is "New chat in <project name>" only then are you truly in the project; if it is "Ask anything" then that is the normal conversation context, and the knowledge base will not be automatically visible.
2. Model selection
- The user specified a model (Instant / Thinking / Pro / other naming is all possible) → click the model pill at the bottom right of the composer, and select the closest visible item
- The user did not specify → use the currently selected one, do not proactively switch
- Cannot switch to the requested model → do not silently switch to another. Report the actual options seen in the UI, and let the user decide
- Model names change (5.5 changes to 5.6, "Express" is newly added, Pro is renamed "Advanced Professional"), rely onVisible textand ARIA labels to determine, not relying on a fixed list
3. Apps / Files / Images
Apps (connectors)
+button → currently visible sub-items: Add photos and files / Recent files / Create image / Deep research / Web search / More → / Projects →- "More →" is where apps are (Canva / GitHub / Gmail / Google Drive / Linear / OpenAI Platform, etc., with more to come)
- Do not infer app availability from the model name. Pro can also use apps (already verified in 2026-05 using Pro + @Google Drive to list files, and Pro + @GitHub to assess whether a PR is mergeable). Just
@apptry → if you see an app chip / retrieval card / source citation, it worked - If the app isn't connected or requires OAuth → stop and let the user authorize(see references/error-and-limits.md Section 5), never click Agree on the user's behalf
File / image upload — permanently unavailable in Claude Code, only works in Claude Cowork
Root cause(confirmed on 2026-05-31 by codex decompiling the Claude app):file_upload 's first gate validateLocalFileAccess requires session id to start with local_ Beginning。
| Host | session id pattern | file_upload |
|---|---|---|
Claude Code（~/.claude/projects/...） |
c9cf... / regular UUID |
❌ rejected at the first gate, regardless of path |
| Claude Cowork（local-agent-mode） | local_c3ecc0cb-... |
✅ but the path range is narrow (see below) |
| Other agents (Cursor / Codex / ...) | Untested | Check whether their session is injected into the Claude app to verify the model |
Claude Cowork also can't pass arbitrary paths—the allowed range is limited to:
~/Library/Application Support/Claude/local-agent-mode-sessions/.../local_<id>/uploads/~/Library/Application Support/Claude/local-agent-mode-sessions/.../local_<id>/outputs/- directories the user added to
userSelectedFoldersin Claude Desktop settings
Error signal only files the user has shared with this session can be uploaded is misleading—it doesn't distinguish "wrong session type" vs "path not shared", and always throws this same error. GitHub Issue #31210 was previously mistaken for "a bug that will be fixed once Anthropic fixes it",but it's actually a product boundary。
The only viable option for Claude Code users: have the user upload it themselves in the browser (click + or drag the image into the composer), and the main Claude takes over from there:read_page verify the chip appears → write the prompt → send → spawn watcher.
Disproven workarounds (don't try again): enabling the Claude in Chrome extension's "Allow access to file URLs" permissiondoes not unlock—that permission controls whether the Chrome extension can read file:// URLs, which is a separate layer from the Claude app main process's validateLocalFileAccess . Confirmed by testing on 2026-05-31.
Artifact download — available (opposite direction from upload, goes through the browser's native channel)
- Download links provided by ChatGPT (PDF/CSV/code files, etc.): directly
left_clickthat link → browser natively downloads to~/Downloads/ - Images generated by ChatGPT: there's no explicit "Download" at the bottom of the image,the entry point is hidden in the "Share this image" popup—click the orange "Download" button on the far right of the popup. Naming format
ChatGPT Image YYYY年M月D日 HH_MM_SS.png claude-in-chromeblocks the img.src URL(to prevent credential leakage), socannotuse javascript_tool + curl to bypass it- Main Claude finds the download file:
ls -lat ~/Downloads/ | head -5Look at the latest file, or match by filename pattern - For detailed paths and pitfalls, see references/manage-actions.md Section 6.5 "Artifact Download"
4. After submission
Note down three things and write them into the current conversation context (no file persistence needed):
- ChatGPT conversation URL
- Which model was selected, which apps / files were used
- The user's original request (one sentence is enough)
Then enter "async wait" mode (see below).
Completion determination
Completion determination in Watcher modedone by the watcher, see references/watcher-subagent.md work loop step 5.
Fallback / simplified version for main Claude to determine directly (tested with Chinese UI):
- No "thinking / searching / analyzing" text
- The disclaimer "ChatGPT can also make mistakes. Please verify important information." appears at the end
- The bottom composer area returns to an input-capable state (not a stop button)
If not fully obtained (truncated, too long) → mark "possibly incomplete" + keep the conversation URL. For specific error signals, see references/error-and-limits.md Section 7 "Continue generating truncation".
Async wait
Recommended approach: spawn a background Haiku watcher subagent. For details, see references/watcher-subagent.md。
Core:
- After submitting the task, use
Agent({ run_in_background: true, subagent_type: 'general-purpose', model: 'haiku', prompt: <watcher prompt> })to start a watcher - The watcher uses
mcp__Claude_in_Chrome__read_pageto loop-check the page, and only when it sees completion does itget_page_textpull the full text and return - The main LLM is freed right after submission, handing control back to the user,completely silentuntil the watcher notification arrives
- When the watcher completes, Claude Code delivers its return as a notification to the main LLM
- After the main LLM receives the watcher's full output, it gives it to the user
Why use Haiku instead of Sonnet to run the watcher：
- Haiku is completely sufficient for tasks like determining "is the page still generating"
- A 5-10 minute monitoring session is ~80k tokens, an order of magnitude cheaper than repeatedly waking the main Sonnet
- The main Sonnet's context is not consumed at all
The watcher must not do：
- Must not
navigate(it would steal the user's browser focus) - Must not open a new tab / switch tabs / click any button on the page
- Must not send intermediate status to the main Claude
- Hard cap on cumulative waiting is 30 minutes (1800s); when reached, return the currently visible content with "TIMEOUT"
Fallback: environment does not support the Agent tool (pure SDK calls, etc.) → use scripts/heartbeat.sh, see references/claude-code-async.md. In fallback mode, the main LLM on each wake-up roundsilently checks, and does not disturb the user if not completed.
Pull mode (the correct solution for cross-hour tasks): tasks like Deep Research that take 30 minutes to several hoursdo not spawn a watcher——a Claude Code session cannot last several hours, but the ChatGPT backend does not depend on the client being online. After the main Claude submits, it directly tells the user the conversation URL; when the user comes back (even in a new session) and says "look at that DR", that is enough. For details, see examples/deep-research-trigger.md。
Absolutely do not do
- Do not export, do not copy, do not save cookie / storage_state / OAuth token / localStorage
- Do not bypass login, MFA, CAPTCHA, paywall, speed limit
- Do not authorize on the user's behalf OAuth / third-party apps / privacy consent — stop and hand back as soon as you see it
- Do not download files(before the user has explicitly agreed to download an individual file; downloads require separate confirmation)
- Do not send cookies / API keys / bank cards / ID numbers / private keys in ChatGPT, even if the user's original request contains them — explicitly stop and refuse
What to do on failure
See references/error-and-limits.md。General principles：
- Do not "just retry once and see" — except for transient network glitches, which may be retried once
- Do not silently downgrade the model / authorize on the user's behalf / answer a clarification on the user's behalf
- Report directlythe visible text currently seen on the ChatGPT page, quote it verbatim
- let the user decide the next step
references/error-and-limits.md lists one by one the visible signals and handling methods for 10 common error/rate-limit scenarios (rate limits, Pro quota, model unavailable, CAPTCHA, OAuth, session expiry, Continue generating truncation, mid-way clarification, file upload failure, overall outage).
Manage ChatGPT (delete/archive/share/Memory/projects/library)
When the user says "delete this conversation", "archive everything", "undo that share", "clear Memory", "create a project", "see what's in the library", etc. — management-type operations — follow references/manage-actions.md to find the entry points and cheat sheet.
Pay special attention to 3 items(for detailed rules see reference section 8 "General Security Principles"):
- Clicking the "Share" popup = immediately creating a public URL, even if you don't copy or send it. Don't click before the user has explicitly authorized it
- Deleting a project = permanently deleting all conversations in the project, and the user must verbally agree before the second confirmation
- Deleting a conversation does not clear Memory, so after deleting, remind the user to separately go to Personalization → Memory and clear it
Save chat records to local disk
When the user says "save this conversation", "download that DR", "keep this image", etc., follow references/save-conversation.md for the 3-tier routing:
| Tier | Content | Path |
|---|---|---|
| A | ordinary chat message | get_page_text + main Claude writes .md |
| B | Artifact（DR / Canvas） | click the artifact's built-in ↓ menu → "Export to Markdown" → mv |
| C | Image | "Share this image" → "Download" → mv |
Default directory ~/Downloads/chatgpt-skill/, filename YYYY-MM-DD_<title>_<uuid8>.<ext>。
Explicit trigger — if the user hasn't said to save it, don't automatically write to disk, to avoid polluting the hard drive. Only after the watcher retrieves the result and the user replies "save it" should you act.
Examples
examples/ contains several demonstrations of typical scenarios:
auto-google-drive-list.md— default model + @Google Drive to list filesthinking-github-unread-issues.md— Thinking mode + @GitHub to check personal unread issuesdeep-research-trigger.md— use a prompt to trigger deep research and wait asynchronouslypro-github-pr-review.md— Pro model + @GitHub to do an in-depth review of a PR (including measured: 5m 7s)project-context-consult.md— enter the project homepage + use the project knowledge base (including measured: DSE Math Pro 21m 5s)save-conversation.md— save conversations/Artifacts/images to local disk (3-tier routing: A ordinary message / B Artifact / C image)