Building TROLL: A Hackathon Experiment in AI-Assisted Ticket Writing

In the spirit of creating absolutely brilliant acronyms, we present TROLL - a tool born from a hackathon experiment and a simple question: what if AI could help us write better tickets?

Who’s That Trip Trapping Over My Bridge?

Every developer has encountered a cryptic ticket. Somewhere, someone is opening Jira, full of good intentions, only to be greeted by a ticket that says “fix the thing”. Which thing? What kind of fix? And suddenly, instead of cracking on with the work, you’re playing detective.

But what if there was something (maybe a Troll? - see where we’re going here) gatekeeping the bridge, ensuring clear, detailed descriptions for Jira tickets, GitHub pull requests, or docstrings?

When priorities are tight and teams need to capture issues quickly, vagueness comes at a cost: slower collaboration, misaligned expectations, and endless clarifications that burn time better spent building.

And it was this opportunity that Alan and Chris decided to tackle as part of the Fuzzy Labs AI hackathon. Rather than accept thorough ticket writing as time-consuming, they asked: could AI help bridge that gap, speeding up ticket writing and enriching the information to create detailed, clear, actionable commentaries.

The Plan: Building a Better Bridge Guardian

The concept was straightforward - instead of writing perfect tickets from scratch, start with a basic description and let AI do the initial enhancement.. TROLL - the Ticket Resolution & Organisational Lifecycle Liaison (oh yes! 🧌) - would refine it, making it clear, well-structured, and detailed enough to keep the team aligned.

For the hackathon, they focused on getting TROLL working with Jira and GitHub integration, pulling context from commits and issues to inform the AI enhancement. Future iterations could potentially flag incomplete tickets, ask clarifying questions, or expand to include Google Docs and Slack for richer context gathering.

They also envisioned two companion tools, with one equally magnificent acronym based name, for the broader ecosystem:

• VICE PRESIDENT ("Very Intuitive Code Explainer: Pull Requests Explained Succinctly. I Don't Even Need Tests!") for GitHub PR descriptions
• The Docstring Whisperer as a pre-commit hook for consistent code documentation

Together, these tools would (or will at a later date) "remove the hassle of writing repetitive descriptions and documentation, allowing you to concentrate on coding and delivering features."

The Build: A Day with Claude Code

On the hackathon day, for this team, things went very smoothly. They spent time planning the architecture and settled on a Python script linking Jira, GitHub, and Gemini together.

The development process became an experiment in AI-assisted coding. Following Tom's advice, Alan set Claude Code to plan mode and had it think through the implementation at different levels. Once he was satisfied with the plan, he switched it to autocomplete mode and let it build.

What happened next was next level vibing: Alan testing what Claude had built, suggesting improvements, or simply pasting error messages back when things broke,  but never actually reading the code Claude was writing. Claude went even further implementing features like a TROLL banner, interactive mode, and preview functionality - which was a very nice touch.

For testing, they needed realistic data, so they created a dummy Jira project and linked it to the real librosa repository. Claude Code managed to fetch actual GitHub issues and turn them into believable Jira tickets. It was creating its own test scenarios, which turned out to be really quite useful for testing the ticket enhancement process.

Reality Check

When Alan eventually examined what Claude had generated, he discovered both the power and quirks of AI-generated code. While it was a nice prototype, a lot of cleaning up would be required for release. Claude had written extensive comments everywhere and implemented overkill fallbacks for every conceivable failure = lots of unnecessary redundant code.

There were also some predictable AI quirks. It was using a deprecated package for Gemini, likely based on what was more prevalent in the training data. When asked, it moved to the current package and a newer, better model pretty seamlessly. For the final transformation from basic Python script to proper CLI tool, Claude Code handled it easily.

The cleanup process revealed important lessons about AI-assisted development. While AI assistants can significantly enhance productivity, they need clear guidance to build practical, robust solutions. The model had frequently resorted to hacky fixes and workarounds when implementing new features, which highlighted the importance of approaching projects with a well-defined, structured plan from the outset.

How Our TROLL Works

1. Connect to Jira → Lists available tickets or fetches specific ticket details
2. Analyse GitHub → Gathers context from commits, issues, and codebase structure
3. AI Enhancement → Gemini generates improved title and description with proper structure
4. Preview Changes → Shows before/after comparison
5. Updates Ticket → Applies improvements to Jira with enhanced formatting

Here's a real example from the repo:

Before (Vague Ticket)

After (TROLL Improved)

Getting Started with TROLL

Ready to give it a go? Here's what you need:

Installation

First, you'll need to grab the code from GitHub and install it locally:

<pre><code>
git clone https://github.com/fuzzylabs/TROLL.git
cd TROLL
pip install -e .
</code></pre>

Setup Process

Run troll --setup to kick off configuration and you'll need to gather three API tokens. You'll want a Jira API token (which you can create here), a GitHub token with repo scope (generate one here), and a Gemini API key from Google AI Studio.

Using TROLL

For interactive mode, just run troll to browse and select tickets through a clean interface. If you want to target a specific ticket immediately, run something like troll TP-123. And if you get stuck at any point, troll --help will sort you out.

Customisation

You can edit TEMPLATE.md to adjust the ticket structure and enhancement format to match your team's preferences. TROLL uses this template as a guide when generating enhanced tickets.

What We’re Learning

The hackathon proved that AI can genuinely solve everyday developer frustrations. Alan and Chris didn't just create a prototype - they built a working tool that transforms cryptic tickets into clear, actionable tasks. TROLL demonstrates how human creativity combined with AI capability can tackle meaty problems in a very short amount of time.

The best part? It's alive! We've been testing TROLL internally at Fuzzy Labs, and the approach is proving useful - with the AI augmenting human expertise rather than replacing it.

Early results suggest it genuinely helps streamline ticket creation while maintaining quality but, in the spirit of Fuzzy Labs and vigorous testing, we want to understand how it performs across different workflows and team structures. That's where you come in - now you can try it too and help us learn whether this human-AI collaboration approach works beyond our own team dynamics…

Ready to Banish Vague Tickets?

The tool is live on GitHub right now, ready for you to clone and start using immediately.

Have a play and see what happens, and let us know how it goes! Your feedback will help us iterate and improve the approach.

… and if you find it useful, perhaps give it a little star too (👀❤️)

Link: TROLL on GitHub

Happy TROLLing! 🧌✨