Table of contents

  1. How I Ship Side Projects in Hours Instead of Weeks
  2. The Setup
  3. The Dual-LLM Workflow (For Big Decisions)
  4. The Plugin System
  5. Superpowers (from superpowers-dev marketplace)
  6. Frontend Design (from claude-code-plugins marketplace)
  7. The Real Numbers
  8. The Meta Twist: Building Tools for the Tool
  9. What Doesn’t Work
  10. Getting Started
  11. The Actual Secret
How I Ship Side Projects in Hours Instead of Weeks How I Ship Side Projects in Hours Instead of Weeks

How I Ship Side Projects in Hours Instead of Weeks

11/Jan/2026 / 6 minutes to read / Tags: guide, ai

In the last three weeks, I’ve pushed ~800 million tokens through Claude Code across multiple projects and users on my server. If I were paying per-token, that would be around $600 USD.

But I’m not. I use a Claude Max subscription at $200/month - unlimited usage, no per-token billing. Even with this intensity, I’ve never hit a rate limit.

The result: 6 deployed applications, a completely revamped workflow, and a fundamental shift in how I think about building software.

The Setup

Hardware: A 33 euro/month Hetzner dedicated server (i7-7700, 64GB RAM, 8TB HDD) running Debian with Virtualmin.

The key insight: Claude Code works best when it has a real environment. Not a sandbox - a real server where it can install dependencies, configure services, hit APIs, and see actual errors. Virtualmin lets me spin up a new subdomain in 30 seconds, so every experiment gets its own isolated space.

What I built:

  • Banana Slides - AI presentation generator
  • AI Whiteboard - Infinite canvas for AI image generation
  • Meta Ads Dashboard - Marketing analytics with AI optimization
  • FB Comments Manager - Automated Facebook/Instagram comment management
  • Drive Dashboard - Google Drive report generator
  • Screenshot Uploader - Tool for sharing screenshots over SSH

But the projects aren’t the point. The workflow is.

The Dual-LLM Workflow (For Big Decisions)

For significant architectural decisions, I don’t use Claude Code alone. I use it alongside OpenAI’s Codex in a deliberate back-and-forth.

Phase 1: Architecture Discussion

Before writing any code on a big project, I describe it to both Claude and Codex. I paste Claude’s proposed architecture into Codex, get its critique, then bring that back to Claude. They debate until they converge on an approach.

This sounds slow. It’s not. It takes maybe 10-15 minutes and prevents hours of refactoring later. Two different models catch different blind spots.

Phase 2: Implementation

Once both LLMs agree on the architecture, Claude Code implements it with auto-proceed enabled. This is where most of the tokens go - iterative building, debugging, refining. I’m not babysitting every command; I let it run and check in periodically.

Phase 3: Code Review

After Claude finishes a major feature, I paste the code into Codex for review. Fresh eyes from a different model catches things Claude missed.

Important: I don’t do this for every task. Small features, bug fixes, quick scripts - those are just Claude Code on auto-proceed. The dual-LLM workflow is for when architecture actually matters.

The Plugin System

Claude Code has a plugin system that most people don’t use. I run two plugins from different marketplaces that fundamentally change how it operates:

Superpowers (from superpowers-dev marketplace)

14 specialized “skills” that enforce disciplined workflows. The one I use most: brainstorming.

Before any non-trivial implementation, the brainstorming skill forces exploration:

  • “What are we building?”
  • “What are the constraints?”
  • “What are three different approaches?”
  • “What are the tradeoffs?”

This prevents Claude from just diving into code. It means I actually think about what I’m building before building it.

Other skills I use regularly:

  • writing-plans - Creates detailed implementation plans before touching code
  • systematic-debugging - Structured debugging instead of random changes
  • verification-before-completion - Requires running actual verification commands before claiming something works
  • parallel-agents - Spawns multiple Claude instances for independent tasks

Frontend Design (from claude-code-plugins marketplace)

Specialized prompts for UI work. Generates distinctive, production-grade interfaces instead of generic Bootstrap-looking stuff.

The Real Numbers

My billing data from the last 3 weeks (just root user):

MetricValue
Total tokens283 million
Cost$217 USD
Heaviest day85M tokens ($45)
Models usedopus-4-5, haiku-4-5, sonnet-4-5

But that’s just one user. Each project on my server has its own user running Claude Code. Another user alone pushed 511 million tokens ($384) in 9 days.

Combined across users: ~800M tokens, ~$600 USD in 3 weeks.

And that’s probably conservative - some projects I haven’t checked.

The token count is high because I let Claude Code run on auto-proceed. It reads files, writes code, runs tests, sees errors, fixes them - each step is tokens. One debug cycle might be 5 API calls. A full feature might be hundreds.

The Meta Twist: Building Tools for the Tool

When you use Claude Code over SSH, you can’t paste screenshots. No way to show it a UI bug or error dialog.

So I asked Claude Code to build a tool that solves this. Now I have utilities for macOS and Windows that run in the background, detect new screenshots, upload them to the server instantly, and copy the remote path to my clipboard.

Screenshot → paste path → Claude sees it.

This is the mindset shift. When something about your workflow is annoying, you fix it. When the fix takes 20 minutes instead of 2 days, you actually do it.

The Screenshot Uploader exists because of how I use Claude Code. And Claude Code built it. The feedback loop creates its own productivity improvements.

What Doesn’t Work

Honest limitations after $600 worth of tokens:

  • Context limits are real. Long sessions lose track of earlier decisions. I keep a CLAUDE.md file in each project documenting architecture so new sessions start with context.

  • It makes mistakes. Wrong imports, deprecated APIs, logic errors. The dual-LLM workflow catches most of these on big projects, but you still need to read what it writes.

  • Vague prompts fail. “Make it better” doesn’t work. “Add pagination with 20 items per page and a loading state” does.

  • Legacy codebases are harder. Claude Code shines on greenfield. Dropping it into weird existing code takes more guidance.

  • Cost can add up (but doesn’t have to). Per-token pricing would have cost me $600 in 3 weeks. With Claude Max at $200/month flat, I pay the same regardless of usage. If you’re going heavy on Claude Code, the subscription pays for itself fast.

Getting Started

Minimum setup:

  1. A server you can SSH into (Hetzner, DigitalOcean, Raspberry Pi)
  2. Claude Code installed locally
  3. A domain with easy subdomain management

First steps:

  1. Install plugins - Superpowers from superpowers-dev marketplace enforces good habits
  2. Create a CLAUDE.md file in your project explaining the architecture
  3. Start with something small you actually need
  4. Enable auto-proceed and let it run
  5. Try the dual-LLM workflow when you’re planning something significant

The CLAUDE.md trick: This file in your project root gets read automatically. Document your tech stack, current state, and any conventions. Claude starts every session with context instead of asking “what framework are you using?”

The Actual Secret

It’s not about Claude Code being smart. It’s about workflow discipline.

The brainstorming plugin forces planning before coding. The dual-LLM approach (when used) forces architectural thinking. The real server environment gives immediate feedback. Auto-proceed removes the friction of approving every command. The CLAUDE.md file maintains context across sessions.

$200/month for unlimited tokens sounds expensive until you realize what I shipped. The speed comes from removing friction and adding structure in the right places.

Claude handles the typing. I handle the thinking. And occasionally, Codex tells us both we’re wrong.

← Back to blog