How to run a four-agent dev team as a non-technical founder

If you're a non-technical founder, you don't need to hire a dev team to ship software: you need to learn to run one. Four AI agents in one Claude Code conversation, each with a bounded role, can build and ship a production website (including the CMS). The only skill you need is the skill of giving good briefs.

You have a list of things you'd build if you had a dev team. Every non-technical founder has one. The list usually starts with "rebuild the website" and ends somewhere near "an internal tool nobody else will ever see, but that would save me four hours a week."

You don't have a dev team. You have a Notion doc called "Dev Team," which currently contains the email address of a freelancer who was responsive in January… two years ago.

Here's the thing nobody has told you yet: you do have a dev team. Four of them. They live inside one Claude Code conversation, they hand work between each other, and they built the site you're reading this on.

The reframe

A multi-agent team in Claude Code is a set of specialist sub-agents, each with its own context file, that you invoke by name and that hand work between each other inside one conversation. Anthropic's Claude Code supports sub-agents, which are bounded specialist instances of Claude that you invoke by name and that share context within one conversation.

The Multi-Agent Starter Kit is a four-agent team: Designer, Engineer, Reviewer, and Marketer, that hand work between each other inside one Claude Code conversation. At Tincture, ours are Vera (Designer, our UX/Design Engineer), Bob (Engineer, our Builder), Ray (Reviewer, our CTO), and Amy (Marketer, our GTM Lead, who assesses whether every output suits our ICP).

Four context files. Four agents. One conversation. That's the kit.

The team has a name: the Tincture Four-Agent Dev Team. It's the team that builds and ships software when you can't write code, don't want to hire a freelancer, and don't have eighteen months to wait for a hire to ramp.

The four agents

Designer. The Designer is the eye. Brand visuals, layout, typography, image direction, page structure. The Designer reads your brand context file (palette, type, voice notes, visual references) and produces concepts you choose between. On tinctu.re, the Designer drafted three concepts for the home page header, named the photography treatment for each, and described what the page felt like before any code existed. You read the concepts, picked one, and moved on. The Designer doesn't write code; the Designer writes briefs the Engineer can scaffold against.

Engineer. The Engineer is the hands. Scaffolding, code, CMS install, deploy pipeline, the work that turns a Designer's brief into a working URL. The Engineer reads your stack context file (preferred frameworks, hosting, CMS choice, anything you've already decided) and writes the code. On tinctu.re, the Engineer installed Sanity as the headless CMS, scaffolded the Next.js site, wired up the Vercel deploy pipeline, and shipped the first version of the home page from the Designer's concept inside the same hour sprint.

Reviewer. The Reviewer is the second pair of eyes. Bugs, security, brand-fit, voice-fit, accuracy, accessibility, ship-or-don't. The Reviewer reads your standards context file (what good looks like, what gets blocked, what gets revised) and runs every piece through a gate before it goes live. On tinctu.re, the Reviewer caught that a hairline divider on warm-white sat below WCAG AA contrast and fired a revise back to the Engineer in the same conversation. The Reviewer doesn't have an off day; the Reviewer's job is to be uncompromising.

Marketer. The Marketer is the voice. Copy, GEO/SEO, meta tags, content repurposing, the work that makes a page findable and a piece of content reusable. The Marketer reads your audience context file (who you're writing for, what they save, what they skip) and produces copy and metadata to match. On tinctu.re, the Marketer wrote the meta description for every insight page, structured each one for LLM citation, and took the first blog post and repurposed it into a Reddit post, a Substack email, and a Substack note before any of them existed.

How to install the kit

The Multi-Agent Starter Kit packages four pre-built sub-agents (Designer, Engineer, Reviewer, Marketer) plus a four-file context layer that drops into any Claude Code project. Setup is eight steps.

That's the kit, the whole thing.

A worked example: the prompt that built tinctu.re's home page header

When the home page header for tinctu.re needed building, the prompt to the Designer was specific:

Designer, the tinctu.re home page needs a header that does three things. One: tells a non-technical founder in five seconds that this is a commercial-ops practice for early-stage founders, not another agency. Two: signals AI-native through visual register, not through over-repetition of the word "AI." Three: opens on the warmth of a practice, not the chrome of a tool. Use the four photography treatments from the design system. Lead with apparatus register. Three concepts, one paragraph each, with the chosen treatment named.

Three concepts came back. The winning one used the apparatus register: a single photograph of a brass alembic on warm-white linen, with the strapline running below in restrained editorial type. The other two got rejected (one was too cold, one leaned too far into chrome).

Then the prompt to the Engineer:

Engineer, scaffold this header in Next.js. The image is a hero with a maximum width of 1200px, the strapline sits below at 24px on desktop. Use the existing font stack. The header is server-rendered, no client-side state. The image source comes from Sanity once it's wired.

The Engineer wrote the JSX, set the typography scale, configured the image component. Ten minutes.

Then the Reviewer:

Reviewer, check this against the brand standards and accessibility.

The Reviewer ran the page. Brand fit: pass. Voice fit: pass. Accessibility: revise. The hairline divider between the header and the next section was at 1.5px in a warm gray that landed below WCAG AA contrast. The Reviewer fired the revise note back, the Engineer adjusted the divider to a darker brand-gray, the page passed.

Then the Marketer:

Marketer, write the meta description for this page. Target query: commercial operations practice for early-stage founders. Read the existing copy on the page and make the meta description an extension, not a translation.

The Marketer wrote 158 characters that read like the page felt. Done.

End-to-end, the header took one Claude Code conversation, three hours of clock time, and roughly an hour of the founder's attention. That's the cadence: agents work, founder directs, work compounds.

Sanity, the headless CMS

A headless CMS is a database for your website's content, separated from the website itself, so that an editor can publish or edit a piece without touching code. Most founders haven't met this distinction; they think a CMS is WordPress. WordPress is the website and the database, fused together. A headless CMS is just the database, and the website talks to it through an API.

We picked Sanity because the editing experience is good, the schema is flexible, and the API is fast. The Engineer agent installed Sanity from scratch: ran the install command, set up the schemas for insights, case studies, and tools, wired the authentication, deployed the studio. The Designer agent built the templates that render Sanity's content on the public site. The Reviewer agent caught two missing schema validations on the first pass. Total wall-clock time, including learning Sanity's specifics inside the conversation: one afternoon.

Vercel, the deploy pipeline

Vercel is the thing that takes your code from your laptop and puts it on the internet. Every time you change a file and save it to GitHub, Vercel notices, builds the site, and updates the live URL. You don't touch it after setup.

The Engineer wired Vercel to the GitHub repository in one prompt. The hardest part wasn't the wiring; it was the founder's decision about which environment variables to set. The agent didn't make that call; the agent asked, the founder answered, the agent wired.

The brand-review gate

The Reviewer agent runs every page through brand-fit and voice-fit before publish, not just at the start. A second pair of eyes that doesn't get tired and doesn't have an off day. The brand-review gate is what makes tinctu.re consistent across surfaces; it's also what prevents the slow drift that affects every site built by a single founder who's getting tired.

The insights pipeline

The Marketer agent takes a cornerstone and produces the LinkedIn post, the X thread, the Substack note, the meta description, the structured data, the alt-text on every image. One piece of writing becomes five surfaces with no copy-paste tax. The site you're reading this on, including the Sanity install and the deploy pipeline, was built by this team.

A short glossary, for someone who hasn't opened a terminal

• Claude Code. A free command-line tool from Anthropic that lets you have a conversation with Claude inside a project folder on your laptop. The kit runs inside Claude Code.
• Sub-agent. A bounded specialist version of Claude that you invoke by name. Each sub-agent has its own context file and stays in its lane.
• Headless CMS. A database for your website's content, separated from the website itself. Sanity is one example. Contentful is another.
• Vercel. A service that takes your website code and serves it on the internet, automatically rebuilding when you make changes. There are alternatives (Netlify, Cloudflare Pages); Vercel is what we use.
• GitHub. Where your code lives. The Engineer pushes there; Vercel reads from there; you don't have to touch it unless you want to.
• Deploy. The act of putting new code live. Vercel does this for you every time GitHub changes.
• Build. The step where your source code gets turned into the optimized version that visitors actually see. Vercel runs the build for you.
• Repo. Short for repository. The GitHub folder your code lives in.

That's the whole stack, in a paragraph. None of it requires you to learn it deeply; it requires you to know the names. The agents handle the rest.

The operating cadence

Running a four-agent dev team is the practice of writing briefs, reading outputs, and making calls; the agents do the building, the founder does the directing.

A day looks like this. You wake up with a thing you want to build or fix. You open the Claude Code conversation. You write the brief to the Designer, or sometimes directly to the Engineer if it's a known-pattern change. You read what comes back. You make the call: this concept, not that one; this copy, not that one. You ask the Reviewer to gate. You wait twenty minutes. You ship.

The cadence works when you protect three things: the briefs you give, the calls you make, and the time you spend in the loop. If the briefs are vague, the work is vague. If you don't make the calls, the conversation stalls. If you outsource the loop, you lose the thread of what's being built and why.

The skill of running the team is the skill of giving good briefs and making good calls. Both of those are founder skills, not engineering skills.

What still needs you, and why those skills are cheap to acquire

Strategy. Taste. The final yes. Naming things. Choosing what to build and why. Agents are leverage, not substitution.

These aren't multi-year skills. They're weeks-and-months skills. You build taste by looking at a lot of work and asking why this one and not that one. You build strategy by reading the operators you respect and understanding their frames. You build judgment by making calls and watching what happens. A non-technical founder can be operationally fluent in all four inside a quarter, often less.

The years-of-study skill is writing code; the kit removes it. The skills that still need you are weekend-and-evenings skills, picked up while running your business, and being curious. You build them at the same time as you build the company. That's the asymmetry the kit exploits, and that's why this specifically works for non-technical founders.

You don't need to learn to code. You need to learn what to brief, what to choose, and what to ship. Those skills are cheap.

Get the kit

The Multi-Agent Starter Kit is at tinctu.re/tools/multi-agent-starter-kit. The zip contains the four context files (with prompts to help you fill them in), the install instructions, a README that walks you through the first conversation, and a worked example showing the team building a simple feature end-to-end.

A non-technical founder can ship a production website, including the headless CMS install, by writing four context files and giving briefs to the four agents. The first thing you'll build is smaller than you think and faster than you'd guess.

The hardest part isn't the kit. It's writing the first brief, and once you've written that, the team starts.