A 20-minute billing run, reduced to one sentence

Every cycle, billing my manual-payment customers used to be a 20-minute job: pull who owes what, generate each invoice, send them out, log it. Now I say one sentence and it's done in about 30 seconds. This is the boring, invisible task that quietly eats your week — and it's exactly the kind AI is best at taking off your plate.

Why this is the right first thing to automate

Most owners reach for the visible automation first — marketing, social posts, the things that feel modern. But the task that actually buys back your time is usually the one you've stopped noticing because you've done it a thousand times. Billing is the perfect candidate: it's repetitive (same steps every cycle), rule-based (you already know who gets charged what), and error-prone when done by hand (a forgotten invoice is money that silently never arrives). That combination is exactly where automation pays for itself fastest.

How it works

There's no magic, and that's the point. The work was never hard — it was just manual and repetitive, which is the definition of something a machine should do. The pattern is three steps:

1. Pull the source of truth. Who has an open balance, what do they owe, what's already been paid. This comes from wherever your data actually lives — your payment system, a spreadsheet, your books.
2. Apply your rules. The judgment you'd apply by hand — which customers are on manual billing, what each is charged, who to skip — written down once so it runs the same way every time.
3. Generate and send. Create each invoice and send it, individually, logged — then tell you what went out so you can trust it happened without checking.

The "one sentence" is me telling it to run. The reason it takes 30 seconds instead of 20 minutes is that all the judgment is already encoded — I'm not re-deciding anything, I'm just pulling the trigger.

The skill itself

You might expect this to be a wall of code. It isn't. The skill is a plain-English Markdown file describing the routine — your rules, written down once. It points at your billing system to do the actual sending, but the skill is just instructions:

# Run Billing

Bill the manual-payment customers for this cycle.
What used to take 20 minutes of clicking; now one run.

## Who to bill (the rules)

- Only customers on MANUAL payment (skip auto-pay).
- Only those with an open balance greater than zero.
- Skip anyone currently on hold.

## What to do

1. Pull the current open balances from the billing
   system — who owes what, right now.
2. Apply the rules above to decide who gets an invoice.
3. For each one: create the invoice for their balance,
   send it to their email, and log that it went out.
4. Report back: how many invoices, total billed — so I
   can trust it happened without checking each one.

The leverage isn't the steps — it's the rules. Getting "who to bill" exactly right, wired to your real billing system, is the part that takes judgment and the part I do for you. Once it's correct, the running is free.

Where this goes next

Billing is the on-ramp. The same pattern — pull the real data, apply your rules, do the thing, report back — is what takes the weight off the rest of your back office: reconciling two systems that never quite agree, chasing the invoices your team forgot to create, answering the same fifteen customer questions, surfacing the closed jobs that silently never got billed. Pick the one that's eating your week, and it's almost always the same shape underneath.