Building a browser extension with AI help is now normal. What's less obvious is which kind of AI tool fits which kind of extension. A chat assistant, an AI code editor and an AI userscript builder all "write code", but they see different things, produce different artifacts, and fail in different ways.
This roundup groups the tools into three categories, says what each is good at and where it struggles, and ends with an honest guide to picking one. Product descriptions come from each product's own pages, read in October 2026. Products change quickly, so check their sites before you decide. We make one of the tools mentioned, ScriptPanda, and we've tried to describe it as plainly as the others.
What makes extensions hard for AI
Two things make extensions different from ordinary web apps.
The platform has strict rules. Manifest V3 decides what goes in manifest.json, which permissions trigger install warnings, how the background service worker behaves, and that an extension can't run code it downloads. A model trained on years of Manifest V2 examples will happily write background.page or blocking webRequest, which no longer work in Chrome.
The real work is often on someone else's page. A content script that adds a button to a site has to find the right element in markup the developer doesn't control. That markup changes, often uses generated class names, and is frequently drawn after load by JavaScript. An AI that can't see the page has to guess.
Keep those two problems in mind; each category below handles them differently.
Category 1: Chat assistants
ChatGPT, Claude and Gemini are general assistants you talk to in a browser tab or app.
Good at:
- explaining extension concepts, from service workers to message passing;
- drafting a manifest, a popup or a service worker from a description;
- reviewing code you paste in and spotting bugs;
- converting a Manifest V2 extension to Manifest V3, if you tell them that's the goal.
Not so good at:
- anything that depends on a specific page's structure. They haven't seen it, so selectors are guesses, and a guessed selector fails silently;
- multi-file projects, unless you paste in every file each time;
- keeping current with Chrome changes, unless you point them at the current documentation.
Tip: paste the relevant HTML from DevTools into the chat, and say "Manifest V3" explicitly. Then check every @match or matches pattern with a tool like our free @match pattern tester, because a wrong pattern means the code never runs.
Category 2: AI code editors and coding agents
This category includes editors and agents that work inside your project, such as Cursor and GitHub Copilot.
As of October 2026, Cursor describes itself as a coding agent "for building ambitious software", with agents that work autonomously and in parallel, from the editor or the terminal. GitHub Copilot describes code completions and edits in your editor, chat that explains code, an agent mode that makes changes across your workspace, and background agents that take on tasks on their own, across GitHub, IDEs and the command line.
Good at:
- full extension projects: manifest, service worker, content scripts, popup, build tooling and tests, all kept consistent with each other;
- refactors such as moving to TypeScript, or from Manifest V2 to V3, across many files;
- running your build and tests and fixing what breaks.
Not so good at:
- the content script's page knowledge. Like chat assistants, they work from your repository, not from the live site, so selectors still need checking against the real page;
- getting you started if you've never set up an extension project, although they'll scaffold one if asked.
Tip: keep a saved copy of the target page's HTML in your repository, or a description of its structure, and point the agent at it. Tests that run your content script against that saved HTML catch selector drift early.
Category 3: AI userscript builders
These tools work from inside the browser, on the page you want to change, and produce a userscript rather than a packaged extension. They're the newest category.
ScriptPanda is the one we build. It's a Chrome extension with a side panel: you open it on a site, describe the tool in plain English, and it sends your request, the page's address and a trimmed outline of the page's structure to write a userscript, which it installs and runs on the page. If the site changes and the tool breaks, you ask it to fix the tool. You can open any tool's code in an editor. It doesn't run existing Tampermonkey scripts, and it builds one tool per page rather than whole extensions with service workers. Plans are paid and listed on ScriptPanda, the AI userscript builder's own site.
Robomonkey describes itself, on its site and its Chrome Web Store listing as of October 2026, as an AI builder for extensions, userscripts, automations and web scraping. It works from a side panel aware of the page you're on, lets you ask for changes at any time, lists data extraction to CSV, ZIP, TXT and JSON, form fillers and UI changes, and says it works with most Tampermonkey and Greasemonkey userscripts.
Good at:
- changes to a specific site: buttons, exports, clean-ups, small automations;
- finding the right elements, because they read the page before writing;
- people who don't want to set up a project at all.
Not so good at:
- full extensions with background logic, browser-wide features or their own toolbar interface;
- anything you plan to publish on the Chrome Web Store as a product. You'd take the generated code as a prototype and build the extension around it.
Which to pick
You want to change one site you use. Start with an AI userscript builder. It sees the page, which is the hard part, and you'll have a working tool in minutes. If you'd rather write it yourself, our userscript header generator and CSS selector tester cover the fiddly bits.
You want to understand how extensions work, or draft one file. A chat assistant is the quickest teacher. Ask for Manifest V3 by name and paste in real HTML when selectors matter.
You're building an extension to publish. Use an AI code editor or coding agent for the project, because it keeps many files consistent and can run your build. Prototype the page-specific part first, in a userscript, so you know it works before you build the package around it. We explain that approach in Prototype your Chrome extension idea as a userscript first.
You're not sure whether you need an extension at all. Read Userscripts vs Chrome extensions. Many ideas turn out to be a userscript.
A note on checking AI output
Whatever you use, a few checks catch most AI mistakes in extension code:
- Manifest version. Make sure it says
"manifest_version": 3and usesbackground.service_worker. - Permissions. Remove any the code doesn't need. Each one can add to the install warning.
- Match patterns. Test every pattern against real URLs.
- Selectors. Test them against the real page, after it has finished loading.
AI has made the first draft cheap. The checks are what turn it into something you can ship.