How to Run a Design Studio Solo with Claude Code + Higgsfield MCP

For years the hard part of running a web-design studio was never finding clients. It was delivery. Someone had to design every layout, build every page, and produce every piece of media. In the old model that meant hiring - a designer, a front-end dev, someone to shoot or license the visuals.

Every hire ate the margin, and the more clients you took, the more people you needed.

That's the part that just changed.

The production layer now runs on models instead of headcount, and one person can carry the load that used to take a small team. This is the playbook for running the whole thing solo - with Claude Code as the build engine and Higgsfield MCP as the media engine.

The offer: sell a product, not custom work

Most people kill the solo model before they start.

They sell "whatever you need." Every project becomes a snowflake, nothing systemizes, and you've built yourself a job you hate.

If you want to run solo, there's one rule: the work has to be deliverable by a system, not by heroics.

That means productized and scoped tight.

What you sell: a done-for-you site plus a monthly retainer for updates, new pages, and maintenance.

The one-time build gets you in the door. The retainer turns one-off projects into recurring revenue - the only way solo math actually works.

What you don't sell: anything that needs a human grinding for a week straight. If a scope can't route cleanly through the system, reshape it or pass on it.

The stack

Every site flows through the same pipeline. You personally touch two stages - the start and the end. The models handle the heavy middle.

1. Fable 5 - the design engine

Fable takes a brief and produces the design system: layouts, components, responsive states, the visual language. This is the part that used to need a designer in Figma for a week. You feed it the brand, the pages, the vibe; it outputs the structure. Your job is direction and taste, not pixel-pushing.

2. Claude Code - the build engine

The approved design goes to Claude Code, which writes the actual site: components, responsive CSS, animations, form logic, CMS wiring, deploy. This is where the front-end dev used to live.

Claude Code builds it; you review against the spec. Reviewing finished work is far faster than producing it - which is exactly why one person can carry several clients' builds at once.

3. Higgsfield MCP - the media engine

Every site needs visuals: a hero video, product shots, motion, avatar spots for landing pages. Instead of a shoot or stock licenses, Higgsfield generates them from prompts. And with the MCP connector, your agent reaches them without leaving the chat - it plans, generates, and pulls the finished clips straight into the build.

Higgsfield MCP in action - the real workflow

This is the piece that makes the whole thing run solo, so here's exactly how it works.

Connect it once. In your agent's settings, add a custom connector and paste one URL. OAuth sign-in, no API keys to manage.

That single connection unlocks 30+ models (Sora 2, Veo 3.1, Kling 3.0, Seedance 2.0, GPT Image 2, Nano Banana Pro, Soul 2.0), and the agent picks the right one per shot.

mcp_servers:
  higgsfield:
    url: "https://mcp.higgsfield.ai/mcp"

Then just describe the shot. Inside Claude you type the brief in plain language, and the agent fires the generation on Higgsfield, chooses the model, and brings the finished clip back into the conversation.

A real prompt looks like this:

Using Higgsfield, generate this as a video — 16:9, ~6 seconds, high quality. Pick the best model for cinematic stylized motion:
Cinematic anime / hand-painted style animated shot, soft cel-shading, luminous painterly watercolor backgrounds, gentle sense of wonder (no logos, no text).
Scene: a lone monk in a bright orange robe stands calmly in a small wooden boat, drifting on glassy turquoise water through a narrow misty gorge. A colossal ancient stone Buddha face is carved into the mossy cliff wall, half-reclaimed by lush green jungle, half-lit by warm golden morning light. Soft god-rays pierce the drifting mist; tiny fireflies of light float in the air.
Motion: slow cinematic push-in toward the Buddha face; mist rolls and curls slowly across the water; gentle ripples and mirror-like reflections shimmer; leaves and vines sway softly; the boat drifts forward almost imperceptibly. Calm, meditative, dreamlike pacing.
Look: painterly anime aesthetic, hand-drawn texture, soft rim light, warm-vs-teal contrast, subtle film grain, atmospheric depth. Smooth and floating, no camera shake.

Product shots, transitions, motion loops, avatar spots - all from prompts, all in one place. The toolkit does more than raw generation, too: it can turn any reference clip into a ready-to-run prompt, build a marketing video from a product page, train a consistent character, cut a long clip into shorts, and score a hook before you post.

For context: commissioning a single short UGC-style spot from a freelancer typically runs $150-$500 for 30 seconds. The MCP outputs a batch for a subscription. That's the difference between a four-figure media line item per client and a rounding error.

The Claude Code build loop, step by step

Between "design approved" and "site live," here's the loop.

Step 1 - Feed the spec. Drop the Fable 5 design system, the client brief, and the full page list into Claude Code as one prompt.

Step 2 - Scaffold first. It generates the folder structure and component tree before writing a page. You're reading it, not producing it.

Step 3 - Build component by component. Prompt section by section: nav, hero, pricing, footer - each referencing the Fable design tokens.

Step 4 - Wire the logic. Forms, CMS fields, animations, responsive breakpoints, in one pass.

Step 5 - Review against the spec, not your taste. A missing breakpoint or CMS field is a prompt back, not a manual patch.

Step 6 - Deploy. Push to your host, connect the domain, done - fully scripted after your first few clients.

Six steps. You're the reviewer, not the coder.

What the output actually looks like

Prompt Claude Code for one interaction - a copy-to-clipboard button that confirms with a quick state change - and this is roughly what comes back:

function CopyButton({ text }) {
  const [copied, setCopied] = useState(false);

  const handleCopy = async () => {
    await navigator.clipboard.writeText(text);
    setCopied(true);
    setTimeout(() => setCopied(false), 1500);
  };

  return (
    <button onClick={handleCopy} className={`copy-btn ${copied ? "copied" : ""}`}>
      {copied ? "Copied ✓" : "Copy"}
    </button>
  );
}

.copy-btn {
  transition: background 0.2s ease, transform 0.15s ease;
}
.copy-btn.copied {
  background: #16a34a;
  transform: scale(1.05);
}

You ask for the interaction in one line; Claude Code writes the state logic and the transition; you click once to confirm it fires and reverts after 1.5s, and it ships.

That's the whole loop in miniature.

The delivery pipeline

Intake (you, ~15 min): turn the client request into a clear spec. Judgment work - where the value lives.

Design (Fable 5): produces the system from the spec.

Build + media (Claude Code + Higgsfield MCP, in parallel): the site gets built while the visuals get generated.

QA + handoff (you, ~20 min): review, deploy, document, notify - mostly templated after the first few.

The two stages that need a human - intake and QA - are the fast ones.

The slow, labor-heavy middle is the one you removed yourself from. You went from laborer to orchestrator.

The unit economics (illustrative)

Treat these as a model - plug in your own real numbers before you quote them anywhere. Monthly cost to deliver, one solo operator:

• Design engine subscription: ~$40

• Build engine (heavy usage across clients): ~$200–$300

• Higgsfield subscription: ~$40

• Hosting, domains, CMS: ~$150

• Other SaaS (CRM, scheduling, comms): ~$180

Roughly $750/month in total delivery cost.

The margin isn't high because you're clever about pricing - it's high because the cost of delivering the work fell through the floor while the value clients pay for stayed the same.

You pocket the spread.

Filling the pipeline

Post the work. Before/afters, "here's a site I shipped in 3 days," case studies with real outcomes. The right clients self-select.

Show speed.

Concept to live site in days instead of weeks is the pitch. Prove it publicly.

Sell the retainer, not the build.

The one-time site gets you in; the monthly relationship is the business.