Last week I was reading a 9,000-word policy document for a client project. Dense, jargon-heavy, the kind of thing where you get to page six and realize you've retained nothing from page two. I opened the Claude Chrome extension, highlighted the whole thing, and asked for a structured breakdown of the obligations, deadlines, and ambiguities. Thirty seconds later I had something I could actually work with.
That's the extension doing what it's good at. The problem is that most writing about it describes something else entirely — elaborate automation pipelines, multi-tab orchestration engines, programmatic workflows that don't exist. I've seen blog posts with hundreds of lines of fictional API code for methods the extension has never exposed. claude.createWorkflow(). claude.createMonitor(). claude.findDeals(). None of these are real. The extension doesn't have a JavaScript API. It's a sidebar that can see your page and talk to Claude. That's it.
And that's actually enough for a lot of things. But you have to know which things.
What it actually does
The Claude Chrome extension puts the model in your browser context. It can read the page you're on — the text, the structure, the layout. You can ask it questions about what you're looking at, and it responds with awareness of the content in front of you. This sounds simple because it is simple. The interesting part is what becomes possible when a model stops being a blank chatbot and starts being a thing that sees what you see.
I use it for four things consistently.
Reading long pages. This is the boring one, and it's the most useful. Research papers, documentation, legal text, long-form articles where I need the structure more than the prose. The extension is good at pulling out the actual claims from the surrounding filler. It's not summarizing in the reductive sense — it's reorganizing information so I can navigate it. I use this almost daily.
Extracting structured information. Product comparison pages, job listings, competitor feature tables — anything where the information I need is scattered across a page in inconsistent formatting. I ask Claude to pull it into a clean list or table. This works well on pages with actual content in the DOM. It breaks on pages where everything loads dynamically or hides behind interactions.
Helping with forms. Not in the "autonomous form-filling agent" sense that some people describe. More like: I'm on a long application form, I have the relevant information in another tab, and I ask Claude to help me figure out what goes where. It's a thinking partner for bureaucracy. It can read the form labels, understand the context, and suggest what each field is asking for when the labels are ambiguous. That's useful. It's not automating anything — it's helping me understand what I'm looking at.
Research across multiple sources. This is where it gets interesting, but also where the limitations show up. I'll have three or four tabs open on the same topic — different takes, different data — and I use Claude to help synthesize across them. The catch is that the extension works with the current tab. It doesn't have some magical multi-tab awareness. I have to bring the context to it. Open a tab, ask a question, switch to the next tab, ask a related question. It maintains conversation context within a session, so the synthesis happens through dialogue, not automation.
What it doesn't do well
This is the part most posts skip.
Complex multi-tab automation doesn't work. There's no workflow engine. You can't tell it to "open five tabs, extract data from each, and compile a report." That's a fantasy version of the extension that doesn't exist. You work tab by tab, conversationally. Which is fine — but if someone told you it orchestrates research across dozens of sources autonomously, they were making things up.
Dynamic single-page apps are a problem. If the content you care about loads after JavaScript execution, lives behind click-to-expand sections, or gets rendered client-side from API calls — the extension often can't see it. It reads the DOM as it exists when you invoke it. Pages that are mostly a JavaScript shell with data piped in later are partially or fully opaque. This includes a lot of modern web apps.
No persistent memory. Every session starts from zero. The extension doesn't remember what you were working on yesterday, doesn't build up a knowledge base over time, doesn't learn your preferences across sessions. This means you can't build cumulative workflows. Each time you open it, you're re-establishing context. For one-off tasks this doesn't matter. For anything you do repeatedly, it's friction.
Cross-device doesn't exist. Your sessions don't sync between machines. Workflows — to the extent that "workflow" means "a conversation I had with the extension" — are tied to the browser instance where they happened.
Team collaboration is absent. You can't share a session, can't hand off a research thread to a colleague, can't build shared templates. It's a single-player tool.
The keyboard shortcuts are real
These actually work and are worth memorizing:
- Cmd/Ctrl + Shift + K — Open Claude on current page
- Cmd/Ctrl + Shift + A — Analyze current page
- Cmd/Ctrl + Shift + S — Summarize current page
- Cmd/Ctrl + Shift + E — Extract structured data
Cmd+Shift+A is the one I use most. Land on a page, hit the shortcut, get an instant read on what I'm looking at. It's small, but it changes how you browse. You stop skimming and start asking.
The interesting question underneath
Here's what I think is actually worth paying attention to, beyond the feature list.
When a model has browser context, the interaction changes. A regular Claude conversation is abstract — you describe what you're working with, the model imagines it, you go back and forth closing the gap between what you mean and what it understands. With the extension, that gap shrinks significantly. The model can see the same page you're seeing. You can point at things instead of describing them. "What does this section mean?" instead of "I'm reading a document that has a section about X, and it says Y, and I'm wondering Z."
This is a different interaction model. It's closer to working with someone who's looking over your shoulder than someone you're talking to on the phone. And the implications go beyond the extension itself — it's the same shift that happens with computer use features, with any AI that has direct access to your context instead of requiring you to manually bridge the gap.
The limitation is that current browser extensions are still shallow integrations. The model can read the page, but it can't truly navigate. It can understand the form, but it can't reliably fill it autonomously. It sees the DOM snapshot, not the living application. The gap between "AI that sees your browser" and "AI that uses your browser" is large, and we're still firmly on the "sees" side of it.
That gap will close. The question is what changes when it does — when browser AI moves from reading comprehension to actual agency. Right now, the extension is a very good reading companion and a mediocre automation tool. The reading companion part is already useful enough to change how I work with web content. The automation part is where the marketing runs ahead of the reality.
Where this goes
The honest framing: Claude in your browser is a context-aware reading assistant that occasionally helps you do things. It's not an automation platform. It's not a workflow engine. It's not going to orchestrate your research while you get coffee.
But the "context-aware" part matters more than it sounds. Having a model that can see what you're looking at — that understands the page, the structure, the specific content in front of you — that's a meaningful step from the chatbot-in-a-box interaction pattern. The best tools don't do more things. They reduce the distance between your intent and the action. Right now, the extension does that for a narrow set of tasks: reading, extracting, understanding dense web content.
Start with Cmd+Shift+A on a page you're already reading. If it saves you time, keep using it. If it doesn't, the tool isn't for that task. Build from what works, not from what someone else's fictional code block promised it could do.