Browser AI and the return of the bookmarklet

As Abraham Lincoln famously tweeted from his BlackBerry:

The fastest way to overcome caution is to make the risky button in Chrome feel a little magical.

The setup

A good friend of mine, who is responsible for a meaningful percentage of my AI-related distractions, has subtly challenged me to find uses for these new computer-use AI tools that are not just coding or scripting by another name.

This post is, unfortunately, not that.

In trying to find a genuinely non-coding example, I instead found another coding-adjacent one. So the search continues, but at least the failure was mildly useful and just nostalgic enough to be worth writing down.

Welcome back to the late 90s and early 2000s: the browser was already the center of the universe, but it was also a much more improvisational place. You were forever poking at pages, saving snippets, and making the machine do a little more than the site designers originally intended.

The bookmarklet brain

A bookmarklet, in the old and slightly chaotic sense, is just a bookmark where the URL is not a normal web address. Instead of pointing at a site, it starts with javascript: and contains a tiny script that runs against the page you already have open.

That is the whole trick.

You save it like a bookmark, click it like a bookmark, and the browser executes the script in the current page. No extension, no giant setup, no turning a five-minute annoyance into an afternoon project. You just patch the page in front of you and move on.

For example, this is how you would remove my beloved darkmode in a single click:

1
javascript: (function () {
2
  const style = document.createElement("style");
3
  style.innerHTML =
4
    "* { background: #f4f1dc !important; color: #000000 !important; border-color: #ddd !important; }";
5
  document.head.appendChild(style);
6
})();

That is not especially useful. It is just a simple example that shows how the thing works in the clearest (and most blinding) way possible.

That was always the charm.

And that same feeling is back now, except with one very important difference: you do not need to be the sort of person who can de-minify JavaScript in their head or summon it by speaking fluent browser goblin.

You also do not technically have to turn it into a bookmarklet at all. You can just self-XSS your way straight into the console like a menace with a clipboard, which is extremely powerful and also exactly where the “please be careful pasting scripts from some AI” warning lives.

The browser layer

AI has now worked its way directly into the browser, which means this is no longer just a chatbot sitting off to the side hoping you ask it to summarize an article. Brave has Leo, Edge has Copilot, Chrome has Gemini in Chrome, and Opera has Aria built right into the browsing experience. They all approach it a little differently, but the idea is roughly the same: the browser is not just there to show you the page anymore, it is increasingly there to help you do something with it.

That context is the whole point. The tool is not guessing from a vague prompt in a vacuum. It can see the page you are on, the table you are fighting with, the labels on the buttons, the weirdly structured form, and sometimes even the other tabs you are trying to keep straight. That means the suggestion is not just “write some JavaScript”; it can be “write this JavaScript for this exact mess.”

That is a very different thing.

It also fits a pattern I keep running into lately: I increasingly value tools that let me stay inside the work instead of bouncing between five different surfaces to get one thing done. That was a big part of what I was getting at in Why I switched to OpenCode Web UI. Different category, same underlying appeal. Keeping the workflow in one place matters more than it sounds like it should.

The obvious stuff

A lot of that is the obvious stuff, and honestly, the obvious stuff is already pretty good. Summarize this page. Explain this chart. Pull out the dates. Tell me what this vendor page is actually trying to say beneath three layers of marketing language and visual noise. That alone is useful.

But the thing that caught my attention is a little more specific, and a lot more nostalgic.

These tools are starting to make the old bookmarklet brain useful again.

The browser AI version of this is not really competing with mature extensions that already do one job well. It is better for the awkward little gaps. The one-off fixes. The things you only need today, or once a month, or just often enough to be irritated by them.

And because it can see the page you are actively working on, it can suggest something that is much closer to the actual problem instead of a generic snippet from the internet graveyard. If the table is cramped, it can target that table. If the page has a nonsense filter, it can focus on that filter. If the layout is fighting you, the code it gives you can respond to the thing you are actually looking at instead of some imaginary average website. You are not stopping to describe the page to some separate app and then translate the answer back into the browser. The page, the problem, and the fix all stay in the same place.

That is where the usefulness jumps from “cute” to “genuinely handy.”

So in my ongoing and completely serious effort to prove to my friend that these tools can be useful outside of coding, I have instead rediscovered a very solid use for having AI write tiny disposable bits of browser code for me.

I realize this is not exactly the victory lap I was aiming for.

Still, it is a useful detour.

If I am on some miserable internal admin page with fifty checkboxes and no “select all,” I can ask for a snippet that checks only the visible ones and skips the disabled rows. If I am staring at a long table with headers that disappear the second I scroll, I can ask for a quick fix that makes the header sticky. If a page is full of IDs, totals, statuses, or dates arranged in a way that suggests the designer and I are not currently aligned, I can ask for a script that pulls the useful bits into something clean and copyable.

Or, a little more pleasantly, I can ask for a quick color picker that lets me sample anything on the page and copy the hex value without installing a Chrome extension or bouncing out to another app:

1
javascript: (async () => {
2
  const existing = document.getElementById("__color_picker_result");
3
  if (existing) existing.remove();
4
  if (!("EyeDropper" in window)) {
5
    alert("This browser does not support the EyeDropper API.");
6
    return;
7
  }
8
  try {
9
    const result = await new EyeDropper().open();
10
    const hex = result.sRGBHex;
11
    try {
12
      await navigator.clipboard.writeText(hex);
13
    } catch {}
14
    const popup = document.createElement("div");
15
    popup.id = "__color_picker_result";
16
    popup.innerHTML = `<div style="width:18px;height:18px;border-radius:4px;background:${hex};border:1px solid rgba(255,255,255,0.25);"></div><div><div style="font:600 13px system-ui,sans-serif;">${hex}</div><div style="font:12px system-ui,sans-serif;opacity:0.75;">Copied to clipboard</div></div>`;
17
    Object.assign(popup.style, {
18
      position: "fixed",
19
      top: "16px",
20
      right: "16px",
21
      zIndex: "2147483647",
22
      display: "flex",
23
      alignItems: "center",
24
      gap: "10px",
25
      padding: "10px 12px",
26
      background: "rgba(17,24,39,0.96)",
27
      color: "#fff",
28
      borderRadius: "10px",
29
      boxShadow: "0 10px 30px rgba(0,0,0,0.35)",
30
      cursor: "pointer",
31
    });
32
    popup.addEventListener("click", () => popup.remove());
33
    document.body.appendChild(popup);
34
    setTimeout(() => {
35
      popup.remove();
36
    }, 5000);
37
  } catch (error) {
38
    if (error && error.name !== "AbortError") {
39
      alert("Color picker failed.");
40
    }
41
  }
42
})();

That is the kind of one-off fix I mean. Small, specific, immediately useful, and not worth turning into a whole project.

Not because it is magical, exactly, and not because it replaces proper tools, but because the web is still full of small annoyances that are too common to ignore and too minor to justify building a real solution around. The browser AI can look at the page, understand the specific annoyance, and hand you a fix that is tuned to the thing in front of you. Just as importantly, it can do that without forcing you to bounce out to another app, explain the problem from scratch, and then carry the answer back in by hand. That is the sweet spot for this kind of thing.

And if it turns out to be something you need more than once, that is where the bookmarklet part comes back.

Ask for the throwaway console snippet first. If it earns a second use, turn it into a bookmarklet and save it like it is 2003 and you have just discovered a new and slightly irresponsible superpower.

That may not be the non-coding victory I was supposed to come back with, but it is useful, it is fun, and it scratches a very specific part of my brain.