Some of the most useful tools in our fraud prevention work started as small userscripts, scripts that add functionality to pages we already use. They addressed everyday “papercuts”: opening several links, switching to the right workspace, and repeating the same navigation steps during a review.

Over time, we had a collection of these scripts. Sharing them and keeping them updated became another piece of work. I built a browser extension with AI assistance to bring that process together, and teammates helped me improve it by trying it in their own workflows and sharing feedback.

Where the repeated work was

One example was gathering information from the links in a review ticket. We would open the links individually before reviewing the information and making a decision. I created a script that opened the relevant links with one click.

A colleague tackled a different navigation problem. Sometimes, opening a link in a review tool would take us to the wrong workspace. We would switch workspaces and then open the link again. Their script automated that switching step.

These were small improvements to tasks we repeated regularly. The analyst still needed to go through the information and make the final decision.

Making scripts easier to share

Initially, sharing a userscript meant attaching it to a Slack message. Later, we moved the scripts to GitHub. That gave us a shared place for them, but teammates still needed a way to install new scripts and receive changes.

The extension provides automatic syncing of userscripts from GitHub, including newly uploaded scripts and updates to existing ones. For teammates using it, sharing an improvement can start with updating the script in the shared repository. Update reliability is still part of the remaining work, so I would not describe this as a guarantee that every installation always has the latest version.

Tampermonkey, the userscript manager most of the team used before, remains another option. Teammates can download scripts from GitHub to install there, or configure them to receive updates from their GitHub URLs. Some colleagues have adopted the shared workflow by uploading a script and notifying the team, knowing that people can use either route.

My contribution was building the extension that brings those scripts together. The scripts themselves include work from other colleagues, and their feedback has helped shape the extension too.

Improving the everyday experience

Feedback helped turn broad requests into practical changes. Teammates wanted to see which scripts were enabled and know when something new was available. I added separate views for enabled and disabled scripts, along with indicators for new scripts and updates.

I also added a way to load scripts locally for development and testing before sharing them through the repository. This gives script authors a way to try a change in the extension before making it available to the team.

Another improvement addressed the wait when opening the extension's popup. It now displays the script list from information already available locally while refreshing in the background. Clearer “last checked” timestamps help people see how recently the information was checked. This makes the popup more responsive while keeping the freshness of its information visible.

Building with AI and checking across browsers

I built the extension with AI assistance, an approach often called “vibe coding.” AI helped with development and troubleshooting. The extension itself does not use AI during normal use.

One of the hardest parts was getting it to work as reliably as the userscript manager people were already using.

I use Chrome. Other teammates use Firefox, Vivaldi, and other browsers. What works in my browser does not establish that it works in theirs, so feedback from teammates has been an important part of finding problems.

That is also a limitation of how I have checked the extension so far. I do not have comprehensive verification across every browser. AI can help me work through a reported issue, but I still need evidence from the affected browser to know whether a change has helped.

Troubleshooting from a distance

Setup introduced its own difficulties. Some teammates had trouble completing the connection needed to sync the scripts. There were also reports of the extension disappearing after some time.

These issues were difficult to investigate remotely. I could not always reproduce what a teammate was seeing in their browser, and a short description of the problem did not necessarily explain what had happened.

I added debug logging to gather more context for troubleshooting. That information helps me investigate issues and work with AI on possible fixes. A proposed fix still needs to be checked in the situation where the problem occurred.

This has been a useful part of the learning process: making a tool easier to troubleshoot matters alongside making it easier to use.

What has improved and what remains

A few teammates have used the extension and shared feedback. I have also seen colleagues adopt the workflow of uploading userscripts to GitHub and notifying the team. That supports both the extension and people continuing with their existing userscript manager.

I have not measured the time saved or collected a complete adoption count. The improvements are visible in the steps we have removed: opening several links becomes one action, a script handles a repeated workspace switch, and automatic syncing reduces the work of distributing scripts and updates.

The scripts reduce repetitive navigation, while the extension makes sharing and maintaining them easier. Analysts remain responsible for checking the information and making review decisions.

There is still unfinished work around update reliability and preserving preferences after reinstallation. Competing priorities have meant that some improvements remain in the backlog. An update flow needs to confirm that a change has actually been applied before treating it as complete, and that reliability matters as much as making updates convenient.

For me, this project has shown how much of building an internal tool involves the work around its main function. Installation, updates, browser differences, and troubleshooting all affect whether a small improvement becomes useful to other people. Feedback from the people using it has been essential to understanding where it still needs work.