Vibe Engineering for Agency Client Builds

For agency developers building client apps · Based on Adrian's Vibe Engineering Build Framework

// TL;DR

Agency developers can use Adrian's Vibe Engineering Build Framework to deliver consistent, production-quality AI apps across many clients without reinventing structure each time. The reusable **skill files** (Clerk, Supabase, OxyLabs, Vercel AI SDK) travel between projects, while a fresh **agents.md** captures each client's product, data model, and out-of-scope boundaries. The AI writes its own implementation prompts, which you approve before code — giving you an auditable plan trail for scope control and client sign-off. It's how agencies scale quality across a portfolio while keeping decisions with the developer, not the AI.

Why do agency AI builds drift out of scope?

Client work lives or dies on scope. When an AI coding tool adds a recommendation engine or a notifications system nobody paid for, you eat the cost or renegotiate. Generic AI sessions add features that 'sound useful' by default. Adrian's Vibe Engineering Build Framework makes scope a first-class artifact through the out-of-scope list in agents.md — every tempting feature you don't want is named, so the AI enforces the boundary across every build.

How do you reuse work across multiple client projects?

Separate tool knowledge from project knowledge. Skill files hold up-to-date, tool-specific guidance — one per tool — and travel from client to client. When a library updates, you fix one skill file and every future project benefits. agents.md holds project knowledge: what this specific client app is, its data model, its layers, its workflow. When you start a new client, you bring the skills and write a fresh agents.md.

This split is the agency scaling lever. Your Clerk skill, Supabase skill, and Vercel AI SDK skill become firm assets. Each new engagement reuses that accumulated tool expertise while getting a clean, client-specific operating system.

How does the approval gate protect your client relationship?

Before touching a file, the AI writes an implementation prompt to /prompts — goal, files to change, security rules, acceptance criteria, and exact verification steps. You review the plan, not the code. For an agency this creates an auditable trail: every feature has a documented plan you approved. If a client questions scope, you have the contract. If a junior on your team runs the build, the plan enforces the same standard a senior would.

You approve with a single letter; the AI rereads the saved file and implements strictly. Because agents.md includes the reread instruction, even a fresh session builds from the approved document, not degraded memory — critical when handing projects between developers.

How do you keep quality consistent across a team?

The data model is defined once in agents.md with hard rules — mandatory fields an item must have before it can be saved — and the AI enforces it everywhere: scraper, validation, UI. That means every developer on the account gets identical validation without coordinating. Layer separation rules (UI displays stored data only; UI never mutates pipeline state) keep architecture clean regardless of who's driving. The fallback rule ensures nobody's AI session makes a large independent decision in an uncovered situation.

What results can an agency expect?

Faster delivery with fewer scope fights, consistent architecture across your portfolio, and a documented plan trail for every feature. Skill files compound in value with every project. Junior developers ship at senior quality because the operating system, not the individual, sets the bar. And clients get production-quality builds with acceptance criteria baked in from the start.

Next step: Build a shared library of skill files for your standard stack, then template a lean agents.md structure your team fills in per client. Start your next engagement by writing the out-of-scope list first.

// FREQUENTLY ASKED QUESTIONS

How do skill files help across multiple client projects?

Skill files hold tool-specific knowledge — one per tool — and travel between projects unchanged. When a library updates, you fix one skill file and every future client build benefits. You reuse accumulated tool expertise while writing only a fresh, client-specific agents.md each engagement. This separation is the agency scaling lever.

Can I use the implementation prompts for client sign-off?

Yes. Every implementation prompt saved to /prompts is a documented plan you approved before code — goal, files to change, security rules, acceptance criteria. It creates an auditable trail per feature, useful for scope disputes and client sign-off. You're approving plans, not just accepting code, which is exactly the artifact clients want.

How does this keep quality consistent when juniors run the build?

The operating system sets the bar, not the individual. agents.md enforces the data model, layer separation, out-of-scope list, and fallback rule on every session. A junior's AI writes the same detailed implementation prompt and runs the same acceptance criteria a senior's would, so quality stays consistent across your team.