5 Months Running a One-Person SaaS on Claude Code — What Stuck, What Got Turned Off

Source: raw/reddit-1uxa0xw.md — u/indie_zack on r/ClaudeCode, “5 months running a one-man SaaS on Claude Code: what stuck and what I turned off” (score 109, 31 comments, posted 2026-07-15).

A solo operator runs a small hosted SaaS (~4,200 commits over 5 months) where Claude Code writes most of the code and also handles day-to-day operations — deploys, server monitoring, support-reply drafting, SEO pages, monthly bookkeeping. The post is framed around the inverse of the usual “here’s my setup” thread: what did the author turn OFF, not what did they turn on. Five distinct techniques compounded into the current setup; this article preserves them as one field report rather than fragmenting the source across the wiki’s several related hub articles (see Related), since the “what stuck / what got turned off” framing is itself the interesting angle and would be lost if broken apart.

Key Takeaways

• Git worktrees are explicitly turned OFF, against the standard advice. The usual answer for running parallel Claude Code sessions is worktrees; this operator blocks the tool outright with a PreToolUse hook. Reasoning: deploys happen by pushing to main, some sessions run unattended overnight, and an agent allowed to create branches will eventually park important work on one that gets found days later. A CLAUDE.md instruction against worktrees got ignored once context filled up; a hook can’t be ignored because it fires deterministically outside the model’s context. Parallelism instead comes from subagents doing research/review work, with a single writer on the one checkout.
• 82 skills, each one a repeated mistake caught a second time. Skills cover deploy, code review, refund flow, support-reply drafting, and weekly usage reports. The framing is explicitly reactive, not proactive tooling-for-its-own-sake — each skill exists because something went wrong or got repeated once already.
• A 427-file “mistake ledger.” The memory directory holds 427 small markdown files, one fact each, roughly half of them “never do X again” notes written minutes after a mistake happened. The author’s framing: CLAUDE.md gets you through week one, but the accumulated per-mistake ledger is why month five feels qualitatively different from week one.
• Interrupt-only-when-needed, not always-on notification. Unattended overnight sessions run scoped audit/maintenance jobs. A hook sends a Telegram ping only when a session actually needs the human — the author stopped checking in proactively and lets the hook interrupt instead. Deploys still explicitly wait for morning review regardless of what the overnight session concluded.
• Cross-vendor code review as a deploy gate, with a concrete caught bug. Nothing deploys until a model from a different vendor than the one that wrote the code reviews the diff, and then a fresh subagent checks the fix. The stated reasoning: same-model review tended to repeat the original model’s own reasoning rather than catch what it missed. The cross-model pass caught a missing tenant-scoping condition in an account query before it shipped — a concrete instance of the abstract “different model, harder to fool” argument.
• A human still sends every customer-facing email. Claude drafts every one; a human sends every one — including, by the author’s account, this Reddit post itself, which they say they rewrote substantially because Claude’s first draft “sounded like a LinkedIn guy.”

Why the Framing Matters

Most Claude Code setup threads are additive — what did you install, what’s your stack. This one is subtractive: five months and ~4,200 commits in, the interesting information is what got actively disabled despite being the standard-advice default (worktrees), and what compounded into necessity despite starting as ad hoc (skills, the mistake ledger). The worktree reversal is the sharpest data point, because it’s a direct rebuttal to a common piece of Claude Code advice, grounded in a specific failure mode (unattended-session branch-parking) rather than a general preference.

Try It

• If you run unattended or overnight Claude Code sessions that deploy by pushing to main, consider whether worktrees are actually safe for your setup, or whether a PreToolUse hook blocking the worktree tool closes a real gap the way it did here — CLAUDE.md instructions are advisory and get dropped under context pressure; hooks are not.
• Start a per-mistake memory file the next time Claude repeats an error, even before you have 427 of them — one fact per file, written within minutes of the mistake, is the concrete mechanic behind this operator’s “month five feels different” claim.
• If you deploy AI-generated code without human review, add a cross-vendor review gate before the merge, not just a same-model self-review pass — the caught tenant-scoping bug is the concrete argument for why the vendor has to differ.
• Scope your notification hooks to interrupt-when-needed rather than notify-always if you run unattended sessions and are prone to checking in reflexively anyway.

Related

• Agent Guardrails: Hooks, Permissions, and Sandboxing Patterns — the general reference for PreToolUse-hook-as-hard-block and deterministic-vs-advisory enforcement; this article’s worktree-blocking hook is a concrete field example of that pattern in production, not a restatement of the reference itself.
• Verifier-First Loops — the cross-model review gate here (a different vendor reviews, then a fresh subagent checks the fix) is a live example of that article’s “give your evaluator a different model” principle catching a real, specific bug rather than a hypothetical one.
• agent-skills (Addy Osmani) and Building Skills Guide — general skill-authoring references; this operator’s 82-skill count and “each one is a caught repeat mistake” framing is a concrete data point for how a skill library grows organically under real production use.
• Claude Code Memory Architecture Comparison and Auto-Memory — general memory-pattern references; the 427-file one-fact-per-file mistake ledger is a distinct, more granular pattern than either describes in the abstract.
• Claude Code Channels — background on remote/relayed notification mechanics; this operator’s Telegram-interrupt-only-when-needed hook is a narrower, single-purpose version of the same idea, and the parallelism this operator gets from subagents (rather than worktrees) against one writer checkout is the same substitution.
• Agentic Coding and Returns to Expertise — the “a human sends every customer email, and rewrote most of this very post” detail is a concrete instance of that piece’s thesis that judgment and voice remain human work even at high automation.

Open Questions

• The post doesn’t specify which two model vendors are paired in the cross-model review gate, only that they differ — worth a follow-up if the 31-comment thread surfaces the specific pairing.
• No detail on how the 427-file memory directory is organized or retrieved at runtime (one flat folder? indexed? loaded in full into context?) — the source states the count and the “one fact each” convention but not the retrieval mechanism.
• This is a single, self-reported field account (109 upvotes, 31 comments) with no independent verification of the ~4,200-commit or 82-skill figures beyond the author’s own claims.