Notes6 min read

From designer to builder: directing a crew of agents at work

Most of the work becomes direction: writing the context agents need, turning taste into skills, setting guardrails for what must never happen, and reviewing what comes back. The part that doesn't change is understanding the problem first.

I've spent more than ten years designing products. That work took me from early research to shipped experiences, for clients like McKinsey, Google, Uber, S&P 500 companies and APCOA Parking. Today I'm a product person and builder at Fiserv, where I'm building agentOS, working across design, product and engineering.

People ask me what changed, and what working with AI agents looks like day to day. The honest answer is that the thread hasn't changed at all: understand the problem, then make the thing that solves it. What changed is who does the making.

2023 to now

The shift didn't happen in one jump. Looking back, it came in four steps.

2023: a thinking partner. I used Claude for research synthesis, for critique, and to sharpen specs. It made me faster. But I was still doing all of the work. Claude was a smart colleague I could think out loud with, and that was it.

2024: context and prototypes. I started keeping my briefs and design principles as context, so I didn't have to explain myself from scratch every time. Conversations began turning into working prototypes. And MCP, the standard that lets Claude connect to other software, plugged Claude into the tools I already used.

2025: from describing to shipping. Claude Code moved the agent into my files. Instead of describing what I wanted and copying the result somewhere, the agent worked directly in the project. Subagents, hooks and skills turned the way I work into something repeatable. That last part mattered most. My habits stopped living only in my head.

Now: directing a crew. Most of my work is direction. Context, taste written down as skills, guardrails, and review. agentOS at Fiserv and this course both came out of that shift.

What it means to direct AI agents

"Directing agents" can sound vague, so here's what it means in practice. It comes down to four kinds of work.

DirectionStandby
Context, taste and feedback converge on you, then fan out as clear direction to each agent's lane.

1. Context: what the agents know

An agent only knows what you tell it, or what it can find. So a big part of direction is writing things down. What the product is. Who it's for. What we already decided and why.

In Claude Code, the main home for this is a file called CLAUDE.md. Claude reads it at the start of every session. If you're a designer, think of it as the project brief that never gets lost in a thread.

Good context reads like a good brief. It's short, specific and current. When an agent does something odd, my first question is rarely "what's wrong with the agent?" It's usually "what didn't I tell it?"

2. Skills: taste, written down

This is the part designers tend to be best at, and it's the part I find most rewarding.

A skill is a set of instructions saved as a file, called SKILL.md, that Claude can pick up when a task calls for it. You can write your first skill in 15 minutes. If I always critique a screen in the same order, or always check the same things before calling a flow done, that belongs in a skill. Then every agent does it my way, not the average way.

The hard part isn't the file. It's being clear about what you actually believe. Writing taste down forces you to say why something is good, not just that it is. If you've ever built a design system, you already know this feeling. A skill is a design system for judgment.

3. Guardrails: what must never happen

Agents are fast, so mistakes are fast too. Direction means deciding in advance what needs a human yes, and what should be blocked outright.

Some of that is simple settings. Claude Code can ask before it takes actions, and you can add rules for specific tools. For the things that must never happen without me, there are hooks: small scripts that run at set moments and can stop an action before it happens.

If I were building Kudos, a made-up testimonial app, my guardrails would be obvious. Nothing reaches a real customer without my approval. No made-up customer ever appears as a testimonial. I'd rather those be enforced by the system than remembered by me.

4. Review: the part you can't hand off

Agents produce a lot. Someone has to decide what's good enough to ship, and that's still me.

Review is where design training pays off the most. I look at the work the way I'd look at a junior designer's file. Does it solve the problem we agreed on? Does it feel right? What's missing? Then the useful question: what should change in the context or the skills, so I don't have to give this feedback again?

That last loop is the real job. Every piece of feedback I give more than once is a sign that something belongs in a skill.

A crew, not a chatbot

Once this is in place, the work feels less like chatting with an assistant and more like running a small team. Different agents take different jobs. In Claude Code, subagents make this practical. Each one works in its own space with its own instructions, and hands back a summary instead of flooding the main conversation.

My role is closer to a creative director's than a maker's. I set the direction and the standard. I check the work. I decide what ships.

That doesn't mean I stopped making things. It means the making moved one level up. I now design how the work gets done, not just the thing at the end.

What changed and what didn't

Here's what changed for me:

  • Where my time goes. Less time producing, more time framing, writing context, and reviewing.
  • What I can ship alone. Things that used to need a team can now start with one person and a well-directed crew.
  • What expertise looks like. It's no longer only in my hands. It's in files that anyone, or any agent, can use.

Here's what didn't change:

  • Understanding the problem still comes first. An agent can build the wrong thing very quickly. Research, framing and judgment matter more now, not less.
  • Taste is still the deciding factor. AI drifts toward the most common answer. Someone has to notice when the output is generic and push it somewhere better. The taste gap explains why.
  • Someone still owns the outcome. Agents don't carry responsibility. You do.

Where this leaves you

If you design, manage products or run a small business, you already have most of what direction needs. You know how to frame a problem, write a brief, give feedback and hold a standard. The new part is putting those habits into a form agents can follow.

That's what Chief of Agents teaches, one capability at a time, on a real product with real customers. It's the playbook I wish I'd had, and every skill in it is one I use myself.

Sources

Learn this inside Claude Code.

Join the waitlist for Chief of Agents. You'll get the free beginner's handbook and skills right away, and hear first when the course opens.

One email to confirm, then the handbook and skills. Unsubscribe anytime.

Keep reading

  1. 7 min read

    Agents, skills, MCPs and hooks, explained with Figma

    Agent vs skill vs MCP, plus subagents, hooks and plugins: seven Claude Code terms, each matched to something you know in Figma.

  2. 6 min read

    Building with AI got cheap. Judgment didn't.

    When AI can build an app in an afternoon, the hard part is judgment: what to build, what good looks like, and who will pay.

  3. 6 min read

    Claude Code for designers: what it is, and why it isn't just for engineers

    What a coding agent does, why directing one is a design skill, and a safe first hour for designers new to Claude Code.

All notes →

© 2026 Chief of Agents · Notes · PrivacyIdeate. Build. Sell. You lead, the agents work.