My Real Claude Code Workday: 6 Slash Commands, 45 Minutes

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

You spun up a SaaS over a weekend. Great. Now it's Monday and you've got support tickets, failed Stripe charges, three open bugs, an outbound pipeline that's gone cold, and a feature branch you haven't touched since Thursday. This is the part the courses never show you, and it's where most solo operators quietly drown.

The fix isn't more tools or a fleet of subagents. It's a tight daily ritual: six slash commands inside Claude Code, anchored to one CLAUDE.md per machine, that takes about 45 minutes of actual terminal time per day. Here's exactly how I run it across three live products from one laptop.

Why the daily loop, not the orchestration graph

I've tested the alternatives on client projects. Hiring a VA means training, supervision, and a quality floor you can't push past without paying senior rates. Stacking five SaaS tools means five dashboards, five subscriptions, and integration glue that breaks every time one of them ships a new API version. The trendy answer right now is "spin up 30 subagents in a graph" — looks great in a demo, dies on a Tuesday when one tool hits a rate limit and the whole DAG stalls.

What survives contact with a real workweek is a small set of commands you've run a hundred times. You know their failure modes. You know what they cost. You know how long they take. Boring is the point.

Here's the rough shape of my day before we go into each command:

Total active Claude Code time: roughly 45 minutes. The rest of the day is deep work, calls, or walking the dog.

The CLAUDE.md that holds the whole thing together

The commands are nothing without the file underneath them. My root CLAUDE.md is the single source of truth Claude reads on every invocation. It looks roughly like this:

# Operator profile
Name: Lazar
Timezone: Europe/Belgrade
Voice: direct, technical, no fluff. Short sentences. No exclamation marks.
Signature: "— Lazar"

# Active projects
## fakturko
  path: ~/code/fakturko
  stack: Next.js 14, Postgres, Stripe (EUR + RSD)
  conventions: see ~/code/fakturko/CLAUDE.md
  support_inbox: support@fakturko.app
  jurisdictions: RS, EU (reverse-charge VAT)

## una_intel
  path: ~/code/una_intel
  stack: Python 3.11, FastAPI, Telegram Bot API, Gmail API
  conventions: see ~/code/una_intel/CLAUDE.md
  support_inbox: hi@una-intel.com

## bizflow_catalyst
  path: ~/code/bizflow_catalyst
  stack: Node 20, Postgres, n8n workers
  conventions: see ~/code/bizflow_catalyst/CLAUDE.md
  support_inbox: ops@bizflowai.io

# Daily ritual
standup_inputs: [git_logs, stripe_dashboard, gmail_label:customer, gmail_label:urgent]
eod_outputs: ~/ops/logs/{YYYY-MM-DD}.md
priority_ranking: revenue_impact_desc

Each project also has its own CLAUDE.md with code conventions, the current spec-in-progress, and a small "tone bank" of past customer replies that Claude uses as voice reference. The slash commands are thin — they just point Claude at the right inputs and ask for a structured output. The intelligence lives in the context files.

08:30 — /standup: three minutes to know your day

This is the command nobody writes first, and it should be. The command file (~/.claude/commands/standup.md) is short:

Read the following and produce a morning brief:

1. Run `git log --since=yesterday --all --oneline` in each project path
   listed in ~/.claude/CLAUDE.md under "Active projects".
2. Fetch Stripe events from the last 24h via the CLI:
   `stripe events list --limit 50 --created.gte=$(date -d yesterday +%s)`
   Group by: succeeded charges, refunds, failed payments.
3. Read Gmail messages from the last 16h with labels: customer, urgent.
   Summarize subject + intent only, do not draft replies here.

Output format:
## Shipped yesterday
## Money moved (net, by project)
## On fire
## Proposed priorities (top 3, ranked by revenue impact)

End with: "Accept (y/n/override)?"

That's it. Claude reads three sources, compiles one brief, and proposes three priorities ranked by revenue impact — not by my mood, not by what looks fun. I either accept or override one. The override matters: I never let the loop run on rails. But 80% of the time, Claude's ranking is the right one because revenue impact is a more honest filter than I am at 8:30 AM.

09:00 — /triage: the inbox killer

The 90-minutes-of-inbox-grinding problem isn't volume. It's that every email forces a context switch into a different product, a different customer, a different emotional register. /triage collapses that.

Pull every unread message from:
- Gmail (across all 3 project support inboxes)
- Crisp chat transcripts from the last 16h
- Typeform/Tally submissions

For each message:
  - Classify intent: [refund, bug, feature_request, sales, billing, other]
  - Identify project from the destination address or URL
  - Draft a reply in operator voice (see CLAUDE.md "Voice" + project tone bank)
  - Score human_review_required: 0 or 1
    1 = refund > €50, legal/compliance, escalation, ambiguous bug

Output: a table with columns
[id, project, intent, draft_preview_80c, human_review]

After the table, dump full drafts in order. Drafts with human_review=0
get a "send" suggestion. I'll reply with the ids to send.

A typical morning: 14 messages in, 10 sent with a one-line send 1,3,4,5,7,9,11,12,13,14, 4 flagged for human review where I actually think and rewrite. Total time: about 10 minutes versus 90.

The tone bank is what makes the drafts not feel like AI replies. It's literally a voice/ folder per project containing 30-40 past replies I've written, with PII scrubbed. Claude matches register, length, and sign-off style. Customers haven't noticed.

What /triage will not do automatically

• Issue refunds (always human)
• Promise feature ETAs (always human)
• Reply to anything tagged legal or press
• Touch threads older than 4 days (those get flagged in /eod instead)

10:00 — /ship: the only hour of actual building

This is the only block where I'm writing production code. One hour, one project, one thing shipped. The command pulls the priority feature from the morning standup, opens the relevant files, and starts.

Read today's priority #1 from the morning standup output.
Open the corresponding project at the path from CLAUDE.md.
Load the spec from $PROJECT/specs/CURRENT.md.
Open the files referenced in the spec.
Print:
  - The spec summary (3 lines max)
  - The files now open
  - The first concrete change you propose, as a unified diff

Then wait for me to say "go" or paste corrections.

The win here isn't speed of typing. It's zero context-switch tax. I'm not opening three editors, hunting for where I left off, or re-reading my own code from Friday to remember the convention. The spec is already written (I write specs the night before in /eod), the files are open, and Claude has the project conventions memorized from the per-project CLAUDE.md.

Most days I ship one real thing: a feature, a migration, a fix. Not ten. One. Compounding across a year, that's enough to keep three products growing.

14:00 — /invoice and /leads: the money commands

After lunch, two commands back to back. These are the ones that pay for everything.

/invoice handles the billing side end-to-end:

For each project in CLAUDE.md:
  1. Query the billing DB for clients with status='due' or 'overdue'.
  2. For each, generate an invoice with the right tax handling:
     - RS clients: 20% PDV
     - EU B2B with VAT ID: reverse-charge, no VAT, add note
     - EU B2C: destination-country VAT
     - Non-EU: zero-rated, add export note
  3. Render PDF via the project's invoice template.
  4. Send via the project's configured SMTP.
  5. Log to ~/ops/accounting/{YYYY-MM}/invoices.jsonl

Report: invoices_sent, total_billed_eur, failures.

/leads runs outbound:

1. Pull new prospects from the sources in ~/ops/sources.yml
   (currently: Apollo saved search, GitHub stars on competitor repos,
    LinkedIn Sales Nav export).
2. Dedupe against ~/ops/crm/contacted.jsonl.
3. Score each: ICP fit (0-10), buying signal (0-10).
4. For score >= 14: draft a first-touch message referencing
   the specific signal (not a generic template).
5. Queue drafts in ~/ops/outbound/queue.md for my approval.

Report: prospects_pulled, qualified, drafts_queued, replies_today.

Both commands report numbers. Not "I sent some invoices." Actual counts: invoices_sent=7, total_billed_eur=4,820, failures=0. You see the business breathing in real time, and you catch problems the same day instead of at month-end.

17:30 — /eod: the audit trail that compounds

End of day. Five minutes. This command does three things that pay off weeks later:

1. Compile what shipped today (git log since 08:00 across all projects).
2. List open customer threads with age in hours.
3. Surface slow leaks:
   - Support threads open > 72h
   - Customers with 2+ failed payments in last 30d
   - Specs in any project marked "in_progress" untouched for 5+ days
4. Write tomorrow's spec for /ship priority #1 (draft, I'll edit).
5. Commit ~/ops/logs/{YYYY-MM-DD}.md to the private ops repo.

The audit trail is the underrated part. Six weeks from now when a client says "you broke X on the 12th," I can git log my own workday and find the exact commit, the support thread, and the decision I made. I've used this in three separate client disputes. It pays for itself the first time.

The "slow leaks" section is what keeps a one-person operation from rotting. Things you'd otherwise miss — the support thread that's been open 4 days, the customer whose card has failed three times — surface every single evening before they become churn.

Why bizflowai.io helps with this

This exact loop — CLAUDE.md per project, structured slash commands, Stripe and Gmail and CRM all reading from one operator context — is what we build into client setups at bizflowai.io. Most clients come in with three SaaS tools and a VA; they leave with a single command file they actually understand, an audit trail their accountant can read, and 30-40 hours a week back. The commands above are the literal template we start from.

Frequently asked questions

What is the daily Claude Code ritual for solo SaaS operators?

It's a roughly 45-minute daily loop built around six slash commands inside Claude Code, all anchored to a single CLAUDE.md file that knows every project you run. The commands cover standup, triage, shipping, invoicing, and lead generation, spread across morning, afternoon, and evening. The goal is to let one operator run a live SaaS without drowning in support, billing, and firefighting work.

How does the slash standup command work in Claude Code?

Run at 8:30 a.m., slash standup reads three sources: yesterday's git logs across every project folder, the Stripe dashboard for new charges, refunds, and failed payments, and Gmail messages tagged customer or urgent. Claude compiles a short brief covering what shipped, what money moved, and what's on fire, then proposes three priorities ranked by revenue impact. The whole review takes about three minutes.

How do I clear a customer support inbox faster as a solo founder?

Use a triage command that pulls every unread support email, customer reply, and form submission from the last 16 hours, then groups them by project and intent like refund, bug, feature, or sales. Claude drafts replies in your voice using a stored tone file and flags only the few messages needing a human decision. This cuts roughly 90 minutes of inbox work down to about 10 minutes.

Why does a daily ritual beat hiring a VA or using subagent armies?

VAs require training, stacked SaaS tools don't integrate well, and elaborate subagent orchestrations break when a single API rate-limits. A tight daily ritual run by one operator on one laptop survives contact with reality because it relies on a small set of trusted commands executed repeatedly. Consistency and a shared CLAUDE.md context make it more reliable than scaling out people or agents.

When should I use slash invoice versus slash leads?

Run both back-to-back around 2 p.m. Slash invoice handles the billing side: checking which clients owe money, generating invoices with jurisdiction-specific tax handling, sending them, and logging for accounting. Slash leads runs the outbound engine: pulling new prospects from defined sources, scoring them, drafting personalized first-touch messages, and queuing them for approval. Invoice covers money in; leads covers pipeline out.

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.