New: outcomized services. Pay per result, with a monthly cap you set. See pricing →
Engineering

How a Three-Person Studio Runs Seven Products on Claude Code Skills

Updated 2026-10 · 10 min read · By the Founder of Outcomizer, former CTO and co-founder

We are a three-person team running seven products, plus client work. We do not do that by working harder. We do it by writing down how every recurring task is done, once, as a Claude Code skill, and letting agents run the steps while humans verify the result. We have over thirty of these skills now, covering engineering, content, SEO, and operations.

This is how the system works, what we got wrong building it, and the rules that keep it from turning into a pile of prompts nobody trusts.

Not sure what to automate first?One week, $1,500, three fixed quotes. The fee is credited toward your build.

A skill is an SOP an agent can execute

A standard operating procedure has the same parts whether a person or an agent runs it: purpose, when to run, inputs, tools, numbered steps, a definition of done, common mistakes, and when to escalate. We write skills in exactly that shape. The difference from a wiki page is that the skill loads automatically when the task comes up, so nobody has to remember it exists.

Two writing rules matter most. Every step is an action verb, a specific object, and an expected result: exact field names, exact commands, exact checks. And unknowns are marked "to be decided, ask the owner" instead of being filled with a plausible guess. A skill with an invented step is worse than no skill, because it will be followed confidently.

One source of truth for tasks

Our rule is that a task not in the registry is not real work. One database holds task definitions: what it is, which product, who directs, executes, verifies, and ships it, the linked SOP, and a definition of done. Work in motion lives in a separate project tool. Definitions in one place, movement in another, and each has one job.

A task cannot be dispatched while it has no SOP. That single gate forced us to write procedures for the work we actually repeat, rather than the work we imagined we would. It also means a new task arrives with a brief complete enough that nobody needs to ask a question before starting.

Every definition of done has three to six checkable criteria, and anything invisible (analytics firing, DNS passing, schema validating) requires evidence on the card: a screenshot, a test result, a URL. "Write a good post" is not a criterion. "Meta description under 155 characters, checked on the live page" is.

Humans verify, agents never verify themselves

Every task has four slots: who decided it should exist, who executes, who verifies, who ships. The rule we never bend: an agent never verifies its own execution. Verification is always a person. Where the founder executes something, someone else runs the mechanical definition-of-done check on it. Reciprocity, not hierarchy.

Two flow rules keep this from clogging. Feedback goes in one numbered comment, and there is one round of changes; on round two the verifier ships it, edits it, or kills it. And when more than ten items are waiting for review, we stop dispatching new work, because the bottleneck is verification, not execution.

If you are not sure which of your recurring processes are worth turning into agent-run SOPs first, that is precisely what our AI Opportunity Audit ranks.

Not sure what to automate first?

One week, $1,500, three fixed quotes. The fee is credited toward your build.

See the AI Opportunity Audit

Research before planning, and kill criteria before building

Our planning skill does not start with a plan. It starts with research: competitors, community threads where users describe the problem in their own words, and our own analytics and search data. Then it runs a filter. Who specifically wants this? How will they find it? What do they use today? Can a v1 ship in under two weeks? Can we charge in month one? Does it compound?

If most answers are no, the skill says so. Killing a bad idea in an afternoon is the most valuable thing a planning process can do for a small team. When an idea passes, every plan names a specific success metric and a kill criterion up front, for example a signup target within fourteen days, so stopping is a decision we already made, not an argument we have later.

The two-week v1 limit is a forcing function. If it cannot ship in two weeks, we cut scope until it can. Most of what gets cut never comes back, and nobody misses it.

Automate anything done twice

The first time we do something by hand, we do it by hand. The second time, we write the skill. That rule is how thirty skills accumulated without a big "process project". Each one came from a session where someone finished real work and the agent offered to turn what just happened into a reusable procedure, with the session-specific values stripped out.

Skills stay generic. We never write one SOP per product; we write one SOP that loads the product's context document at step one. And skills hand off artifacts rather than calling each other: keyword research produces a list, the drafting skill consumes from it. That keeps each skill testable on its own.

Where this breaks, and what we would do differently

Skills rot when the tools underneath them change. An integration that changed behavior once broke two documents before we wrote the trap into the skill. We now treat any surprise from a tool as a skill bug: fix it in the skill the same day, so the next run inherits the fix.

Deviations are allowed, but they are surfaced in a weekly review and either merged into the SOP or dropped. The goal is consistent quality regardless of who or what executes, not maximum speed. Speed comes as a side effect of not redoing work.

Key takeaways

  • Write skills in SOP shape: purpose, trigger, inputs, exact steps, definition of done, escalation.
  • Keep one registry of task definitions. No SOP, no dispatch.
  • Agents execute, humans verify. Never let an agent sign off on its own work.
  • Research and set kill criteria before planning. Cap v1 at two weeks.
  • Do a task by hand once. The second time, write the skill.

Frequently asked questions

A packaged set of instructions, and optionally scripts and reference files, that Claude Code loads when a matching task comes up. Think of it as an SOP that an agent can read and follow.

Start with the three tasks you repeat most every week. We have over thirty now, but each one exists because the task came up at least twice.

No. We still use one for work in motion. Skills define how work is done; the registry defines what work exists; the project tool shows where each piece is right now.

Yes for the SOP discipline, which is most of the value. Writing and maintaining the skills themselves is easier with someone comfortable reading tool configs and debugging integrations.

Free playbook

The 15-Day AI MVP Playbook

Day-by-day plan, a starter CLAUDE.md, the Lovable-to-production checklist, eval and cost worksheets, and 10 prompts. Pure value, no pitch.

Get the playbook →
Next step

Book 20 minutes, or send a brief

A former CTO replies. You leave with a written plan and a fixed estimate.

No spam. One reply within one business day. Or skip the form and book a call.

Thank you. Your brief is on its way. Grab a time now so we can talk it through.

Prefer LinkedIn? Connect with Harish.

HG
Harish Ganapathi, Founder of Outcomizer, former CTO and co-founder

I started Outcomizer because hourly billing rewards the wrong thing. As a CTO I led an 18-engineer team and shipped the products in these case studies, including a Fortune 100 shipping system and a SaaS we later sold. Now I put my fee on the result. I still do the work. You work with me, not a sales layer on top of a bench.

Connect on LinkedIn →
Book a callFree lead test