One Claude File Runs My Whole Invoicing Business

By Lazar Milicevic · Published June 21, 2026 · 9 min read

Six weeks in, most solo founders have a domain, a Notion vault, a half-built funnel, and exactly zero invoices sent. The bank account doesn't care about your AI operating system. It cares about the loop that turns work into money: quote, invoice, paid. This post shows you the single Claude Code setup I use to run that loop end-to-end in about 90 seconds of active work per cycle.

Why the Standard SMB Stack Fails Solo Operators

The conventional advice for a one-person business is to assemble a stack: a CRM like HubSpot, an invoicing tool like QuickBooks or Stripe Invoicing, an email platform, a document generator, and Zapier to glue it together. Before you've billed a single client, you're paying somewhere between $80 and $200 a month and burning two weeks on configuration. Every tool has its own client list, its own templates, its own export format. You end up maintaining four sources of truth for the same five customers.

The other failure mode is what I call the "AI operating system" trap. You build a beautiful nested folder structure with sub-prompts for marketing, sales, ops, finance, and content. It looks great in a YouTube thumbnail. It generates zero invoices.

Here's a more honest comparison for a solo operator running ~10 invoices a month:

The folder approach wins because there's one source of truth (flat JSON files on disk), one brain (CLAUDE.md), and three commands. That's the whole product.

The File Layout — One Folder, Six Files

The entire business runs out of a single directory. No database, no SaaS, no platform tax. Here's the structure:

invoicing/
├── CLAUDE.md
├── clients.json
├── quotes.json
├── invoices.json
├── templates/
│   ├── quote.html
│   └── invoice.html
├── .claude/
│   └── commands/
│       ├── quote.md
│       ├── invoice.md
│       └── chase.md
└── output/
    └── 2025-01-15/
        └── INV-2025-0042.pdf

A few things worth pointing out:

• JSON, not SQLite. At 10–100 clients you don't need a database. jq and Claude can read and rewrite JSON files faster than you can write the schema migration.
• .claude/commands/ is the magic. This is where Claude Code looks for slash commands scoped to the project. Each file is a short markdown spec.
• Dated output folders make the audit trail trivial. Every PDF lives under the day it was generated.

The CLAUDE.md File — The Brain of the Operation

CLAUDE.md is what Claude Code reads automatically on every session in this folder. It's the persistent context that tells the model how your business actually works. Mine is roughly 80 lines and covers three things.

1. Business definition (3 sentences). Who the clients are, what services I sell, what currency and tax rules apply.

2. Data schemas. Plain text descriptions of what each JSON file looks like:

## Data files

- `clients.json`: array of objects with fields
  `id` (int), `legal_name` (string), `tax_id` (string),
  `email` (string), `payment_terms_days` (int, default 14).

- `invoices.json`: array of objects with fields
  `invoice_number` (string, format INV-YYYY-NNNN),
  `client_id` (int), `line_items` (array of {description, qty, unit_price}),
  `issue_date` (ISO 8601), `due_date` (ISO 8601),
  `status` (enum: draft | sent | paid | overdue),
  `subtotal`, `tax`, `total` (numbers, USD).

- `quotes.json`: same shape as invoices but with `quote_number`
  (format Q-YYYY-NNNN) and no due_date.

3. Workflow rules in plain English. Three short sections describing what "generate a quote", "convert a quote to an invoice", and "chase overdue invoices" should actually do, including tone for reminder emails ("polite, professional, never accusatory; reference the invoice number and days overdue").

That's the entire context Claude needs. No fine-tuning, no vector database, no RAG pipeline. The model already knows how to read JSON, fill an HTML template, and draft an email. CLAUDE.md just tells it the specifics of this business.

The Three Slash Commands

Inside .claude/commands/ I have three markdown files. Each is between 15 and 30 lines. Here's the actual structure of /quote:

---
description: Generate a quote PDF for a client
argument-hint: <client_id> <natural language line items>
---

Read clients.json and find the client with id matching $1.

Parse the line items from the rest of the arguments ($2+).
For each item, extract description, quantity, unit price.

Calculate subtotal, apply tax rate from CLAUDE.md, compute total.

Open templates/quote.html, fill in client details, line items,
and totals. Save as output/<today>/Q-<year>-<next_number>.pdf
using the headless Chrome PDF renderer.

Append the new quote object to quotes.json.

Print the file path and total to the terminal.

/invoice is similar but takes a quote ID, copies the line items, assigns the next invoice number, calculates the due date from payment_terms_days, generates the PDF, updates invoices.json with status sent, and drafts an email with the PDF attached.

/chase is the simplest of the three:

---
description: Draft reminder emails for overdue invoices
---

Read invoices.json. Today's date is the current system date.

Filter for invoices where status is "sent" AND due_date < today.

For each overdue invoice:
  - Compute days_overdue = today - due_date
  - Look up client email from clients.json
  - Draft an email referencing the invoice number, amount,
    and days overdue. Tone: polite, professional.
  - Output the draft as a .eml file in output/<today>/reminders/

Print a summary table: invoice number, client, amount, days overdue.

Three commands. That's the entire cash-in loop.

A Real 90-Second Cycle

Here's what an actual session looks like. I cd into the folder, run claude, and the model reads CLAUDE.md automatically.

> /quote 12 fifteen hours of consulting at $150, one fixed
  deliverable at $1,200

✓ Read clients.json — Acme Industries, payment terms 14 days
✓ Calculated: subtotal $3,450, tax $0 (B2B export), total $3,450
✓ Generated output/2025-01-15/Q-2025-0007.pdf
✓ Appended to quotes.json

Quote Q-2025-0007 saved. Total: $3,450.00

Elapsed: about 20 seconds. I email the PDF to the client. Two days later they reply "approved."

> /invoice Q-2025-0007

✓ Loaded quote Q-2025-0007
✓ Assigned invoice number INV-2025-0042
✓ Due date: 2025-01-29 (14 days from today)
✓ Generated output/2025-01-15/INV-2025-0042.pdf
✓ Updated invoices.json — status: sent
✓ Drafted email (preview below)

To: billing@acme.example
Subject: Invoice INV-2025-0042 — $3,450.00 due Jan 29

Hi James,
Please find attached invoice INV-2025-0042 for the consulting
engagement we agreed on this week. Payment terms are net 14,
due January 29.

Thanks,
Lazar

Another 20 seconds. I review, hit send.

A week after the due date passes:

> /chase

Found 2 overdue invoices:

INV-2025-0038  Beta Corp     $1,800   12 days overdue
INV-2025-0041  Gamma LLC     $2,400    4 days overdue

✓ Drafted 2 reminder emails in output/2025-01-22/reminders/

I read both drafts, adjust one sentence on the Beta Corp one because they're a repeat client, send them. Maybe 40 seconds.

Full cycle — quote, invoice, chase — that used to take me about 20 minutes across Word, a PDF tool, my email client, and a tracking spreadsheet. Now it's roughly 90 seconds of active work per invoice per month.

What to Skip Until You Have Paying Clients

The reason this works isn't because Claude Code is magic. It's because the loop is small and the data model is honest. A few things I deliberately did not build:

• No web dashboard. I read JSON in the terminal. cat invoices.json | jq '[.[] | select(.status=="sent")]' is faster than any UI.
• No client portal. Clients want a PDF in their inbox. That's it.
• No payment integrations. Bank transfers reconcile fine manually at this volume. When I cross 50 invoices/month I'll add a Stripe webhook to flip status to paid. Not before.
• No CRM. clients.json is the CRM. If I need notes per client, I add a notes field.
• No "AI marketing assistant". It doesn't generate revenue at month one. Build it at month six if you still need it.

The principle: build the cash-in loop first, automate the bottleneck second, expand the surface area never.

Why bizflowai.io helps with this

This pattern — small flat-file data, one project-scoped Claude Code config, a handful of tightly-scoped slash commands — is exactly what bizflowai.io builds for clients who don't want to maintain it themselves. The team sets up the CLAUDE.md, the JSON schemas, the PDF templates, and the commands tailored to your specific quoting, billing, and follow-up rules, then hands you a folder you can run from your own machine. No SaaS subscription, no vendor lock-in, no monthly platform fee — just the loop that moves money into your account.

Frequently asked questions

What is the cash-in loop for a solo founder business?

The cash-in loop is the minimum workflow that moves money into your bank account: generating quotes, converting them to invoices, sending those invoices, and chasing overdue payments. Solo founders often fail because they build branding, templates, and AI systems first while neglecting this loop. Six weeks in, they have no invoices sent and no revenue, despite plenty of setup work.

How do I set up Claude Code to run an invoicing business?

Create one project folder containing a CLAUDE.md file describing your business, clients, services, currency, and VAT rules. Add a clients.json and invoices.json for data, plus a templates folder with HTML files for quotes and invoices. Then add three slash commands in .claude/commands/: quote, invoice, and chase. No database, SaaS, or Zapier integrations are required.

Why does sequencing matter more than tooling for solo founders?

Sequencing matters because building elaborate systems before sending invoices means no money moves. Most solo founders fail not from lack of skill but from building everything except the revenue loop. Spending weeks on domains, Notion templates, and AI operating systems produces impressive structure but zero income. Building the cash-in loop first ensures the business generates revenue before optimizing anything else.

When should I use Claude Code instead of a CRM and invoicing SaaS stack?

Use Claude Code when you're a solo founder who wants one source of truth, no monthly platform fees, and fast setup. A typical CRM-plus-invoicing-plus-Zapier stack costs $80-$200 per month and takes about two weeks to configure across four tools. A Claude Code setup with markdown files and JSON data eliminates the platform tax and consolidates client data into one folder.

What do the quote, invoice, and chase slash commands do?

The quote command takes a client ID and line items, fills an HTML template, saves a PDF, and logs it to quotes.json. The invoice command converts a quote to an invoice, assigns the next number, calculates VAT, generates a PDF, updates invoices.json, and drafts an email. The chase command filters invoices.json for overdue items and drafts polite reminder emails referencing invoice number and days overdue.

Want more like this?

I publish practical AI automation, GenAI engineering, and faceless content workflows on YouTube every week.

Subscribe to bizflowai.io on YouTube — never miss a new tutorial.

Planning an AI automation project or need a second opinion on your architecture?

Connect with me on LinkedIn — Lazar Milicevic, GenAI Engineer & bizflowai.io Founder.

Visit bizflowai.io for our services, case studies, and AI consulting.