How to Run a $35K/Month Web-Design Agency Solo With Fable 5 + Higgsfield

A staffed web-design shop at $35k/month keeps maybe $10k after payroll. A solo operator running the same revenue on a three-tool stack keeps closer to $34k

Same clients. Same deliverables. The only thing that changed is who does the production work.

The bottleneck was never getting clients. It was delivery. Someone had to design, build, and ship every site. In the old model that meant hiring: a designer, a front-end dev, someone to manage them. Every hire ate the margin. Now the production layer runs on models instead of people, and one person can carry the load of five.

The offer: sell a product, not custom work

Most people kill the solo model before they start. They sell "whatever you need." Every project is a snowflake, nothing systemizes, and you've built a job you hate.

If you want to run solo, 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 retainer turns one-off builds into recurring revenue, which is the only way solo math works.
• How you price it: anchor clients on $2,500-$5,000/mo, core clients on $1,500/mo, lite maintenance on $750. A mix of 12-14 clients lands you at $35k MRR.
• What you don't sell: anything that needs a human grinding 40 hours. If a scope can't route cleanly to a system, reshape it or pass.

The three-tool stack

Every site flows through the same pipeline. You personally touch two stages. The models handle the 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 sitting in Figma for a week. You feed it the client's brand, the pages, the vibe, and it outputs the structure you build on. Your job here 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, deploys. This is where the front-end dev used to live. Claude Code builds it, you review against the spec. Reviewing finished work is 10x faster than producing it, which is exactly why one person can carry five clients' worth of builds.

3. Higgsfield (the media engine)

Every site needs visuals: hero video, product shots, motion, avatar spots for landing pages. Higgsfield generates them from prompts instead of a shoot or a stock-photo license. A single UGC creator on Fiverr charges $150-500 per 30-second spot. Higgsfield outputs the batch for a subscription. That's the difference between a $5k media line item per client and a rounding error.

The Claude Code build loop, step by step

This is the part people ask about most: what actually happens between "design approved" and "site live." Here's the loop.

1. 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. Name every page, every section, every piece of copy you already have.
2. Step 2: Scaffold first. Claude Code generates the folder structure, the component tree, and the base layout before writing a single page. You're not producing this. You're reading it.
3. Step 3: Build component by component. Prompt section by section: nav, hero, pricing table, footer. Each prompt references the design tokens from Fable so spacing, type, and color stay locked to spec.
4. Step 4: Wire the logic. Forms, CMS fields, animations, responsive breakpoints. This used to eat a front-end dev's whole week. Claude Code does it in one pass, then you prompt fixes on anything that's off.
5. Step 5: Review against the spec, not your taste. Pull up the brief from intake and check every box. A missing breakpoint, a missing hover state, a missing CMS field: that's a prompt back to Claude Code, not a manual patch.
6. Step 6: Deploy. Push to Vercel or Netlify, connect the domain, done. This step is fully scripted after your first few clients.

Six steps. No IDE gymnastics, no Git conflicts to referee, no junior dev to unblock. You're the reviewer, not the coder.

Example: a copy-to-clipboard button with animation

Here's roughly what comes back from Claude Code when you prompt for this exact pattern, a button that copies text and gives feedback with a quick state change instead of just swapping a label:

> 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); > > }

That's the loop in miniature. You ask for the interaction in one line, Claude Code writes the state logic and the transition, you click it once to confirm it fires and reverts after 1.5 seconds, and it ships. No hand-coding a debounce, no fighting a CSS class toggle yourself.

The delivery pipeline

1. Intake (you, 15 min): turn the client request into a clear spec. Pages, brand, edge cases. This is judgment work, and judgment is where the value lives.
2. Design (Fable 5): produces the system from the spec.
3. Build + media (Claude Code + Higgsfield): the site gets built and the visuals get generated in parallel.
4. QA + handoff (you, 20 min): review, deploy, document, notify. Mostly templated after the first few.

Notice the shape. The two stages that need a human, intake and QA, are the fast ones. The slow, labor-heavy stage in the middle is the one you removed yourself from entirely. You went from laborer to orchestrator.

The unit economics (why you keep 90%)

Here's where $35k MRR actually goes every month:

• Fable 5 subscription: ~$40
• Claude Code (heavy usage across all clients): ~$200-$300
• Higgsfield subscription: ~$40
• Hosting, domains, CMS: ~$150
• Tools/SaaS (CRM, scheduling, comms): ~$180

Call it roughly $750/month in total cost to deliver $35,000 of client value. That's a margin north of 90%, a number a staffed agency literally cannot reach because their biggest line item, payroll, is one you don't have.

The 90% margin doesn't exist because you're clever about pricing. It exists because the cost of delivering the work fell through the floor while the value clients pay for stayed exactly the same. You pocket the spread.

Filling the pipeline

A 90% margin means nothing without clients. You don't need a sales team.

• Post the work. Before/afters, "here's a site I shipped in 3 days," case studies with real outcomes. The right clients self-select and come pre-sold.
• Show speed. Concept to live site in days instead of weeks is the whole pitch. Prove it publicly.
• Sell the retainer, not the build. The one-time site gets you in. The monthly relationship is the business.

The agencies that win from here won't be the ones with the biggest teams. They'll be the ones who figured out that headcount went from being leverage to being a liability. Fable 5, Claude Code, and Higgsfield are the whole production department. One person, three tools, $35k/month