How I run a one-person AI company on Claude Code

A one-person AI company works when you stop treating the model as a smarter autocomplete and start treating it as a workforce — a tiered one, with a cheap model running the main loop, a strong model doing the heavy execution, and you sitting at the top doing the one thing none of them can: judgment. Everything below is how that plays out on my actual machine, on an actual Tuesday.

I don't run a team. I run Claude Code as the hub, wire real tools into it, and keep a small set of habits that stop the whole thing from turning into confident garbage. Here's the setup, piece by piece.

Orchestrate cheap, execute strong

The rule that makes the economics work: don't run the biggest model for everything.

My main loop runs on a fast, cheap model. It does the thinking — decomposing a task, making the call on architecture, reviewing what comes back, talking to me, and handling the one-line edits where spawning a subagent would cost more than it saves. Heavy execution — multi-file implementation, deep debugging, long tool-call chains, refactors — gets delegated to a stronger model through subagents. Pure mechanical work — code search, bulk transforms, file inventories, doc lookups — goes to the smallest model that can still get it right.

What never gets delegated is judgment. The orchestrator always reviews a subagent's output before reporting anything done: reads the diff, spot-checks the claim, confirms the file actually says what the summary says it says.

This rule doesn't live in my head — it lives in my global instructions file, so every session on the machine inherits it automatically:

## Work process — orchestrate by difficulty, delegate to save the main loop

- Keep on the main loop: architecture/design decisions, deep single-threaded
  debugging, reviewing/synthesizing subagent results, final answers.
- Delegate (parallel) with model: sonnet — independent chunks that run
  concurrently: multi-file edits, per-item transforms, search-and-apply.
- Delegate (mechanical) with model: haiku — code search, file inventories,
  bulk find/replace, simple verifications, doc lookups.
- Always review delegated output before reporting done.

That last line is the one that actually matters. Delegation moves the typing. It never moves the responsibility.

Memory is a file, not a feeling

An AI session has zero continuity by default. Close the terminal and the model forgets your business existed. The fix isn't a bigger context window — it's writing things down, in the repo, in plain files, the same way you'd onboard a new hire instead of hoping they read your mind.

My setup has three layers:

• A root instructions file, read at the start of every session — who I am, how this machine is set up, the rules that never change.
• A memory directory, one fact per file, tagged by type: what's true about me (location, fiscal status, preferences), corrections I gave once that should stick, ongoing project state that isn't derivable from the code, and pointers to external systems I use.
• An index file, one line per memory, loaded every session so a fresh conversation can scan the state of my world in seconds and pull only what's relevant.

When something changes, the memory gets updated or deleted — wrong facts don't get left to rot, they get removed. That discipline is what turns a stateless model into something that compounds instead of resetting to zero every morning. Session fifty is dramatically more useful than session one, not because the model got smarter, but because the context did.

Skills are packaged workflows, not one-off prompts

Anything I find myself explaining for the third time gets turned into a skill — a named, reusable procedure the model can load on demand instead of me re-typing instructions from memory.

The ones I actually run, daily or weekly:

• A morning-planning skill that reads my calendar, my current priorities, and the state of active projects, and hands me the day's plan before I've had coffee.
• An end-of-session skill that persists new memory, refreshes the instructions file, and flags loose ends — uncommitted files, open pull requests, jobs still running. This one's open-source; anyone can install it.
• A full blog engine — write, rewrite, outline, brief, audit, schema, repurpose — scored against a rubric tuned for search rankings and AI-citation visibility.
• A video-package skill that transcribes a local video and generates the whole upload package: SEO titles, a ready-to-paste description, and thumbnails.
• Research skills that go from a quick lookup to a multi-source, fact-checked report with adversarial verification of the claims.

Installing one from the marketplace is two lines:

/plugin marketplace add Wecko-ai/claude-skills
/plugin install closing@wecko-skills

Skills are how a solo operator gets consistency. A freelancer's process usually lives in their head, applied a little differently every time, forgotten under deadline pressure. Written as a skill, it runs the same way at 9am or midnight.

MCP: the doors between the model and the real world

A model that can only read and write files in a repo is a fast intern locked in a room. MCP servers are the doors out of that room — they let the loop act on the systems a business actually runs on, not just describe what it would do if it could.

The ones wired into my daily loop: Google Calendar, so the model can read real commitments and plan around them instead of guessing; Gmail, for search, drafting, and labeling; Google Search Console, for traffic, quick wins, and content decay across the web properties I run; a research API for deep, sourced lookups with current information; and a messaging channel that lets me reach the whole setup from my phone — send a photo, get a structured answer back, no laptop required.

None of this replaces judgment about what to send or what to trust in a reply. It just means the model isn't limited to advising — it can check the calendar itself, draft the real email, pull the real numbers.

Verification is the whole safety net

Subagents are fast and they are confident. Confidence is not correctness, and the gap between the two is exactly where a one-person operation gets burned if nobody's watching.

So the habit is non-negotiable: read the diff before it merges. Spot-check the number before it goes in a report. Confirm the file actually exists before trusting a summary that says it does. This costs almost nothing compared to the alternative — shipping something confidently wrong to a client, or to production, because a subagent's report sounded plausible. It's the one step in the whole pipeline I refuse to delegate, and it's the reason the rest of this can run at machine speed without becoming reckless.

What this has actually built

None of this is theoretical. This workflow is how a zero-dependency CLI that detects the best local LLM for your machine got from idea to published npm package to a Homebrew tap in one sitting. It's how an open marketplace of Claude Code skills got built — the closing skill mentioned above was the first thing published to it. It's the same loop behind a rough-cut video pipeline that turns raw footage into a cut timeline, subtitles, and vertical shorts, a coaching bot that lives in Telegram, a note-syncing tool, and the content and SEO systems behind several web properties, each living in its own repo with its own instructions file so the assistant loads the right context the moment you switch directories.

The org chart is: a cheap model for judgment-light thinking, a strong model for execution, files for memory, skills for process, MCP for reach — and a human who never stops reading the diff.

Want this running in your own work

If any of this sounds like the gap between what your team wants AI to do and what it actually does day to day, that's exactly what I help close:

• AI integration — I audit how your team actually works and build the agents, automations, and RAG into it.
• Developer coaching — 1:1 or team coaching on this exact workflow: agentic coding, Claude Code, MCP, verification habits included.
• Build-with-AI training — hands-on workshops and cohorts that end with something live, not a slide deck.