You Can't Orchestrate What You Haven't Broken Down

Have you ever handed an agent the whole job? "Plan the launch." "Handle onboarding." "Write the weekly update." It comes back fast, polished, and confident. It also comes back generic. It isn't wrong, exactly. It just isn't how you would have done it.

So you do what everyone does. You add more context. You paste in examples. You write a longer, more detailed ask. You get a longer, more detailed version of the same generic answer.

The problem was never the ask. It was the size of it.

You can't orchestrate what you haven't broken down.

The expert problem

When I talk about skills, I don't mean people skills. I mean AI skills, the small written instructions an agent picks up when a task calls for it. And there's an idea about building them that I couldn't shake. "You can't build a skill without first being an expert in that skill."

It sounded right. It also sounded like a wall. If you have to be an expert first, most people never get to the start.

I went looking for whether it was true. It's half true, and the half that isn't is the useful part.

Orchestration isn't a bigger skill

Orchestration sounds like the advanced move, the thing you graduate to. One skill that runs the whole job while you watch.

It isn't a bigger skill. It's skills you already trust, run in an order you already trust. Each piece gets built on its own until it works every time. Then they get put together, and the whole thing is only as good as its weakest step.

Most people try to build the orchestrator first.

Start at the finish line

Before I write a single instruction, I write down what done looks like. In my own workflow I call this the unified vision (a shared picture of what done looks like). It isn't a paragraph. It's a short list of things I can check with a yes or no.

Under 200 words? Mentions every number that moved? Ends with one clear next step? Sounds like us?

If I can't write that list, the agent can't hit the target. More often than I'd like to admit, it also means I haven't decided what I want yet. That's worth finding out before anything gets built.

Do it once, out loud

Don't try to remember how you do the job. Do it once, for real, and narrate. Talk through it, or jot a line every time you make a move.

You will catch steps you didn't know you were doing. I always check last week's version before I write this week's. I had never once written that down. It lived in my hands, not on any page.

You'll catch something else, too. Steps that are wrong. The check you do in the wrong order. The workaround for a problem that got fixed a year ago. The rule you follow but can't defend once you see it written down. None of that shows up while it's living in your head. It only shows up on the page.

This is where the expert line starts to crack. You don't have to already know your process. You have to watch yourself do it. Every gap you find and fix makes the process better, and it makes you more of an expert in your own work than you were before you looked.

Give every step one job

Now turn those notes into steps. Before you do, it helps to know what a good step actually is.

There's a classic set of chess studies from the 1970s that I keep coming back to. Show a chess master a real game position for a few seconds and they can rebuild the board almost perfectly. Beginners can't. You'd assume masters just have better memories. They don't. Scatter the same pieces randomly, in positions that could never happen in a real game, and most of the masters' advantage disappears.¹101Source: Gobet & Charness Expertise in Chess

What the masters had was chunks. They didn't see a board full of separate pieces. They saw a handful of familiar patterns, each one a single thing they recognized and knew what to do with. A beginner sees a bishop, a knight, two pawns, and a rook. A master sees one shape.

That's what a good step is. A chunk. It isn't every tiny action, and it isn't the whole job. It's a group of actions that belong together, that you'd recognize as one move, with a clear result at the end. "Open the dashboard, filter to this week, export the numbers" isn't three steps. It's one chunk. Gather this week's numbers.

That's also what expertise looks like from the inside. A beginner's version of a job is a long list of loose actions. An expert's version is a short list of chunks. When you break your work down this way, you aren't just organizing it for an agent. You're building the same thing the chess masters built.

So group your notes into chunks. Four to eight is plenty. Start each one with a verb, like gather, compare, flag, draft, or check.

Then, for each step, write two lines. What goes in. What comes out.

That second line is the one that matters. What comes out is the artifact, something I can read and judge for myself. Every step leaves a signal. When the end result is off, I don't guess where. I open the artifact for each step and find the one that went sideways.

While you're there, mark the judgment calls. Some steps are routine, and anyone could follow the rule. Some take experience, like deciding which change actually matters to this client. And some are yours to keep. Those last ones become the moments the agent has to stop and ask you.

On the last pass, ask "why do I do this?" for each step. Every time I've done this, at least one step didn't survive the question.

Build one chunk at a time

Each chunk gets its own skill. One sentence on what it does. A few lines of instruction. One example of good. One way to check it.

This is where it's easy to overcorrect. Once you see the value in breaking work down, the instinct is to keep going. Split every step into smaller steps until each one is a single action. Open the file. Find the column. Copy the number.

That's the beginner's board again. A pile of loose pieces with no shape.

The goal isn't the smallest step you can write. It's the biggest step you can still judge in one look.

So I ask two questions of every chunk.

Would I actually look at what it produces? If the output isn't something I'd stop and judge on its own, it isn't a chunk. It's a piece of one. Fold it back into its neighbor.

When it goes wrong, do I know where to fix it? If a bad result could have come from three different places inside the step, it's carrying more than one chunk. Split it.

Everything between those two is the right size.

The research lines up with this. In a 2026 benchmark called SkillsBench, focused skills improved agent results about three times as much as long, comprehensive documents. But more pieces didn't keep helping. Two or three skills on a task did best, and past four the gains mostly fell away. Focused, not tiny.²202Source: SkillsBench The First Benchmark for Agent Skills

Then test each skill alone, with real work instead of made-up examples. One change, then check.

Only when a chunk does its job every time does it earn a place in the chain.

Then let something conduct

Once the pieces work, connect them. What comes out of one step is what goes into the next. Between each one is a checkpoint. Is this still on track before I hand it forward? Anthropic's own example of this is about as plain as it gets. Write an outline, check that it meets the criteria, then write from the outline.³303Source: Anthropic Building Effective Agents

If the steps are always the same, that chain is enough. Don't build more than you need.

If the job changes with the situation, that's when you add a conductor. It's a skill whose only job is to run the other skills. It knows the finish line, the order, the checkpoints, and when to stop and ask me. It doesn't do the work. It calls the right step at the right time.

My own workflow is exactly this. Research, proposals and questions, unified vision, named outcome, build, test, then my own hands-on check before anything ships. Each of those is its own skill. The orchestrator just knows the order and knows which ones need me. When something comes out wrong, the artifacts tell me which step to adjust, and I can change that one without breaking the rest.

I didn't design that in one sitting. It grew out of pieces that worked, one at a time.

What the expert line got wrong

So, can you build a skill without first being an expert?

The half that's true is that someone has to know what good looks like. The same benchmark found that skills written by people who knew the work made a real difference, while skills the agent wrote for itself barely helped. The agent can try and retry all day. It can't decide what "good" means for your work.²202Source: SkillsBench The First Benchmark for Agent Skills

The half that isn't is that you don't have to show up an expert. Breaking the work down is how you become one. Every step you name, every artifact you check, every "why do I do this?" makes you better at the job, not just the agent. The breakdown also shows you your own gaps. The step you never wrote down, the rule you couldn't explain, the step that shouldn't exist.

You don't need expertise to start. You build it by breaking things down.

The order holds

My first attempts at orchestration were too much, all at once, with nowhere specific to fix it. Every one of them failed for the same reason. I'd skipped the breakdown.

Now I start at the finish line, give every step one job, build one chunk at a time, and let the conductor come last.

You can't orchestrate what you haven't broken down.

Start with one chunk. Build it until you trust it. Then add the next.