Solo UnicornHow I Use AI to Manage Tech Debt Across Three Products — A Solo Multi-Product Survival Guide
How I Use AI to Manage Tech Debt Across Three Products — A Solo Multi-Product Survival Guide
On a Friday afternoon in August 2025, ArkTop AI's production environment started throwing a cascade of 500 errors. Two hours of debugging later, I found the culprit: a Python dependency (pydantic) had auto-upgraded from 1.x to 2.0, with a backwards-incompatible API. I hadn't pinned the version.
After fixing ArkTop AI, I instinctively checked JewelFlow's dependencies. Same problem — it just hadn't been triggered yet because JewelFlow hadn't been deployed that week.
That evening, I did the math: ArkTop AI runs Python + FastAPI, JewelFlow runs TypeScript + Next.js, and the Solo Unicorn Club bot system runs Python + Discord.py. Three tech stacks, three dependency trees, totaling over 400 direct dependencies and thousands of transitive ones. And the person managing all of this was just me.
That weekend, I started building an AI-driven tech debt management system. It's been running for six months. This article is the complete record — the exact setup, tool choices, and every pitfall along the way.
Context: Running Multiple Products Solo Means Tech Debt Is a Ticking Time Bomb
Tech debt isn't exclusive to big companies. One-person companies actually accumulate it faster — no code reviews, no QA process, and a breakneck development pace.
My three products' tech debt falls into three categories:
Dependency debt: Outdated package versions, unpatched known vulnerabilities, inconsistent version pinning. This is the most dangerous category — if you don't actively manage it, it surprises you one day.
Code debt: Hacks left over from feature rushes, duplicated code, missing type annotations, overly complex functions. None of it breaks current functionality, but the time cost of every change keeps creeping up.
Architecture debt: High module coupling, insufficient test coverage, too many manual steps in the deployment pipeline. This category is the slowest to pay down but has the greatest long-term impact.
All three products accumulating all three types of debt simultaneously. If managed entirely by hand, just monitoring dependency updates and code quality would eat 8–10 hours per week — not counting actual fix time.
Three Principles
Principle 1: Automate Dependency Management 100% — Zero Manual Intervention
Dependency updates are the most automation-friendly part of tech debt management — the rules are clear, the frequency is high, and doing it manually is mind-numbing.
I use Renovate (completely free) for automated dependency updates. Configuration:
- Patch and minor versions: Auto-create PRs; auto-merge when CI passes. I don't look at them, don't touch them.
- Major versions: Auto-create PRs but don't auto-merge. I spend 30 minutes every Friday batch-processing major updates across all three projects.
- Security vulnerability fixes: Regardless of version level, immediately create a PR and flag it as high priority.
Why Renovate over Dependabot? Both are free, but Renovate supports monorepos and unified cross-repo configuration. I manage update policies for all three projects with a single renovate.json. Dependabot can't do that.
Once this setup was running, dependency debt essentially shifted to "passive digestion" mode — I no longer need to manually check which packages are outdated. The system automatically keeps everything on the latest stable version.
Principle 2: AI Code Review Fills the "Second Pair of Eyes" Gap
The single biggest code quality risk for a one-person company is the absence of code review. You write code, you merge it yourself — blind spots are systemic.
I use CodeRabbit for AI code review. It triggers automatically on every PR — including my own code and the dependency update PRs created by Renovate.
CodeRabbit is free for open-source repos; the Pro plan for private repos is $24/user/month. All three of my products are private repos, but there's only one developer (me), so the monthly cost is $24.
Real-world experience:
What it's good at: Catching obvious bugs (null pointers, unhandled exceptions), flagging code style inconsistencies, detecting breaking changes after dependency updates, pointing out missing test cases. Roughly 60% of its comments are genuinely valuable.
What it's not good at: Business logic judgment. For example, if JewelFlow's pricing calculation logic changes, CodeRabbit can see the code changed but has no idea whether the new logic meets the business requirements. That part is always my responsibility.
An unexpected bonus: CodeRabbit's review history itself became living documentation. Three months later, when I revisited a module, the AI comments on the PR helped me quickly recall the original design decisions and potential risks.
Principle 3: Batch Your Debt Payoff — Don't Fix While You Build
If tech debt fixes get mixed into daily development, they'll never make it to the top of the priority list. My approach: every two weeks, I designate a full "debt payoff day" — no new features, only tech debt.
Debt payoff day workflow:
- Run
ruff check(Python projects) andeslint(TypeScript projects) to collect all warnings - Use Claude Code for automated refactoring — it can directly read code, modify code, and run tests. Typical tasks: splitting functions over 200 lines, adding type annotations, eliminating duplicate code
- Process backlogged major version dependency updates
- Update test cases, ensuring coverage stays above 70%
Claude Code's efficiency boost is most dramatic during refactoring. Previously, manually refactoring a complex function took 1–2 hours (modifying code + updating tests + verification). Now Claude Code can produce an initial refactored version in 10–15 minutes, and I spend 15–20 minutes reviewing and fine-tuning. A single debt payoff day now handles roughly 3x the workload it used to.
Tool Stack Breakdown
| Use Case | Tool | Monthly Cost | Why This One |
|---|---|---|---|
| Automated dependency updates | Renovate | $0 | Free, cross-repo unified config, auto-creates PRs |
| AI code review | CodeRabbit Pro | $24/month | Auto-reviews every PR, excellent private repo support |
| Code refactoring + tech debt fixes | Claude Code (Max plan) | ~$20/month amortized | Reads code, modifies code, runs tests directly — 3x refactoring efficiency |
| Static analysis (Python) | ruff | $0 | Fast, comprehensive rules, replaces flake8 + black |
| Static analysis (TypeScript) | eslint + prettier | $0 | Community standard |
| Security vulnerability scanning | Snyk (free plan) | $0 | 200 open-source tests/month is sufficient, supplements Renovate's security checks |
| CI/CD | GitHub Actions | $0 (free tier) | CI for all three projects runs here |
| Total | ~$44/month |
Why not heavier solutions? Qodo (formerly CodiumAI) and Zencoder offer more features but cost $50–$100/user/month — an unreasonable investment for one person managing three small products. This current combination covers 90% of my needs.
Results
System has been live since September 2025 — six months of data:
Dependency management:
- Total PRs auto-created by Renovate: 287
- Auto-merged (patch/minor + CI pass): 241 (84%)
- Major updates requiring manual handling: 46
- Security vulnerability fix PRs: 12 (all merged within 24 hours)
- Zero dependency-related production incidents in six months
Code quality:
- Total review comments from CodeRabbit: ~480
- Comments I accepted and acted on: ~290 (60%)
- Average test coverage across three projects: up from 52% to 74%
- Average function length: down from 45 lines to 28 lines
Time investment:
- Weekly time on tech debt management: down from 8–10 hours to 3 hours
- Debt payoff day throughput: 12–18 items per session (previously 4–6)
Production stability:
- Dependency-related production incidents: down from 4 in the six months before to 0
- Deployment rollbacks: down from 1.5/month average to 0.3/month
Lessons from the Trenches
Pitfall 1: Renovate's auto-merge nearly introduced a breaking change
One time, Renovate auto-merged a minor version update (an npm package from 4.2.1 to 4.3.0). CI tests all passed green. But the package had changed a method's default parameter, causing JewelFlow's report generation output to silently differ from before. CI tests didn't cover that edge case.
Lesson: Auto-merging is only safe when test coverage is high enough. My rule now: dependency updates related to modules with less than 60% test coverage don't get auto-merged.
Pitfall 2: CodeRabbit's false positives caused review fatigue
In the first month, CodeRabbit averaged 15–20 comments per PR, more than half of which were style suggestions (variable naming, comment formatting). Review fatigue set in fast — I started skipping AI comments entirely, making the tool pointless.
Fix: I adjusted CodeRabbit's config to severity "medium" and above, keeping only bug, security, and performance-related comments while muting everything style-related. Comments dropped to 4–6 per PR, each one worth reading.
Pitfall 3: Claude Code occasionally altered business logic during refactoring
While having Claude Code split a 180-line function, it "helpfully" optimized a pricing calculation — changing standard rounding to banker's rounding. If I hadn't carefully reviewed the diff, this change would have directly affected customer invoices.
Lesson: After AI refactoring, you must review the diff line by line — especially code involving monetary calculations, permission checks, and data transformations. This is the non-negotiable line of "humans lead."
Advice for Getting Started
Step 1: Install Renovate first. 10-minute setup, immediate results. Automate away the most boring yet most dangerous task in your codebase — dependency management.
Step 2: Add CodeRabbit to your projects. Free for open-source. $24/month for private repos. Use it for a month and count how many of its comments flag things you would have missed in your own review — that's its value.
Step 3: Schedule a debt payoff day every two weeks. Don't wait until something breaks to remember tech debt exists. Tech debt compounds like financial debt. Regular small payments are always cheaper than letting it pile up until the system collapses.
Final Thoughts
Managing tech debt across multiple products as a one-person company is fundamentally an attention allocation problem. Your attention is a scarce resource — it should go toward business decisions and product direction, not toward checking dependency versions and fixing lint warnings.
$44/month, and three products' tech debt went from spiraling out of control to a predictable, manageable routine. It's not that tech debt disappeared — it never does — but I'm no longer the one being chased by it.
Several indie product builders in the Solo Unicorn Club share the same fear: not a lack of users, but code that's rotted to the point where even the creator is afraid to touch it. Tech debt management isn't glamorous, but it's the foundation that keeps a product alive long-term.
How much tech debt does your product have right now? Do you have a regular cadence for paying it down?