For ten days, my AI developer did no work, and every health check on the dashboard was green.
The tool was installed, it could run, and it happily printed its version number. Its login had expired though, so every attempt to do any actual work failed. None of my checks tested whether it could log in.
Looking back, there was a fairly obvious clue: 35 calls and $0.00 spent. A failed login costs nothing. I was counting attempts without checking whether anything had happened.
This is probably a good introduction to Heavy Lifter, a system I’ve spent the last two months building and running against real Jira tickets. It reads the ticket, asks questions, writes a plan, implements the change and puts it into a test environment. Once someone is happy with it, it opens a GitLab merge request.
I expected most of the effort to go into getting the AI to write decent code. In practice, I’ve spent much more time working out what it should be allowed to do, how to explain that to the person approving it, and how to notice when it has quietly stopped working.
Why I built it
Most teams have a long list of small jobs waiting for a developer. A label is wrong on a PDF. Another role needs access to a field. An upload error needs to tell people how big their file was.
None of these is particularly difficult, but each one means stopping something else, loading up the context, asking a question and waiting for an answer. By the time you come back to it, you need to remember what you were doing in the first place.
These seemed like good jobs to give a coding agent. I still wanted the person who raised the ticket to decide what should happen, and to check the result before it went any further.
For example, someone raises a ticket saying the upload limit is too small. Heavy Lifter might come back with:
Should we increase the limit (A), or compress images on upload so large files fit (B)? I’d suggest B, since it keeps storage costs flat.
The product owner replies “B please” and assigns the ticket back. Heavy Lifter writes a short plan for them to approve, then builds the change and publishes it to the user acceptance testing environment, or UAT, with a note explaining what to try.
If it needs more work, they send it back with feedback. When they’re happy, the system opens a merge request for someone to review and merge.
That’s the basic idea: do the work needed to get to the next decision, then hand it back to a person.
How it works
Heavy Lifter checks one Jira project every fifteen minutes and only picks up tickets assigned to its nominated account. It follows this sequence:
- Read the ticket and ask questions if a product decision is missing.
- Once it has enough information, post a short plan and hand the ticket back.
- Once the plan is approved, write the code, run the build and publish to UAT.
- Rework the change if the reviewer has feedback.
- Open a merge request when the ticket moves to Ready for Deployment.
The teal boxes are work Heavy Lifter does. The amber gates are where a person decides what happens next. You can open any diagram to see it full size.
Handing a ticket back means reassigning it to whoever needs to act next. To approve a plan, that person replies and assigns it back to the bot. Both parts matter: the reply tells it what was decided, and the assignment tells it to pick the ticket up on the next run.
It sounds a little fussy, but it means you can look at the Jira board and see who each ticket is waiting on.
For anyone interested in the stack, it’s a React dashboard, .NET Azure Functions, Jira and GitLab APIs, and the Claude Code CLI doing the reading and coding. The dashboard lets me turn it on or off, run it immediately, or do a dry run to see what would happen without making changes.
Getting people to read the plans
My first plans were detailed engineering documents. The problem was that the people approving them weren’t looking for an engineering document. They wanted to know whether I had understood their request and what would change.
So I removed file names, function names and code from the plans, and asked for one sentence followed by no more than three bullets, aiming for under eighty words. One real plan went from 230 words across five labelled sections to 86. Still a little over, but much easier to read.
I made the questions optional too. If the ticket is clear, there’s no reason to send it back just to confirm the obvious. If there is a choice worth making, it offers options and a recommendation so the reply can be as simple as “B please”.
There were some basic things to fix along the way. A product owner attached four screenshots showing where some items appeared, and the plan came back saying it couldn’t see them. It turned out the images were being dropped when I converted the ticket into text. Once I fetched the images and had the model open them, it produced a different plan.
Even the punctuation made a difference. Nobody on our team really types em dashes, so the comments looked obviously machine-written. I asked the model to avoid them and added a filter for any that slipped through. A small thing, but the comments sounded much more like something a person on the team would write.
Keeping the history in Jira
One decision that has worked well is keeping ticket progress in Jira itself, rather than creating a separate database to track it.
Every comment Heavy Lifter posts ends with a marker such as [heavy-lifter:plan]. On the next run, it reads the ticket status, finds its latest marker and looks at the human replies after it to work out what to do next.
If someone changes the ticket manually, the next run just reads the new situation. There’s no second record of progress that can get out of sync, and the conversation is available to everyone who already uses the ticket.
Of course, anyone could type one of those markers into a comment. The system therefore only accepts them from the configured bot account.
At the moment that account is mine, which isn’t ideal. It can distinguish my account from everyone else’s, but it can’t distinguish a comment I wrote from one the bot wrote. A dedicated service account is still on my list.
What exactly did they approve?
Approvals turned out to need more thought than I expected. Consider this reply:
Yes, go ahead, and clear out the old orders while you’re in there.
They’ve said yes, but they’ve also added a job that could delete data. Checking whether someone approved the plan and checking whether it’s safe to act on their reply need to be separate steps.
Heavy Lifter now works through five checks before pushing code:
- Who is speaking? Comments from people outside the approved list are removed before the model sees them.
- Who approved? Someone can be allowed to answer a question without being allowed to authorise a build.
- What was approved? A separate model call checks the reply for anything that should stop the work, including extra requests added to an approval.
- What was written? The actual code diff is checked for protected files, excessive numbers of changed files and large deletions.
- Does it build? The project build runs in the ticket’s workspace. If it fails, the model gets the compiler output and one attempt to fix it. If it fails again, it goes back to a person.
If a check puts the ticket on hold, Heavy Lifter posts the reason and assigns it to a named review contact. Only that person’s account can release it. Passing these checks still doesn’t tell us whether the feature does what the product owner wanted, which is why they test it in UAT before it reaches the merge request.
Making sure it’s reading the right code
For weeks, Heavy Lifter was planning changes against my local checkout, which was thirteen commits behind main. I only noticed when it confidently told me the project had no test setup. In the version it was reading, that was correct.
Read-only calls now use the latest main, and each ticket gets its own git worktree, ie a separate working directory using the same repository history.
This keeps my unfinished work out of its commits and stops two tickets from picking up each other’s changes. It also means the bot can’t switch the branch I’m working on underneath me.
Each time it publishes to UAT, it starts from main and merges in the ticket branches currently under review. A rejected ticket can then leave the environment without taking everyone else’s work with it. If one branch won’t merge, it gets flagged and skipped, so the other tickets can still be tested.
Old ticket branches are rebased before work resumes. If Claude resolves a conflict, the diff checks and build run again. The first real attempt resolved a nine-hunk conflict for $2.13 and came up with the same result I’d written by hand. I was pleased with that, although I wouldn’t assume every conflict will go so well.
A few things that went wrong
I’ve kept a decision log as I’ve gone along. It has become one of the most useful files in the project, partly because the same sorts of problems keep coming back.
Rejecting a perfectly good yes
Every plan ended with instructions to reply with approval and reassign the ticket. I gave the whole comment to the model that checked for approval, including those instructions.
It started rejecting replies because they lacked “the required reassignment action”. But reassignment is a field change in Jira. You can’t see it in a reply, and my code had already checked it before asking the model anything.
I had a similar problem with “Rebase please, then commit, and sort out any merge issues”. Sometimes the model read this as a refusal because it contained instructions. With the same real input, the old prompt accepted six out of ten runs. After making it clear that approval can include instructions, it accepted ten out of ten in that test.
That doesn’t prove it will always get approvals right, but it did show me where to look. If the reason for rejection asks for something the reply couldn’t possibly contain, the check itself needs fixing.
Making up the missing context
One re-plan said an earlier attempt had stopped before changing anything, even though seven half-written files were sitting in the workspace.
Another claimed UAT was well behind and listed six other tickets whose changes would arrive alongside the work. None of that was true. A person approved the plan, then the risk check took the invented risk seriously and put the ticket on hold.
I changed the plans to describe only the product change. The pipeline handles branches and deployments, so anything about their current state needs to come from checking them directly. It doesn’t belong in a product plan based on the model’s guess at what happened.
Checking everything except the thing that failed
Which brings me back to the expired login. I’d checked that the tool existed, that it was executable and that it could print a version. All of those could pass without it being able to do a single piece of work.
My rule now is to deliberately create the failure a check is supposed to catch and see whether it catches it. Until then, I don’t know if the green light means much.
There were other omissions. For weeks the prompt told the model to run the build, while the CLI’s permission settings refused to let it run the build tool. In another case, someone approved a plan and asked for an extra text setting. The approval passed, but I never passed that extra request to the model writing the code.
It’s easy to blame the model when something goes wrong. In these cases, I needed to look at what I had actually allowed it to do and what information I had given it.
Where the time and money went
The dashboard’s pipeline view once took 75 seconds and about $1.50 to load. I measured where the time was going: Jira took 1.3 seconds, and most of the rest was fifteen model calls running one after another. Fourteen of those results were thrown away.
Now the dashboard first shows everything it can work out without a model call. The remaining decisions fill in afterwards, running in parallel and cached against the exact prompt. The initial view came down to about 1.9 seconds in my measurements. A repeat load took 1.7 seconds and needed no new model calls.
I also moved the simple yes/no checks to a smaller model without access to repository tools. In those runs, the cost came down from roughly $0.095 to $0.025 per call. The higher-stakes checks and code writing stayed on the larger model.
Those figures are specific to my setup and the runs I measured, but they gave me a much better idea of what was worth improving.
How does it compare with the other software factories?
There are already several systems doing versions of this. Looking at them, the basic idea of assigning a ticket to an agent and getting code back is fairly well established. Asking questions and approving plans aren’t unique to Heavy Lifter either.
OpenAI’s Symphony is particularly close in its architecture: it picks up work from a tracker, gives each issue its own workspace, and manages concurrent runs and retries. Its example workflow builds and validates a pull request before handing it over for human review. You can configure a different approval process, so that sequence is a starting point rather than a restriction.
What I’ve built is more specific to how our team works. The person who raised the ticket gets a short plan to approve, then tries the result in shared UAT before a merge request is opened. The benefit is that they can make decisions by reading a few sentences and using the product. The cost is that tickets still wait for people, and changes being tested together can affect each other.
Here’s how I’d assess the different approaches from their published descriptions:
-
Heavy Lifter
- Benefit
- Small changes move through short product-owner decisions in Jira, with UAT before the merge request.
- Tradeoff
- Human handovers set the pace. I maintain the runner, and shared UAT can mix changes from several tickets.
-
OpenAI Symphony
- Benefit
- A foundation for running multiple ticket-driven agents, with separate workspaces, retries and recovery.
- Tradeoff
- You still need to define the team's approval process, validation and deployment workflow.
-
Factory / Droid
- Benefit
- Remote Jira delegation, plus plan approval and adjustable autonomy for different kinds of work.
- Tradeoff
- Your team needs to choose and configure the modes, permissions and review process it wants.
-
Devin
- Benefit
- Hand over a Jira issue, follow progress and answer questions there, then get a pull request back.
- Tradeoff
- Jira is linked to Devin sessions. A staged plan-and-UAT process like ours still needs to be specified.
-
StrongDM's approach
- Benefit
- Agents iterate against end-to-end scenarios and simulated services, aiming to work without human code review.
- Tradeoff
- It depends on a substantial validation setup. The scenarios and simulations must catch what matters to users.
My assessment, 19 October 2026. Links explain each system's approach; this isn't a benchmark. Heavy Lifter describes my implementation, Symphony a framework, Factory and Devin products, and StrongDM an engineering approach.
StrongDM is the furthest from where I’ve ended up. Its aim is to make automated validation good enough to work without human code review. I can see the attraction, but for our small changes I’m still getting useful feedback from having the product owner try the result. For now, that’s a step I want to keep.
Would I build it again?
Yes. The small tickets get started without waiting for me to find a gap, and the product owners get questions and plans they can answer without reading through implementation details. The decisions and changes are all there in Jira and git if we need to go back and look.
There are still things to sort out. The runner that writes the code lives on my laptop and needs a working copy, a CLI login and push credentials. Moving it to a hosted runner is unfinished, as is giving it its own Jira account. Borderline decisions can still vary from one run to the next.
It also needs maintenance. An automatic CLI update once left the binary truncated and stopped everything. I now pin the CLI and model versions, and revise the prompts against failures I’ve actually seen.
If you’re thinking of building something similar, my suggestion is to start with a small class of tickets and decide where you want a person to step in. Make the questions easy to answer and the plans short enough that people will read them. Then check that your failure checks actually work.
That’s where most of my effort has gone over these two months. Getting it to write code was useful, but getting it to ask a sensible question, wait for an answer and tell me when something had gone wrong is what made it worth using.





