Hackathon Spotlight: AI-Assisted Jira Workflows and One-Shot Fixes with Kotlin Koog and OpenAI Codex

TL;DR

• Incomplete or poorly structured Jira tickets slow down distributed engineering teams. Bitmovin’s hackathon team built an AI-powered workflow to automatically audit incoming bug reports and ensure they contain all the context engineers need before work begins.
• A nightly GitHub Action triggers a Kotlin Koog-orchestrated workflow that uses OpenAI GPT to check tickets for reproducibility details, flag missing information, suggest clarification questions, and validate product area relevance.
• Beyond ticket prep, the team extended the workflow to attempt fully autonomous code fixes for well-bounded tasks. Using the OpenAI Codex agent running inside a Docker environment with a live codebase, the system generates code changes, runs tests, and opens a pull request.
• The one-shot approach works best for small bug fixes, localized cleanup, and repetitive low-risk changes where expected behavior is already clearly defined.
• It is not suited for refactors, complex features, or tasks requiring deep architectural reasoning.

During a recent company-wide hackathon at Bitmovin, teams across the organization explored how AI could be used to improve internal workflows and prototype ideas that may influence future product directions. One area that consistently slows teams down, especially across distributed engineering groups, is how issue tickets enter the development process. Bug reports may arrive incomplete, unclear, or missing key diagnostic details, and engineers often spend valuable time gathering the right information before meaningful work can even begin.

So we set out to experiment with an automated solution. 

In this blog, we explore how AI was used to analyze incoming tickets, identify missing context, and help prepare issues for faster engineering execution.

Designing an AI-Powered Ticket Preparation Workflow

To start, the goal was not to replace human review, but to ensure that every ticket, especially bug reports, has enough structure and detail for engineers to begin work without unnecessary back-and-forth.

We experimented with an automated workflow designed to improve how new Jira tickets are prepared before entering active development. Running as a nightly GitHub Action, the workflow is orchestrated using Kotlin Koog, while an AI model powered by OpenAI analyzes ticket content and performs several preparation tasks:

How It Works

1. Nightly GitHub Action triggers the pipeline.
2. Kotlin Koog orchestrates the workflow.
3. OpenAI GPT analyzes the ticket’s content and performs a series of preparation tasks:
   • Checks if required details for reproducibility are included
   • Highlights any missing information
   • Suggests clarification questions
   • Ensures the problem description and expected behavior make sense, by also checking the linked secondary communication channels
   • Validates that the issue fits within relevant product areas

The end result was more consistent, clearer tickets that are easier for engineers to pick up.

One-Shot Fixes: From Ticket to Pull Request

While automated ticket preparation helps ensure that tickets are well-structured before work begins, we also wanted to explore whether AI could take on highly self-contained engineering tasks end-to-end. This led to our second experiment: one-shot fixes.

The idea was simple. If a ticket describes a well-bounded change, something that does not require deep architectural understanding or large cross-module reasoning, could an AI agent implement the fix autonomously and deliver a ready-to-review pull request?

To test this, we extended the same tooling used for ticket preparation and created a non-interactive workflow powered by the OpenAI Codex coding agent.

How the One-Shot Workflow Works

The workflow runs inside a purpose-built Docker environment that includes:

• A checked-out version of the relevant code repository
• A fully configured build and development toolchain

Within this environment, the workflow performs the following steps:

1. Prompt construction
   The system takes the Jira ticket, extracts relevant content, and combines it with a custom instruction prompt tailored for generating focused code changes.
2. Non-interactive code generation
   The prompt is passed to the Codex coding agent in a non-interactive mode. All changes are directly applied to the contained development environment and tests are run automatically.
3. Automated PR creation
   When the change passes validation, the workflow automatically commits the update, pushes a branch, and opens a pull request in GitHub

From Jira ticket to pull request, the process is fully automated.

Where This Approach Works Best

The one-shot workflow is not intended for major refactors, complex feature work or API design. Instead, its strengths lie in accelerating:

• Small bug fixes
• Localized cleanup or modernization
• Repetitive, low-risk code changes
• Tasks where expected behavior is already well-defined

Even when the AI doesn’t produce a perfect fix, our experiments showed that most of the time it generates at least a good starting point. In some cases, ticket resolution required no functional changes at all, while in others the output was not usable. These outcomes helped clarify where AI-assisted workflows can provide the most value and where human intervention remains essential.

Takeaways

The hackathon gave us a practical look at how lightweight AI integration can meaningfully improve developer workflows. By combining Kotlin Koog, GitHub Actions, and OpenAI, we now have a prototype that reduces friction in our ticket lifecycle and opens the door to more automation in debugging and testing.

FAQs