mcpbeat Sign in

Org Design Agent Skill

Designs how an organization is structured — reporting lines, team boundaries, spans and layers, role definition, and workforce planning against the strategy. Use this to structure a new team, restructure an existing one, resolve unclear ownership between teams, plan headcount, or diagnose why a team underperforms for structural rather than individual reasons.

745 tokens
context cost
the whole folder, loaded on every use
1
files
instructions only
0
copies elsewhere
how many repositories repackaged it
220
stars on the repo
on the repository, not the skill itself

Install

one command, takes just this skill from the repository
npx skills add https://github.com/cbrock84/headcount --skill org-design

The instruction itself

7 sections, as written by the author

Org design

Structure determines what is easy and what requires heroics. Most persistent coordination problems

are structural and cannot be fixed by asking people to communicate better.

Design from the work

Start with the work that must happen and its natural boundaries — where handoffs are expensive, and

where they are cheap. Draw team lines at the cheap handoffs.

Then check: can each team deliver something meaningful without waiting on another? A team that

cannot ship without three dependencies is not a team, it is a queue.

Design the org for the work, not around the people currently in it. Then reconcile deliberately,

noting where you have compromised and why. Structures built around individuals fail when those

individuals leave, and everyone can see they were built that way.

Spans and layers

Wide spans push decisions down and starve people of attention. Narrow spans give attention and breed

layers, which add latency to every decision.

Roughly: five to nine reports for a manager whose people need coaching; more where the work is

consistent and the people are experienced. Every layer must add decision value — a layer that only

passes information along should be removed, and it is usually obvious which one it is.

Ownership

Every outcome has exactly one owner. Where two teams share an outcome, neither owns it, and it fails

in the gap. Where an owner lacks the authority to deliver, the accountability is fictional.

Write down the boundaries — what each team decides alone, what needs consultation, what needs

approval. Ambiguity between senior teams is expensive and does not resolve itself.

Workforce planning

Plan roles against the work and the plan, not against last year plus a percentage. For each proposed

role: what does not happen without it, what does it take off someone else, and what is the ramp

before it contributes?

Sequence hires so each has someone to learn from. Hiring three juniors before the senior who leads

them is a common and expensive ordering error.

Restructuring

  • Say why, plainly, and what problem it solves. People fill silence with worse explanations than the

truth.

  • Announce the whole change at once. Serial reorganizations cost more in sustained uncertainty than

one larger change.

  • Anything touching an individual's role, level, or pay goes through the people function before

announcement, without exception.

Never

  • Restructure to avoid a performance conversation.
  • Create a role to retain someone the structure does not need.
  • Leave an outcome with two owners.

How to use it

Copy the folder

Take cbrock84/org-design from the repository into ~/.claude/skills for personal use, or into .claude/skills inside a project.

Check the name does not clash

The agent identifies a skill by the name field in its header. Two skills with the same name cannot sit side by side — one of them will be ignored.