DEV Community

Cover image for AI for business problems: measure freed hours, review time included
MatIntellect
MatIntellect

Posted on Edited on Originally published at matintellect.com AI-assisted

AI for business problems: measure freed hours, review time included

Problem: AI projects in business get judged by the number of agents launched or tasks processed, which says nothing about whether people got time back, and hides the time someone spends checking the output. Result: a small calculation of weekly hours freed per task that counts review time explicitly. Stack: Python 3.10+ standard library (tested on 3.15.2). Boundaries: you supply the minutes; the example numbers are invented for one imaginary employee

AI-generated illustration of AI for business problems

Why this metric

The ads promise a hundred agents running a company. When I tried building real systems, the useful ones turned out to be narrow, repetitive and checked by a person. I run a team of 8 AI agents; none of them runs the business alone, and none publishes or spends without me. My personal agent has been running for 134 days, does 10 scheduled jobs and has passed 165 tasks to other bots since July, with deleting, spending, client messages and publishing always waiting for my yes

The scale is real, but it shows up as hours, not as agent counts. A post that took about an hour now reaches a preview in about 5 minutes; a long call becomes a transcript, tasks and a CRM card in about 10 minutes. Measuring that honestly means counting the review step too

Input, processing, output

Input: per task, how many times a week it happens, minutes per item before AI, minutes per item after AI, and minutes a person spends reviewing each AI result

Processing: hours before equals count times minutes before; hours after equals count times (minutes after plus review); freed equals the difference

Output: hours before, after and freed per task, plus a weekly total

A team discussing documents

The example

def freed_hours(before: dict, after: dict, review_minutes: dict, per_week: dict) -> list[tuple]:
    """Weekly hours freed per task, counting the time a person spends checking AI output."""
    rows = []
    for task, n in per_week.items():
        old = before[task] * n / 60
        new = (after[task] + review_minutes[task]) * n / 60
        rows.append((task, round(old, 1), round(new, 1), round(old - new, 1)))
    return rows

if __name__ == "__main__":
    # invented teaching numbers for one employee's week
    per_week = {"invoice check": 40, "weekly report": 1, "client reminders": 30}
    before = {"invoice check": 6, "weekly report": 90, "client reminders": 3}
    after = {"invoice check": 0.5, "weekly report": 5, "client reminders": 0.2}
    review = {"invoice check": 1.5, "weekly report": 20, "client reminders": 0.5}
    total = 0
    for task, old, new, freed in freed_hours(before, after, review, per_week):
        total += freed
        print(f"{task}: {old} h -> {new} h, freed {freed} h/week")
    print(f"total freed: {round(total, 1)} h/week")
Enter fullscreen mode Exit fullscreen mode

Output, exactly as printed when I ran it:

invoice check: 4.0 h -> 1.3 h, freed 2.7 h/week
weekly report: 1.5 h -> 0.4 h, freed 1.1 h/week
client reminders: 1.5 h -> 0.3 h, freed 1.1 h/week
total freed: 4.9 h/week
Enter fullscreen mode Exit fullscreen mode

Note how review dominates "after" in every row. That is not a flaw; it is the part a person keeps, and leaving it out would overstate the gain several times over

Design notes

Review is not optional. In every working chain I run, the last decision is human. If your "after" number has no review time, either the work is truly trivial or nobody is checking it

Measure, do not estimate. Time a normal week before the change and a normal week after. Guesses about manual work are usually low, and guesses about review are usually lower

Freed hours need a destination. Decide with the employee what the time goes to: more customers, better quality, postponed work. Otherwise it dissolves into the week and nobody can say what changed

Bad metrics are easy to grow. Agents, runs and generated texts can all go up while freed hours stay flat. Track hours first

Choosing tasks to measure

Three questions filter candidates: does the task repeat, can its result be checked, and is there a named person to check it. If any answer is no, pick another task. Repetitive operations such as order processing, report preparation and individual steps in finance and bookkeeping usually pass; complex multi-step judgement usually does not

Colleagues discussing charts

Where freed time should go

The calculation is only useful if the hours land somewhere. In practice they go to more customers, because the same person answers more people and stops losing leads; to quality, because a specialist finally has time to think; to work that was postponed for months; or simply to fewer late evenings. Write the destination next to the number. If there is nowhere to put the time, that is a conversation about where the business wants to grow, not a reason to cut someone

Limits

Small numbers mislead. A task done twice a week will never free much time, however good the AI is

Quality is outside this calculation. A faster process that produces worse work is not a win; keep a separate check on output quality

Ramp-up skews the first weeks. Review takes longer until corrections turn into rules; measure again after a month

Reproduce it

  1. Save the code as hours.py and run python3 hours.py
  2. Replace the dictionaries with one real employee's tasks and measured minutes
  3. Rerun after a month with updated review times
  4. Write down where the freed hours went

The non-technical version: AI for business problems: scale without firing people

This article was created with the help of AI.

Top comments (0)