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
When 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 comes out"
Access method (mandatory）
| Host | browser access | prohibited |
|---|---|---|
| Claude Code | claude-in-chrome MCP（mcp__Claude_in_Chrome__*） |
Playwright, Puppeteer, standalone automated browser profile,computer-use operating Chrome (Chrome is at 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 (for example "ask in the GI2 project") → find the project from the sidebar → click the "Open project home page" 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 → enter directly from the sidebar "Recent" or the URL
- Always note down the conversation URL, it will be used 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 it is a normal conversation context, and the knowledge base will not automatically be visible.
2. Model selection
- The user specified a model (Instant / Thinking / Pro / other naming is all possible) → first find the model selector visible on the current page; it may be near the composer, or it may be in the top banner. After clicking it open, choose the closest visible item
- The user did not specify → use the currently selected one, do not proactively switch
- If you cannot switch to the requested model → do not silently switch to another one. Report the actual options seen on the UI and let the user decide
- Model names and the visible list will change (different accounts may see only ChatGPT + upgrade entry, or may see Thinking / Pro, etc.); rely onvisible textand ARIA labels to judge, not on a fixed list
3. Apps / Files / Images
Apps (connectors)
+/添加文件等menu usually includes: Add photos and files / Recent files / Create image / Think / Deep research / Web search / More / Projects. The exact wording will drift with account, language, and UI, so check the current page before clicking- There are two Apps entry points:
+in the menu, the更多submenu, or type@in the composer and then select a suggestion. Current testing shows@suggestions can directly show深度研究as well as apps such as Canva / GitHub / Linear / OpenAI Platform - 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 can be merged). Directly
@apptry → if you see an app chip / retrieval card / source citation, it succeeded - Deep Research may also activate as a
@深度研究suggestion. After selecting it, the reliable signal is that the composer placeholder changes to获取详细报告, and深度研究chip /应用button /推荐、报告and other DR-specific controls appear; do not treat the+menu as the only entry point - If the app is not connected or requires OAuth → stop and have the user authorize(see references/error-and-limits.md section 5), and 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 must start with local_ Beginning。
| Host | session id pattern | file_upload |
|---|---|---|
Claude Code（~/.claude/projects/...） |
c9cf... / ordinary UUID |
❌ rejected at the first gate, regardless of path |
| Claude Cowork（local-agent-mode） | local_c3ecc0cb-... |
✅ but the path scope 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 cannot pass arbitrary paths—the allowed scope 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 does not distinguish "wrong session type" vs "path not shared" and uniformly throws this error. GitHub Issue #31210 was previously mistaken for a "bug that will be fixed once Anthropic fixes it,"but it is actually a product boundary。
The only viable option for Claude Code users: have the user upload in the browser themselves (click + or drag an 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 workaround (do not try again): enabling the Claude in Chrome extension's "Allow access to file URLs" permissiondoes not unlock it—that permission controls whether the Chrome extension can read file:// URLs, and 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 given by ChatGPT (PDF/CSV/code files, etc.): directly
left_clickthat link → browser natively downloads to~/Downloads/ - Images generated by ChatGPT: there is 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 at 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), soyou cannotbypass it with javascript_tool + curl- Main Claude finding downloaded files:
ls -lat ~/Downloads/ | head -5check the newest 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 chosen, 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 modeis done by the watcher, see references/watcher-subagent.md 's work loop step 5 for details.
Fallback / simplified version for direct determination by main Claude (tested with Chinese UI):
- No "Thinking / Searching / Analyzing" wording
- 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 incomplete (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
Main recommended approach: spawn a background Haiku watcher subagent. See references/watcher-subagent.md。
for details. 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 as soon as it submits, 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 gets the watcher's complete output, it gives it to the user
Why use Haiku instead of Sonnet to run the watcher：
- Haiku is entirely sufficient for a task like judging "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
What the Watcher must not do：
- Must not
navigate(it would steal the user's browser focus) - Must not open new tabs / switch tabs / click any button on the page
- Must not send intermediate states to main Claude
- Hard cap on cumulative waiting is 30 minutes (1800s); when reached, return the currently visible content with "TIMEOUT"
Fallback: the 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 roundSilent check, do not disturb the user if not completed.
Pull mode (the correct solution for cross-hour tasks): For 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, directly tell the user the conversation URL; when the user comes back (even in a new session) and says "look at that DR", that is enough. See examples/deep-research-trigger.md。
Absolutely do not
- Do not export, do not copy, do not save cookie / storage_state / OAuth token / localStorage
- Do not bypass login, MFA, CAPTCHA, paywalls, speed limit
- Do not authorize on the user's behalf OAuth / third-party app / privacy consent; if you see it, stop and hand it back
- Do not download files(before the user has explicitly agreed to a single file download; 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—stop explicitly and refuse
What to do on failure
See details in references/error-and-limits.md。General principles：
- Do not "just retry once and see"—except for transient network jitter, which may be retried once
- Do not silently downgrade the model / authorize on the user's behalf / answer 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 expiration, Continue generating truncation, mid-task follow-up questions, file upload failure, overall failure).
Manage ChatGPT (delete/archive/share/Memory/projects/library)
When the user says "delete this conversation", "archive everything", "revoke that share", "clear Memory", "create a project", "see what is in the library", or other management 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 Rules"):
- Clicking the "Share" popup = immediately creating a public URL, even if you do not copy or send it. Do not click before the user has explicitly authorized it
- Deleting a project = permanently deleting all conversations in the project, and before the second confirmation, the user must verbally agree
- Deleting a conversation does not clear Memory, and after deletion remind the user to separately go to Personalization → Memory to 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 3 tiers of 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 did not say to save it, do not 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/ Here are several typical scenario demonstrations:
auto-google-drive-list.md— Default model + @Google Drive list filesthinking-github-unread-issues.md— Thinking mode + @GitHub check personal unread issuesdeep-research-trigger.md— Use a prompt to trigger deep research and wait asynchronouslypro-github-pr-review.md— Pro model + @GitHub do an in-depth review of a PR (including actual test: 5m 7s)project-context-consult.md— Enter the project homepage + use the project knowledge base (including actual test: DSE Math Pro 21m 5s)save-conversation.md— Save conversations/Artifacts/images to local disk (3-tier routing: A regular message / B Artifact / C image)