5 Agents, 11 Skills, 1 Brief: How I Built My Own AI Workflow

A few weeks ago, I sat down and tried to honestly map what was slowing me down the most: page briefs.

Not the writing. Not the design. The brief — the research-heavy document that needs to exist before any of that can happen. The one that requires synthesizing product capabilities, competitor pages, user interviews, audience data, and page performance numbers into something a designer or writer can actually execute from.

It was slow. It was inconsistent. And the quality depended on how much time I had to invest in the research.

I wanted to make this more efficient without sacrificing depth and quality.

So I spent time mapping it, building it, breaking it, and rebuilding it — until what I had was a system I could actually trust. I built an AI workflow for brief creation.

Here's how I built it, step by step.

Step 1: Map before you prompt

The most important thing I did had nothing to do with AI.

Before I opened any tool, I wrote the entire process out as a document. Every step. What information goes in. Where it comes from. What the output needs to look like. How it connects to the next step.

This sounds obvious, but most people skip it. They jump straight to prompting and wonder why the outputs feel disconnected.

When you map first, you see the full picture. You spot which steps are actually dependent on each other. You realize some things can run in parallel. And you figure out where the quality risks live.

In my case, the research phase had four completely independent tracks: product capabilities, competitor analysis, page performance data, and audience insights. None of them needed to wait for the others. That one insight alone shaped the entire architecture.

Step 2: Let the AI help you design the system

Once the process was on paper, I uploaded it and asked Claude to think through the structure with me: What agents would I need? What skills do I need to define? What tools does each one need access to? How should they hand off to each other?

I didn't start from scratch. I reacted, pushed back, and refined.

This is where I learned something that sounds simple but took a while to feel real: the AI isn't the decision-maker. I am. My job in this phase was to bring the domain knowledge — what a good brief actually requires, what my real tools are, what quality looks like — and let the model help me translate that into a system design.

What came out of this step: 5 agents, 11 skills, and a 5-step production workflow. Each agent owns exactly one part of the process. No one agent does everything.

Step 3: Build one step at a time

This is where most people try to do too much at once, and then nothing works and they can't tell why.

I built each step completely before moving to the next one. I defined the skills for each step and each agent got its own detailed skill file — a spec that defines what it does, what it reads from, how it formats its output, and how the next agent picks up from there.

The research agent, for example, runs four tracks in parallel: product capabilities from the internal knowledge base, competitor page analysis, page performance data from Tableau and Quix, and audience insights from NotebookLM's user calls database and social listening.

I didn't move to Step 2 (synthesis) until Step 1 was producing outputs I actually trusted.

That constraint slows you down at the start. It saves you enormous time later.

Step 4: Connect the steps

Once every individual step was working, I wired them together.

This is when the agents become a system instead of a set of isolated tools. Each agent knows what to expect from the one before it, and what to produce for the one after.

The Analyst agent takes the four research outputs and turns them into one consolidated report — surfacing signals, contradictions, and opportunities. The strategy agent reads that synthesis and defines the positioning angle, the page story and fold breakdown together with the Designer agent. The Copywriter agent turns that into a format the writer can execute.

The wiring matters as much as the steps themselves. A great agent with a bad handoff produces garbage for the next step.

Step 5: Add review gates

This is the piece I'm most proud of, and the one I didn't know I needed until I thought about it carefully.

I added a QA agent between every single step. Before any output reaches the next stage — or reaches a person — it passes through a review gate that checks it against a defined quality checklist.

The gate doesn't approve or reject. It surfaces specific gaps: is the user intent clearly defined? Is the positioning differentiated? Are there source citations? If there are critical issues, the step re-runs automatically until the output is clean.

What surprised me was how differently I related to quality once it was baked into the process. When a gate surfaces a gap, it doesn't feel like failure. It feels like the system doing its job. I stopped second-guessing my own output and started trusting that problems would get caught before they moved forward.

That shift alone was worth the build time.

Step 6: Test end-to-end — and expect it to break

The first time I ran the full workflow, several things didn't work.

Some agents produced outputs in the wrong format. One handoff dropped data that the next step needed. A source connection that worked in isolation failed when it ran as part of a larger chain.

I expected this. Breaking is part of the process. What mattered was having enough visibility into each step to diagnose where the failure actually came from.

Run the full workflow. See what breaks. Fix it. Run it again.

The workflow now runs in production. It handles the research-to-brief process for page creation — from product capability research through to a Google Doc content brief and a mockup in Figma, with a QA gate at every step. It integrates with 6 tools I actually use and it gets better as the knowledge it draws from grows.

What I'd tell anyone starting this

You don't need to be an engineer to build a system like this. You need to know your process deeply — what quality looks like, where the risk lives, what the inputs and outputs are at each step.

That's PMM work. Workflow design is just PMM work applied to AI.

The research that used to take days now gets done in hours. The briefs are more consistent. And the knowledge the system draws from grows with every page I create.

That compounding effect is what I didn't fully anticipate when I started — and it's the reason I keep building.