Add a Department, Not a Prompt: Why One Developer Gave Claude Code a C-Suite

cbrock84/headcount opens with an interactive org chart. Sixteen C-suite departments. One hundred and forty-six skills. A chief executive at the top and a legal department at the bottom that can, in theory, stop the entire operation. It looks like a Series B startup’s management page, but it is actually a plugin marketplace for Claude Code. The pitch is pithy: “Add a department, not a prompt.”

The repository is the work of Chris Brock, and it represents one of the more ambitious attempts to impose structure on the emerging chaos of AI agent capabilities. Rather than treating large language models as infinite prompt surfaces, Headcount treats them as a company that hires specialists. The metaphor is not merely cosmetic. It encodes a specific theory about how agent systems should scale: through hierarchy, bounded responsibility, and independent audit.

The Org Chart as Operating System

Most current approaches to augmenting coding agents rely on flat registries of skills or ad-hoc prompt libraries. Headcount’s insight is that human organizations evolved org charts for a reason—coordination fails when everyone owns everything. The repository therefore partitions its 146 skills into sixteen departments, each with an executive title and a bounded remit. Technology reports to the CTO. Security reports to the CISO, who in turn reports to the CEO, not to the CTO whose work they review. Product, Finance, Operations, and Demand Generation each carry their own installable plugin manifest. A project loads only the departments it needs, addressing skills through a department:skill namespace that prevents collision.

The interactive org chart is not mere marketing. In a system with 146 skills, discoverability is a genuine technical problem. The chart makes the namespace browsable, allowing a developer to search across every skill, open a department, and jump to source. This addresses a failure mode common in large prompt libraries: skills exist but nobody knows they exist, so users revert to generic prompting. By making the hierarchy visual and searchable, Headcount turns the org chart into a user interface for capability discovery.

Progressive Disclosure at Enterprise Scale

The technical foundation rests on Anthropic’s own skill architecture. As documented in the Claude platform, skills use a three-level progressive disclosure model. Level 1 is metadata—roughly a hundred tokens of name and description that sit in the system prompt permanently, allowing Claude to match user requests to relevant skills without loading their full content. Level 2 is the instruction body, loaded only when a skill triggers. Level 3 comprises scripts, references, and additional materials accessed on demand. Headcount exploits this aggressively. A skill like security:threat-modeling or finance:unit-economics occupies negligible context until the user asks something in its territory, at which point the full procedural knowledge loads. The result is a system that can carry the expertise of an entire enterprise software suite without the context-window bloat of dumping every prompt into every session.

This matters because the alternative—giant system prompts stuffed with every possible instruction—degrades performance. Headcount’s auto-loading mechanism means the right specialist engages for the right question. Ask why a landing page is not converting, and the demand-generation:landing-page-cro-expert loads. Ask whether a hire is affordable, and finance:unit-economics responds. The user does not need to remember which prompts exist; the metadata matching handles dispatch.

Corporate Governance as Agent Architecture

What separates Headcount from a well-organized prompt folder is its governance model. The repository explicitly designates Security and Legal & Risk as “reviewer-class” departments. Their blocking findings are, by convention, not overridable by the department under review. The documentation notes that this is why the CISO and CLO report to the chief executive rather than into the function they oversee. In human corporations, this independence prevents production from overriding safety. In an agent context, the same structural principle means a security skill can halt a deployment skill, or a legal skill can flag a contract review before revenue operations proceed.

The README walks through seven cross-department scenarios—enterprise SOC 2 demands, security incidents, stalled funnels—where multiple departments engage sequentially and where a reviewer-class department has the authority to stop the work rather than merely append an opinion. This is workflow design masquerading as documentation. It suggests that agent systems need separation of powers, not just separation of concerns.

Each department also ships an agent charter in .claude/agents/, allowing the department to be delegated as a subagent with its own exclusive write surface. This is the other genuinely sharp idea in the repository. Most multi-agent systems split work by topic—one agent for SEO, another for UI—which inevitably leads to merge conflicts because both touch the same files. Headcount splits by write surface instead. The Technology department might own src/, while Security owns the review comments. The boundary is checkable: the repository includes a surface map and a CI script that verifies every path has exactly one owner. It is a crude but effective approximation of filesystem-level access control, implemented through documentation and automation rather than kernel permissions. The same CI script validates that every department:skill reference resolves, that frontmatter is unique, that generated READMEs are current, and that no third-party license text has crept in. The rigor suggests Brock is applying production-engineering discipline to what is essentially a knowledge-management problem.

The Marketplace Landscape

The repository sits within a rapidly expanding ecosystem. Claude Code’s plugin marketplace mechanism, introduced by Anthropic, allows anyone to define a marketplace.json catalog and distribute installable skills via git. Users add a marketplace once, then install individual plugins scoped to their project. Other marketplaces are emerging—Netresearch maintains a curated collection of stack-specific skills for TYPO3, PHP, Go, and Docker, while directories like aitmpl.com track dozens of collections ranging from browser automation to notification hooks.

Headcount distinguishes itself by being function-centric rather than stack-centric. Where Netresearch asks “what framework are you using?”, Headcount asks “what business problem are you solving?” The former is a toolbox; the latter is a consulting firm in a box. Its closest conceptual competitor might be the larger skill collections on aitmpl.com, but even those tend to organize by technical capability rather than by business function. Headcount’s bet is that developers working on real software also need help with pricing, positioning, threat modeling, and unit economics—and that these should be first-class citizens in the agent’s world, not afterthoughts.

Where the Metaphor Strains

That consulting-firm framing is also where the project risks overreach. The “departments” are ultimately skill namespaces and markdown files. The chief executive skill does not allocate actual capital; the CFO skill does not touch a ledger. The corporate hierarchy is a powerful mnemonic and a useful packaging convention, but the enforcement of the chain of command relies on the user—or the CI script—to respect it. There is no technical mechanism preventing a user from overriding the CISO, just as there is no technical mechanism preventing a human CEO from firing the auditor. The metaphor is strong because it maps to familiar organizational patterns, but it remains a metaphor.

And because the repository is purpose-built for Claude Code’s plugin system, its portability to other agent platforms—Cursor, Copilot, or the emerging Agent Skills specification—is uncertain, though the underlying markdown skills could likely be adapted. The value is in the taxonomy and the governance conventions, not in a novel runtime.

Outlook

Still, the metaphor may be exactly what agent systems need right now. The immediate problem in AI-assisted development is not a lack of raw capability; it is a lack of coordination. Developers are drowning in context windows stuffed with prompts that trigger at the wrong time, or in multi-agent loops that overwrite each other’s work. Headcount’s org-chart approach offers a plausible middle ground between the anarchy of flat prompt libraries and the complexity of fully autonomous agent swarms. It suggests that the future of agent organization might look less like a Kubernetes cluster and more like a mid-sized company’s reporting structure—complete with the politics, checks, and balances that implies.

Whether that future arrives depends on whether the Claude Code plugin ecosystem matures into a true interoperability standard or fragments into competing taxonomies. Headcount has placed its bet: when in doubt, add a department.