I Cancelled $380/mo of SaaS With 3 Folders in Claude Code

By Lazar Milicevic · Published June 17, 2026 · 10 min read

Four logins. Four monthly bills. Zero shared data. That was my agency stack last quarter — CRM, scheduler, invoice tool, notes app — and the only thing they had in common was my credit card. I replaced all four with three folders on my home server and around 150 lines of context per folder. Here's exactly how the setup works, what it can't do, and where the real leverage hides.

The actual problem isn't the tools, it's the handoffs

Every solopreneur I talk to has the same shape of stack:

The cost isn't really $380/mo. The cost is the copy-paste tax between them. Lead comes in via email → you paste into CRM. Lead asks for a call → you paste email into scheduler. Call happens → you paste notes into the CRM and the notes app. Project closes → you paste address into the invoice tool. Every handoff is two to four hours a day of manual work, and every manual handoff is where the wrong invoice number gets sent and the follow-up gets missed.

The standard YouTube answer is to buy a $497 course, build an "AI operating system", spin up a subagent army, and follow a 30-day challenge. I tried versions of that for a month. It's productized confusion. What actually works is much smaller.

Three folders. That's the whole architecture.

On my PC-PC home server I have a single parent directory. Inside it, three folders:

~/ops/
├── client-ops/      # One subfolder per active client
│   ├── acme-corp/
│   │   ├── brief.md
│   │   ├── deliverables/
│   │   └── log.md
│   └── beta-llc/
├── agency-ops/      # Back office: leads, invoices, proposals
│   ├── CLAUDE.md
│   ├── leads.md
│   ├── invoices/
│   ├── proposals/
│   └── calendar.md
└── content-ops/     # Outward-facing: posts, scripts, marketing
    ├── CLAUDE.md
    └── linkedin/

That's it. If a task doesn't fit into one of those three buckets, it's probably not a task I should be doing. The classification rule is also the prioritization rule.

The mental model:

• client-ops — anything billable and engagement-specific
• agency-ops — anything that keeps the business running
• content-ops — anything outward-facing that's not for one specific client

The CLAUDE.md file is the brain (and the leverage)

Inside each folder lives one file: CLAUDE.md. Around 150 lines. Claude Code reads it automatically when I cd into that folder. It tells Claude four things, in this order:

1. What this folder is for, in plain language
2. The commands I run most often and what they should do
3. The guardrails — don't touch these files, never send email without confirmation, always log actions
4. The output format I expect, so responses look identical every time

Here's a trimmed version of my agency-ops/CLAUDE.md:

# agency-ops — back office for the agency

## Purpose
This folder runs the business behind the work. Leads, proposals, 
invoices, contracts, follow-ups. Not client deliverables.

## Key files
- leads.md          → pipeline table (name, source, status, last_touch, next_action)
- invoices/         → one .md per invoice, generated from template.md
- proposals/        → one folder per prospect
- calendar.md       → mirror of upcoming Google Calendar events

## Commands
- /daily-brief    → read last 24h of Gmail (label:agency), check calendar,
                    scan invoices/ for overdue, list 3 priorities
- /new-lead       → parse forwarded email, append row to leads.md
- /invoice <client> → render invoices/template.md with client data, output PDF
- /follow-up      → for any lead with last_touch > 5 days and status=warm,
                    draft a follow-up email (DO NOT SEND)

## Guardrails
- Never send email. Draft only. I send manually.
- Never modify invoices/sent/*.md — those are immutable records.
- Always append, never overwrite, in leads.md.
- Log every action to ./log.md with timestamp.

## Output format
- Daily brief: one page, 3 sections (REPLY / SEND / BLOCKED).
- Email drafts: subject line + body, no preamble.
- Invoice generation: confirm client + amount before rendering.

That's the whole structure. Context, commands, guardrails, format. No framework, no subagents, no orchestration layer.

Why this beats prompting from scratch

• You write the file once and refine it over a week
• Every command in that folder behaves the same way next month as it did today
• New tasks become new slash commands, not new prompts
• The guardrails are enforced by the file, not by my memory at 7am

What a morning actually looks like

$ cd ~/ops/agency-ops
$ claude
> /daily-brief

In about 40 seconds Claude reads the relevant Gmail threads from the last 24 hours (via an MCP connector), checks today's calendar, scans invoices/ for anything past due, looks at active proposals, and writes one page:

REPLY (3)
- Marko @ Fakturko: wants timeline change → propose Fri call
- Jana @ DSP: contract clarification on clause 4
- Stefan: asked for case study link

SEND (2)
- Invoice #2041 to Acme (overdue 6 days)
- Proposal v2 to BetaLLC (promised Monday)

BLOCKED (1)
- Waiting on logo assets from Gamma to ship landing page

I read it with coffee. Five minutes. The same triage used to take 40 minutes across four tabs.

How each killed SaaS got replaced

This is the part people get wrong — they think you need a fancy replacement. You don't. Every replacement is boring. Boring is what runs in production.

Total killed: ~$160/mo on the listed plans, $380/mo once you add the team seat upgrades and the Zapier integration tax I was paying to make them talk to each other.

The /invoice command in full:

# Inside agency-ops/
$ claude
> /invoice acme-corp 2400

Confirming:
- Client: Acme Corp (from leads.md row 14)
- Amount: €2400
- Due: 14 days
- Invoice #: 2042 (next in sequence)

Proceed? y/n
> y

✓ Rendered invoices/2042-acme-corp.md
✓ Generated invoices/2042-acme-corp.pdf
✓ Logged to log.md

That's the whole tool. ~80 lines of Markdown template, ~30 lines of bash for the pandoc step, and a slash command. It does exactly what FreshBooks did for me, minus the dashboard I never looked at.

Where this stack breaks (and where I still pay for SaaS)

I need to be honest about the limits, because nobody else will tell you. Claude Code is bad at two things: anything real-time, and anything client-facing.

It will not be:

• A customer-facing chat widget
• A booking page a client logs into
• A dashboard a client sees
• A status page
• Anything with a public URL and an SLA

For those, I still pay for SaaS, and I should. The rule I use:

If a human outside my company needs to interact with it, that's SaaS territory. If it's internal ops — paperwork, prep, follow-up, drafting, reporting — that's Claude Code territory.

That single sentence decided every cancellation. The CRM, scheduler, invoice tool, and notes app were all internal-facing for me. The landing page, the public booking link for cold leads, and the contract-signing tool stay on SaaS. I didn't try to be a hero about it.

The leverage isn't the AI. It's the file.

The reason this stack works isn't that Claude is smarter than HubSpot. It's that the CLAUDE.md file is leverage you build once and reuse forever.

• You're not prompting from scratch every morning
• You're not re-explaining your invoice format every time
• You're not hoping the model remembers the guardrails
• You're running a deterministic system you defined in 150 lines

Compare the build cost to a real SaaS migration:

The 90 minutes is real. I timed the rebuild on a fresh machine last month: 22 minutes for the folder structure and templates, 38 minutes for the three CLAUDE.md files, 28 minutes wiring up the Gmail and Calendar MCP connectors. Two hours including a coffee break.

Why bizflowai.io helps with this

This is exactly the kind of internal-ops automation I build for clients at bizflowai.io — replacing SaaS sprawl with a small set of folders, context files, and slash commands that match how the business already works. Most engagements start with auditing which subscriptions are doing real customer-facing work versus which are just expensive copy-paste destinations, then porting the copy-paste category into a CLAUDE.md-driven workflow the owner can actually maintain themselves.

Try it before you cancel anything

Don't cancel your SaaS tomorrow. Do this instead:

1. Pick your three folders. Probably client-ops, agency-ops, content-ops, or close variants.
2. Write a 150-line CLAUDE.md for each. Context, commands, guardrails, format.
3. Define five slash commands you'd actually use every day. Not ten. Five.
4. Run it for one week in parallel with your SaaS.
5. Cancel only what the folders fully replaced. Keep the rest.

If you're sitting at three or four subscriptions that don't talk to each other, you don't need a course. You need an afternoon.

Frequently asked questions

What is the three-folder Claude Code setup for replacing SaaS tools?

It's a minimal solopreneur ops system using three folders on a home server: client-ops (active client work), agency-ops (back office like leads, invoices, proposals), and content-ops (marketing and outward content). Each folder contains a single CLAUDE.md file of about 150 lines that defines context, commands, guardrails, and output format. Setup takes around 90 minutes and replaces a CRM, scheduler, invoicing tool, and notes app.

How do I replace a CRM, scheduler, and invoicing tool with Claude Code?

Replace the CRM with a leads.md table tracking name, source, status, last touch, and next action, updated when you forward emails to the folder. Replace the scheduler with a calendar.md plus a script connecting to Google Calendar so Claude drafts slots and confirmations. Replace invoicing with a Markdown template and a command that pulls client data to generate a PDF. Replace notes with per-client log files in client-ops.

Why does manual copy-paste between SaaS tools matter for solopreneurs?

Running a CRM, scheduler, invoicing tool, and notes app separately means every handoff — lead email to scheduler, call notes to CRM, address to invoice — is manual. Each manual step introduces errors like wrong invoice numbers, missed follow-ups, and double bookings. This copy-paste tax costs solopreneurs two to four hours per day plus around $380 per month in subscription fees, with no shared data between tools.

When should I use Claude Code vs SaaS tools?

Use Claude Code for internal operations: paperwork, prep, follow-ups, drafting, and reporting. Use SaaS when a human outside your company needs to interact with the tool. Claude Code is bad at real-time and client-facing work — it can't power a customer chat widget, a booking page, or a client-facing dashboard. The simple rule: external interaction means SaaS, internal ops means Claude Code.

What should a CLAUDE.md file contain?

A CLAUDE.md file is roughly 150 lines and defines four things: the folder's purpose in plain language, the commands you run most often and what they should do, guardrails (files not to touch, requiring confirmation before sending email, logging actions), and the expected output format so responses stay consistent. This structure — context, commands, guardrails, format — acts as the brain for each folder without requiring a framework.

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.