Solo Stack Method: Run a Studio with AI Agents

Ten years running an independent studio in Taipei taught me one thing: the bottleneck is never the work. It’s the load of holding every decision in your head.

You know the shape. A client sends a brief Tuesday morning. You read it over breakfast, draft a quote in your head on the MRT, remember mid-meeting that last year’s similar job ran 40% over on retouching, forget to log the thought, and by Friday you’re rewriting the same quote for the third time.

Nothing on that list is hard. All of it together is what makes you the bottleneck.

The Solo Stack Method is how I stopped being that bottleneck. Not by hiring — by restructuring the studio into eight AI-run departments on a shared four-part operating system. Two years running this way. Working hours cut in half. Project volume doubled. Same operator.

Why AI tools alone don’t solve this

I’ve tried them all. ChatGPT for drafts. Zapier for connections. Notion AI for notes. Otter for meetings. Each solves a slice and adds a tab you have to remember to open.

Using an AI tool and running an AI-augmented workflow are two different jobs. A tool is something you pick up when you notice you need it. A workflow fires without you noticing. For a solo operator, the difference is whether you can leave for a week and still have quotes going out in your voice.

You don’t get there by collecting more tools. You get there by giving each department its own written operating instructions, in a format an agent can read and follow.

The four parts

My eight departments (proposals, invoicing, client updates, R&D, content, ops, sales-follow, weekly review) all run on the same stack:

1. Signal — what’s going on right now
2. Strategy — how we decide
3. Skill — how we execute
4. Ship — what “done” looks like

Skip any layer and the department leaks. Follow all four and it runs without you.

Signal — telling the agent what’s going on

Beginners skip Signal. They open Claude, type “write me a proposal for this client,” and wonder why the output feels generic.

The agent has no idea who this client is. It doesn’t know they signed a 15K NTD deal last year, complained about the invoice format, and told you their annual review budget lands in November. It doesn’t know your template omits the retainer clause under 30K.

Every department in my studio has a context/ folder: client history, current pipeline, past proposals, invoicing quirks, tone guidelines. The agent reads Signal first, before drafting anything.

My proposal agent reads three files at start:

• context/current-pipeline.md — who is warm, who is cold, what stage
• context/client-{name}.md — history and quirks for this client
• context/pricing-anchors.md — what we’ve charged for similar scopes

Without Signal, every proposal is a first draft.

Strategy — how the department decides

Strategy is where you write down the rules. The rules, not the vibes.

“When a client asks for a discount above 15%, offer a scope reduction instead” is a strategy. “Try to be helpful” isn’t. Strategy is what the agent reads at an edge case. Leave it vague and the agent falls back to whatever it saw in training, which won’t be your business.

My proposal department’s strategy.md covers about a dozen decisions I used to make ad-hoc: deposit terms, discount policy, when to walk away from an RFP, how to handle scope creep, when to insist on kickoff calls. Every rule has a one-line reason so the agent can generalize.

Writing Strategy down is the moment your business stops depending on you being awake.

Skill — the actual doing

Skill is what most people think agents are: the doing. In Claude Code terms, this is your SKILL.md, the procedure the agent follows.

A good SKILL.md isn’t a prompt. It’s closer to a handbook chapter:

• When to run — the trigger condition
• Inputs required — what needs to be in place
• Steps — a numbered procedure with branch points
• Output format — what the finished piece looks like
• Common failure modes — what to catch and how to recover

Working examples live in the claude-code-skill-stack repo.

A well-written skill file runs the same procedure at 2 AM as at 2 PM, whether you’re awake to supervise or not.

Ship — telling the agent what “done” is

Ship stops the agent from handing back half-finished work you have to redo.

The instinct is to say “make it good.” Never works. What works is defining, in the skill file, what “ready to send” looks like:

• Every quoted number cross-referenced against the pricing anchor
• Client name and address correct
• Deposit terms and payment method spelled out
• File named per the convention, saved to the right folder
• One-line summary logged to the pipeline so next month’s you-agent knows this happened

When Ship is defined, the agent verifies its own work. When Ship is undefined, you verify, which is the bottleneck you were trying to escape.

Why this is a method, not a stack of tools

Swap “Solo Stack” for any of the ten AI courses you’ve watched and most would list the same tools: Claude, a vector DB, some automation glue, a repo of prompts. Tools are commodities.

The four-part discipline of running every department through Signal → Strategy → Skill → Ship is not. That’s the method. It’s what makes an eight-agent studio work instead of turning into a graveyard of half-configured tools.

Two years in, my studio’s failure mode has changed. When something breaks, it’s almost always because I skipped a layer. Signal was stale. Strategy was ambiguous. Skill was a first draft. Ship was undefined. Fix the layer, fix the department. Fix the department, fix the week.

How to start next Monday

Pick your worst department. The one that leaks time, the one you dread Sunday night.

1. Write the Signal. Dump everything the agent would need into a context/ folder. Client history, pricing anchors, tone rules. If it feels silly, you’re doing it right. Goal: a smart new hire could run this department after reading only these files.
2. Write the Strategy. List every decision you make in this department. For each, write the rule and the reason. Aim for 10-20 on the first pass. Not perfect. Just written.
3. Write one Skill. Pick the single most repeated task. Write a SKILL.md that starts from Signal and Strategy and produces one specific output. Include Ship criteria at the bottom.

One department, one week. If the skill runs and the output survives your review, you’ve built the smallest working piece of the Method. Then repeat, seven more times.

---

If you want to see the working files, the claude-code-skill-stack repo has real SKILL.md files, real context folders, and post-mortems on what broke and why. Star it if it’s useful. That’s how I know what to publish next.

For the full library, weekly QA, and members debugging their own skill files with me, that lives in Solo Stack Studio, my Claude Code community. First cohort is free right now.

FAQ

Isn’t this just Claude Code with extra vocabulary?

Partly, yes. The Method uses Claude Code’s skill system as the execution layer. What it adds is the discipline of Signal and Strategy before Skill, and Ship after, so skill files don’t drift into first-draft territory. Without them, a SKILL.md is just a nicer prompt. With them, it’s a running department.

How many skills do I really need to start?

One. One working SKILL.md, running one repeated task, with Signal and Strategy behind it. If it survives a week of real use, add the second. Most operators try to write eight in one weekend and produce eight files that all break by Wednesday.

Does this work for non-technical solo founders?

Yes, with a caveat. You don’t need to code. You do need to be willing to write things down in Markdown, install Claude Code once, and edit text files. If those three feel unreasonable, this method isn’t for you, and honestly, no AI method is, yet.

What if my business is too unique for a shared method?

Every business feels unique until you write down its rules. The eight departments aren’t universal. The four-layer stack is. Your departments might be seven, nine, or five. Signal-Strategy-Skill-Ship stays the same.