Operating web pages: 6 traditional tools vs AI…

Every tool that reads, rewrites or automates a web page operates at a specific layer of the browsing stack, and that layer — not the feature list — determines what the tool can and cannot do. A bookmarklet lives inside one page and dies on refresh. A proxy sits outside the browser entirely and rewrites traffic before the browser ever sees it. And the newest arrivals, AI assistants like Gemini built directly into Chrome, occupy a layer that did not exist three years ago: they operate on the meaning of a page rather than its markup. This guide maps the traditional toolbox from the page upward, then examines where browser AI genuinely changes the picture.

1. Bookmarklets: one click, one page

A bookmarklet is a snippet of JavaScript stored as a bookmark, built on the javascript: URL scheme and usually URL-encoded. It does nothing until you click it, at which point it runs once in the context of the current page. Within that page it can do a lot — extract all links, strip clutter for printing, enlarge fonts, generate a QR code for the current URL. But its limits are hard: it cannot run automatically, cannot persist across navigation, and the browser's same-origin policy restricts how it can interact with resources from other origins.

Its virtues are the mirror image of those limits. There is nothing to install, it works on every desktop browser and most mobile ones, it consumes zero memory while idle, and the entire "codebase" is one line you can audit yourself. For a quick, manual, single-page action, nothing beats it.

2. Userscripts: automation for pages you visit anyway

Userscripts — run through a manager extension such as Tampermonkey or Violentmonkey — are JavaScript files with a metadata header that declares which URLs they match. The Violentmonkey metadata-block reference documents controls such as URL matching and run timing. When you visit a matching page, the script runs automatically, either before the page's own scripts (document-start) or after load. Manager-provided APIs like GM_xmlhttpRequest lift the same-origin restriction, so a userscript can fetch prices from a competitor site or check a video's sponsor segments against a community database.

This is the sweet spot for modifying sites you use daily: skipping intros, restoring keyboard shortcuts a redesign removed, auto-expanding truncated comment threads. The ecosystem is enormous — Greasy Fork hosts tens of thousands of ready-made scripts — and writing your own requires only ordinary front-end JavaScript. The dependency on a host extension is the main weakness, along with fragility: scripts key off a site's DOM structure, and a site redesign silently breaks them.

3. Extensions: full applications inside the browser

A browser extension is a sandboxed application with its own background process, storage, and privileged APIs. It can rewrite any page via content scripts, but it can also do what no page-level tool can: intercept and redirect network requests, manage tabs and downloads, read and write cookies across sites, and present persistent UI in the toolbar. Password managers, ad blockers, screenshot tools and immersive translators all require this tier.

The cost is complexity and governance. Chrome's Manifest V3 platform documentation explains the move from persistent background pages to service workers and from blocking webRequest behavior toward the safer declarativeNetRequest API. That trade changes how blockers and request-rewriting extensions work. Store review takes time, high-risk permissions invite rejection, and users have learned (correctly) to read permission prompts with suspicion.

4. UserCSS: restyling without risk

Style managers like Stylus inject user-defined CSS into matching pages and nothing else. Because no JavaScript is involved, a UserCSS theme cannot exfiltrate cookies, log keystrokes or phone home — it is the one tool in this list that is safe by construction. What it buys you is purely visual: dark modes for sites that refuse to ship one, hiding engagement-bait modules, fixing unreadable typography. What it cannot do is change behavior in any way. If the task is "make this site look right", start here before reaching for anything heavier.

5. Headless browsers: automation from the outside

Playwright, Puppeteer and Selenium invert the whole model: instead of code running inside your browsing session, an external program (Node.js, Python) drives a real browser instance over a control protocol. Playwright's official browser documentation, for example, covers automation across Chromium, Firefox and WebKit. That program can type, click, scroll, drag, wait for network idle, intercept requests, and save results anywhere — a database, a spreadsheet, a PDF of the rendered page.

This is the layer for jobs, not sessions: scrape a report every night at 2 a.m., fill five hundred forms, run a regression suite across three browser engines. The trade-off is that it is not a daily-browsing tool. Instances are resource-hungry, sophisticated sites deploy bot detection against them, and everything must be scripted in advance.

6. Proxies and network-level tools: above the browser entirely

Debugging proxies — mitmproxy, Whistle, Charles, Fiddler — sit between the browser and the internet as a local man-in-the-middle. The mitmproxy documentation describes the interception, inspection and modification model directly. After you install a trusted local certificate, these tools can decrypt HTTPS and rewrite traffic in transit: inject a script into an HTML response, stub an API to return test data, or map a production JavaScript bundle to a local file you are editing. Because they act before content reaches the browser, they work across browsers and other apps configured to use the proxy.

One rung higher, DNS-level blockers like Pi-hole and AdGuard Home run on a router or home server and refuse to resolve ad and tracker domains for every device on the network — TVs and phone apps included. Pi-hole's official documentation covers this network-wide DNS sinkhole model. These tools cannot modify a page (blocked elements may leave empty gaps), but as a low-maintenance, whole-network filter they are unmatched.

7. Where AI tools enter: Gemini in Chrome

Everything above shares one assumption: you tell the tool exactly what to do, in code or configuration, ahead of time. Browser-integrated AI assistants break that assumption. Google's Gemini in Chrome help page documents how the assistant uses the current tab and up to ten shared tabs to provide page-aware answers. It can summarize a long article, clarify concepts and compare information across selected tabs. Google also documents an agentic direction through Auto browse, which can navigate sites, click buttons and fill forms for multi-step tasks.

The comparison with traditional tools is instructive rather than competitive:

Interface. Traditional tools are programmed; the assistant is instructed. "Find the cheapest of these three tabs and list the trade-offs" is not expressible as a userscript at all — it is not one site, one selector, one rule.
Robustness. A userscript dies when a class name changes; an AI assistant reads the rendered page the way a human does, so redesigns do not break it. The flip side is determinism: a script does the same thing every run, while an assistant's output can vary and must be reviewed.
Scope. The assistant works within your interactive session and Google's product boundaries. It will not run unattended at 2 a.m. (headless browsers keep that job), block trackers for your television (Pi-hole keeps that one), or give you the pixel-exact permanent restyling of UserCSS.
Privacy. Every traditional tool here can be run fully locally. A cloud assistant, by design, sends page content off the machine — the exact property self-hosters use proxies and local scripts to avoid.

Gemini in Chrome is the most prominent example because it ships inside the world's largest browser, but the pattern is general: Copilot occupies the same slot in Edge, agentic browsers like Comet build the whole product around it, and frameworks that pair LLMs with Playwright bring natural-language driving to the headless tier too.

8. Choosing the right layer

Match the tool to the shape of the task. A quick manual action on the current page: bookmarklet. A permanent visual fix for one site: UserCSS. A behavioral tweak to sites you visit daily: userscript. A tool needing background state, toolbar UI or network interception: extension. Unattended, scheduled or bulk automation: headless browser. Rewriting traffic across apps, or defeating anti-tampering checks: debugging proxy. Whole-network ad and tracker blocking: DNS-level filter.

And the AI assistant? Reach for it when the task is about understanding — summarizing, comparing, extracting, deciding — or when it is a one-off, multi-step chore you would never bother scripting. The traditional stack automates what you can specify; browser AI handles what you can only describe. For the foreseeable future the winning setup is both: deterministic tools for the repeated and precise, an assistant for the ambiguous and ad hoc.

Operating web pages: 6 traditional tools vs AI tools like Gemini in Chrome