Everyone talks about AI in the context of customer-facing products. The chatbot. The recommendation engine. The generative feature in your SaaS that appeared in the release notes last quarter. And yes — those things have value.
But some of the highest-return AI development work we do at Elysium has nothing to do with customers at all. It's the jobs that your team has been grinding through manually every month because the tooling to automate them felt too expensive to justify. With AI-assisted development, the economics of those tools have completely changed.
The task nobody looks forward to
Every service business that bills by time has a version of this problem. At the end of each month, someone has to compile the time logs, apply the billing rules for each client — which are never quite the same — format everything into a presentable report, and get it out the door. If you're doing it properly, across 10 or 12 clients, with different hourly rates, prepaid hour deductions, and tiered billing structures, it eats most of a day.
Ours was no different. We track client time in Redmine, our support platform. At the end of each month, generating billing reports meant manually querying time entries per project, working through the numbers for each client's particular billing arrangement, building out the Excel workbooks with the right structure, and saving them to the right place on the network. Repeat for each client. The data was all there — it was just tedious, error-prone work to assemble it.
The kind of task that tends to expand into a full day not because it's genuinely complicated, but because it demands sustained attention, it punishes mistakes, and it's exactly the sort of work that gets interrupted.
Building the fix — fast
We built a Python command-line tool called Elysium Timesheets to replace it. The tool connects to the Redmine API, pulls all time entries for a given client and month, applies the correct billing rules, generates a formatted Excel report, and saves it to the right network location. Run one command for a single client. Run the batch script and it generates reports for all of them.
What makes it more than a basic script is the billing logic it handles. Some clients pay a flat hourly rate. Others have tiered arrangements — say, the first 25 hours at one rate, then a higher rate on top. Some have prepaid hours that come off the total before billing kicks in. Some need time entries separated by cost centre so they can recharge internally. Each client has their own configuration: project IDs, rate structures, which tracker type to include, which sub-projects to exclude. The tool handles all of it.
Under the hood there's pagination to handle large monthly datasets from Redmine, a retry strategy with exponential backoff for network reliability, issue-level caching to avoid redundant API calls, and Excel output that uses actual formulas rather than pre-calculated values — so the person receiving the spreadsheet can see the working and adjust if needed.
It's not a complex piece of software. But it's not trivial either. There's real logic in there, and it needed to be right. A billing error in either direction is a problem.
The development time, with AI-assisted coding: a few hours. The same tool built without AI tooling — scoping out the Redmine API, working through the Excel generation library, handling the edge cases in the billing logic — would have been a 2–3 day piece of work. Possibly more, once you factor in testing against real data.
Now the monthly reports that used to take the best part of a day to produce run in minutes. Accurate every time. Consistent formatting. Saved to the right place automatically.
Why the economics have changed
The honest reason tools like this don't get built isn't usually technical. It's economic. If a task takes a day a month to do manually, and automating it is a week's development work, the payback period is eight months before you break even — and that's before you account for the ongoing cost of maintaining and updating the tool as things change. A lot of sensible engineering managers have done that calculation and decided it's not worth it.
AI-assisted development compresses the build side of that equation dramatically. A tool that would have taken a week to build now takes an afternoon. The payback period on that calculation drops to days rather than months. And suddenly a whole category of internal tooling — things you knew would save time but couldn't justify building — becomes genuinely worth doing.
This is where we're seeing some of the most immediate impact from AI coding tools. Not in the complex product features that still require deep thinking and careful design, but in the operational layer of running a business: the reporting scripts, the data transformation tools, the things that live in spreadsheets and email threads and manually-followed procedures because nobody ever had the time to build something better.
It still needs to be built properly
There's a version of this story where you just prompt an AI into producing a script, run it, and move on. And sometimes that's fine. But a tool that runs every month against live billing data and outputs client-facing reports needs to actually work. The Redmine API has pagination quirks. Network shares are unreliable. Billing logic has edge cases. The Excel output needs to look professional.
The value of having experienced developers in the loop — even when AI is doing a significant share of the code generation — is that they know which parts of a problem are harder than they look. They'll add the retry logic before it becomes a problem at 4pm on a billing deadline. They'll make the billing config explicit and testable rather than buried in conditionals. They'll structure it so that adding a new client next month is a five-minute job rather than a half-day of digging through code.
AI makes the build faster. Experience makes it reliable.
Start with the jobs nobody enjoys
If you're thinking about where to apply AI-assisted development in your own organisation, the monthly reports are a good place to start. So is anything that's currently a manual data extraction from one system into a spreadsheet. Or a task that follows consistent rules but still lives in someone's head because writing it down felt like too much effort.
These tasks have something in common: the inputs are structured, the rules are knowable, and the output is predictable. That's exactly the territory where automation pays back quickly, and where AI-assisted development closes the gap between "this would be useful" and "this is built."
The code already knew how to do it. You just needed someone to ask.