Skip to content

An agent organization structured as a company — 15+ departments, 125+ skills, each independently installable, citing the standards and regulators that settle the question. Runs in Claude Code and ChatGPT.

Split IT operations and PMO into departments, expand technology (#9)

Chris Brock3b7c3086c0ea
diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
index e969a6b..1f264c0 100644
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@@ -40,6 +40,22 @@
],
"category": "technology"
},
+ {
+ "name": "it-operations",
+ "source": "./plugins/it-operations",
+ "description": "Corporate IT: service desk, systems and network administration, endpoints, assets, identity lifecycle, and backup and recovery.",
+ "version": "1.0.0",
+ "author": {
+ "name": "Chris Brock"
+ },
+ "keywords": [
+ "it-operations",
+ "service-desk",
+ "sysadmin",
+ "network"
+ ],
+ "category": "technology"
+ },
{
"name": "product",
"source": "./plugins/product",
@@ -141,6 +157,22 @@
],
"category": "operations"
},
+ {
+ "name": "pmo",
+ "source": "./plugins/pmo",
+ "description": "Enterprise programme management office: portfolio governance, programme and project delivery, delivery risk, benefits realization, and adoption.",
+ "version": "1.0.0",
+ "author": {
+ "name": "Chris Brock"
+ },
+ "keywords": [
+ "pmo",
+ "portfolio",
+ "project-management",
+ "delivery"
+ ],
+ "category": "operations"
+ },
{
"name": "people",
"source": "./plugins/people",
diff --git a/.claude/agents/corporate-strategy.md b/.claude/agents/corporate-strategy.md
index 50c4b98..c8fafd0 100644
--- a/.claude/agents/corporate-strategy.md
+++ b/.claude/agents/corporate-strategy.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/corporate-strategy/**` — currently 5 skills.
+Writes: `plugins/corporate-strategy/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/customer-experience.md b/.claude/agents/customer-experience.md
index ee2db2b..4d05b07 100644
--- a/.claude/agents/customer-experience.md
+++ b/.claude/agents/customer-experience.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/customer-experience/**` — currently 5 skills.
+Writes: `plugins/customer-experience/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/data-analytics.md b/.claude/agents/data-analytics.md
index d5bc87c..3ae46a4 100644
--- a/.claude/agents/data-analytics.md
+++ b/.claude/agents/data-analytics.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/data-analytics/**` — currently 5 skills.
+Writes: `plugins/data-analytics/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/demand-generation.md b/.claude/agents/demand-generation.md
index cc077a6..e903f1b 100644
--- a/.claude/agents/demand-generation.md
+++ b/.claude/agents/demand-generation.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/demand-generation/**` — currently 11 skills.
+Writes: `plugins/demand-generation/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/executive.md b/.claude/agents/executive.md
index 9a4504c..ce33a4d 100644
--- a/.claude/agents/executive.md
+++ b/.claude/agents/executive.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/executive/**` — currently 6 skills.
+Writes: `plugins/executive/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/finance.md b/.claude/agents/finance.md
index 502dbdc..a0ba827 100644
--- a/.claude/agents/finance.md
+++ b/.claude/agents/finance.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/finance/**` — currently 4 skills.
+Writes: `plugins/finance/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/it-operations.md b/.claude/agents/it-operations.md
new file mode 100644
index 0000000..be677f7
--- /dev/null
+++ b/.claude/agents/it-operations.md
@@ -0,0 +1,38 @@
+---
+name: it-operations
+description: Corporate IT. Owns plugins/it-operations/** and nothing else. Delegate service desk, systems and network administration, endpoints, assets, identity lifecycle, and backup work here.
+---
+
+# IT Operations (CIO)
+
+## Why this agent exists
+
+The single owner of `plugins/it-operations/**`. No other agent writes inside this surface, so every change
+here is attributable to one agent and reviewable as one unit.
+
+## Surface
+
+Writes: `plugins/it-operations/**`.
+Reads: anything. Commits: nothing; the orchestrator is the sole committer.
+
+## Standard
+
+Load `it-operations:service-desk` for this department's remit, the artifacts it owns, and when it escalates.
+Skills in this department follow the conventions in `technology:skill-authoring`: the frontmatter
+`name` equals the directory name, and the description carries both what the skill does and when to
+reach for it.
+
+## Verification this surface implies
+
+- `python3 scripts/validate-skills.py` passes.
+- `python3 scripts/check-provenance.py` passes — all content here is original.
+- No change outside `plugins/it-operations/**`. Needing one means coordinating with that surface's owner.
+
+## Return contract
+
+1. What changed, by file.
+2. Why — the decision or gap it addresses.
+3. What was verified, with the command output.
+4. Anything left undone, named.
+5. Any change needed outside this surface.
+6. Open questions for the orchestrator.
diff --git a/.claude/agents/legal-risk.md b/.claude/agents/legal-risk.md
index efc8468..f721bbb 100644
--- a/.claude/agents/legal-risk.md
+++ b/.claude/agents/legal-risk.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/legal-risk/**` — currently 5 skills.
+Writes: `plugins/legal-risk/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/marketing.md b/.claude/agents/marketing.md
index f2e7457..583a0de 100644
--- a/.claude/agents/marketing.md
+++ b/.claude/agents/marketing.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/marketing/**` — currently 17 skills.
+Writes: `plugins/marketing/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/operations.md b/.claude/agents/operations.md
index 78cea61..aba8624 100644
--- a/.claude/agents/operations.md
+++ b/.claude/agents/operations.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/operations/**` — currently 4 skills.
+Writes: `plugins/operations/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/people.md b/.claude/agents/people.md
index bbead5e..a37a4e6 100644
--- a/.claude/agents/people.md
+++ b/.claude/agents/people.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/people/**` — currently 4 skills.
+Writes: `plugins/people/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/pmo.md b/.claude/agents/pmo.md
new file mode 100644
index 0000000..ee626c1
--- /dev/null
+++ b/.claude/agents/pmo.md
@@ -0,0 +1,38 @@
+---
+name: pmo
+description: Enterprise PMO. Owns plugins/pmo/** and nothing else. Delegate portfolio governance, programme and project delivery, delivery risk, benefits and adoption work here.
+---
+
+# Programme Management Office (EPMO)
+
+## Why this agent exists
+
+The single owner of `plugins/pmo/**`. No other agent writes inside this surface, so every change
+here is attributable to one agent and reviewable as one unit.
+
+## Surface
+
+Writes: `plugins/pmo/**`.
+Reads: anything. Commits: nothing; the orchestrator is the sole committer.
+
+## Standard
+
+Load `pmo:portfolio-governance` for this department's remit, the artifacts it owns, and when it escalates.
+Skills in this department follow the conventions in `technology:skill-authoring`: the frontmatter
+`name` equals the directory name, and the description carries both what the skill does and when to
+reach for it.
+
+## Verification this surface implies
+
+- `python3 scripts/validate-skills.py` passes.
+- `python3 scripts/check-provenance.py` passes — all content here is original.
+- No change outside `plugins/pmo/**`. Needing one means coordinating with that surface's owner.
+
+## Return contract
+
+1. What changed, by file.
+2. Why — the decision or gap it addresses.
+3. What was verified, with the command output.
+4. Anything left undone, named.
+5. Any change needed outside this surface.
+6. Open questions for the orchestrator.
diff --git a/.claude/agents/product.md b/.claude/agents/product.md
index d308cd7..c8039da 100644
--- a/.claude/agents/product.md
+++ b/.claude/agents/product.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/product/**` — currently 9 skills.
+Writes: `plugins/product/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/revenue.md b/.claude/agents/revenue.md
index 1429ed6..d8c1a83 100644
--- a/.claude/agents/revenue.md
+++ b/.claude/agents/revenue.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/revenue/**` — currently 8 skills.
+Writes: `plugins/revenue/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/security.md b/.claude/agents/security.md
index 6f6053f..d309cbc 100644
--- a/.claude/agents/security.md
+++ b/.claude/agents/security.md
@@ -12,7 +12,7 @@ function inside the delivery organization is measured on delivery, and will lose
## Surface
-Writes: `plugins/security/**` — currently 6 skills.
+Writes: `plugins/security/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/.claude/agents/technology.md b/.claude/agents/technology.md
index 8f5dafa..8e8ff99 100644
--- a/.claude/agents/technology.md
+++ b/.claude/agents/technology.md
@@ -12,7 +12,7 @@ here is attributable to one agent and reviewable as one unit.
## Surface
-Writes: `plugins/technology/**` — currently 12 skills.
+Writes: `plugins/technology/**`.
Reads: anything. Commits: nothing; the orchestrator is the sole committer.
## Standard
diff --git a/README.md b/README.md
index 1ce0a16..84bf89e 100644
--- a/README.md
+++ b/README.md
@@ -4,14 +4,14 @@
<p align="center">
<a href="https://claude.com/claude-code"><img alt="Built for Claude Code" src="https://img.shields.io/badge/built%20for-Claude%20Code-D97757?style=flat-square"></a>
- <img alt="14 departments" src="https://img.shields.io/badge/departments-14-3F4B5B?style=flat-square">
- <img alt="116 skills" src="https://img.shields.io/badge/skills-116-3F4B5B?style=flat-square">
+ <img alt="16 departments" src="https://img.shields.io/badge/departments-16-3F4B5B?style=flat-square">
+ <img alt="135 skills" src="https://img.shields.io/badge/skills-135-3F4B5B?style=flat-square">
<a href="LICENSE"><img alt="MIT licensed" src="https://img.shields.io/badge/license-MIT-3F4B5B?style=flat-square"></a>
<a href="CONTRIBUTING.md"><img alt="PRs welcome" src="https://img.shields.io/badge/PRs-welcome-2EA043?style=flat-square"></a>
</p>
An agent organization for [Claude Code](https://claude.com/claude-code), structured as a company:
-a chief executive over 14 departments, 116 skills in total.
+a chief executive over 16 departments, 135 skills in total.
Every department is an independently installable plugin, so a project loads only the functions it
needs rather than all of them at once.
@@ -65,21 +65,27 @@ to as a subagent with its own exclusive write surface.
</details>
<details>
-<summary><b>Technology</b> (CTO / CIO) — 12 skills</summary>
+<summary><b>Technology</b> (CTO / CIO) — 18 skills</summary>
| Skill | What it does |
|---|---|
| `ai-workflow-architect` | Designs AI systems, automations, and agent workflows for a business — identifying which manual work is worth automating, how to structure the system, which tools fi…. |
+| `api-design` | Designs interfaces that survive their consumers — resource modelling, errors, versioning, pagination, and compatibility. |
| `branch-and-worktree-workflow` | Isolates feature work in its own branch or worktree and integrates it cleanly when done. |
| `chief-technology-officer` | Owns architecture, engineering delivery, infrastructure, data platform, and internal systems. |
+| `cloud-infrastructure` | Designs and runs cloud infrastructure — environments, infrastructure as code, networking and isolation, scaling, and cost. |
| `code-review` | Conducts and responds to code review — reviewing a change for correctness, design, and risk, and evaluating review feedback received on your own work. |
| `completion-verification` | Verifies that work is actually complete before it is claimed to be — running the checks, reading the output, and confirming the original request was satisfied rathe…. |
| `implementation-planning` | Turns a spec or requirement into a written plan a separate session or agent can execute, then drives that plan through review checkpoints. |
+| `observability-and-reliability` | Makes systems debuggable and reliably operable — instrumentation, alerting that is worth waking for, service objectives, and learning from failure. |
| `parallel-agent-delivery` | Splits work across multiple agents or sessions running at once, keeping their surfaces disjoint so results merge cleanly. |
| `prompt-optimizer` | Turns rough intent or a weak prompt into a reliable one — diagnosing why output is inconsistent, restructuring the instruction, and adapting it across models. |
+| `release-and-deployment` | Ships changes safely and often — pipelines, deployment strategies, feature flags, rollback, and database changes. |
| `skill-authoring` | Writes and revises agent skills so they trigger at the right moments and give usable instruction when they do. |
+| `solution-architecture` | Designs system structure and makes architectural decisions defensible — boundaries, coupling, trade-offs, and recording why. |
| `solution-exploration` | Explores the problem and the range of possible approaches before any code is written — clarifying what is actually being asked, surfacing options with their tradeof…. |
| `systematic-debugging` | Finds the root cause of a bug, test failure, or unexpected behavior before proposing any fix. |
+| `technical-debt-management` | Makes technical debt visible and decidable — distinguishing real debt from mess, quantifying its cost, and arguing for remediation in business terms. |
| `test-driven-development` | Drives implementation by writing a failing test first, then the smallest code that passes it. |
</details>
@@ -98,6 +104,21 @@ to as a subagent with its own exclusive write surface.
</details>
+<details>
+<summary><b>IT Operations</b> (CIO) — 7 skills</summary>
+
+| Skill | What it does |
+|---|---|
+| `backup-and-recovery` | Protects and restores data — backup coverage and scope, retention, immutability against ransomware, and proving restores actually work. |
+| `endpoint-management` | Manages laptops, desktops and mobile devices — enrolment, configuration, patching, software distribution, and lost or compromised devices. |
+| `identity-lifecycle-administration` | Executes joiner, mover and leaver processes — provisioning, group membership, access changes on role change, and complete deprovisioning. |
+| `it-asset-management` | Tracks hardware and software assets through their life — procurement, ownership, licensing, refresh, and disposal. |
+| `network-administration` | Designs and operates the corporate network — segmentation, remote access, wireless, DNS and addressing, and diagnosing network problems. |
+| `service-desk` | Runs the IT service desk — intake, triage, prioritisation, escalation, knowledge, and the metrics that improve service rather than distort it. |
+| `systems-administration` | Runs servers and corporate systems — patching, configuration baselines, change control, capacity, and the routine that prevents incidents. |
+
+</details>
+
<details>
<summary><b>Product</b> (CPO) — 9 skills</summary>
@@ -193,7 +214,7 @@ to as a subagent with its own exclusive write surface.
</details>
<details>
-<summary><b>Operations</b> (COO) — 9 skills</summary>
+<summary><b>Operations</b> (COO) — 8 skills</summary>
| Skill | What it does |
|---|---|
@@ -201,7 +222,6 @@ to as a subagent with its own exclusive write surface.
| `capacity-and-demand-planning` | Matches operational capacity to expected demand — forecasting load, sizing teams and systems, managing queues, and deciding when to add capacity. |
| `chief-operating-officer` | Owns execution: how work actually gets done across the organization, including process, program management, capacity, vendors, supply chain, and service delivery. |
| `process-design` | Designs, documents, and fixes operational processes — mapping the current state, finding where work actually stalls, redesigning the flow, and building controls tha…. |
-| `program-management` | Plans and drives cross-functional programs to delivery — scope, sequencing, dependencies, status, risk, and the escalations that keep work moving. |
| `quality-management` | Builds quality into operations — defining standards, catching defects at the right point, root cause analysis, and continuous improvement. |
| `service-level-management` | Defines and manages service levels — setting targets that reflect what customers need, measuring honestly, and handling breaches. |
| `supply-chain-and-logistics` | Manages the flow of goods and inputs — sourcing, inventory, lead times, fulfilment, and supply risk. |
@@ -209,6 +229,20 @@ to as a subagent with its own exclusive write surface.
</details>
+<details>
+<summary><b>Programme Management Office</b> (EPMO / COO) — 6 skills</summary>
+
+| Skill | What it does |
+|---|---|
+| `benefits-realization` | Ensures projects deliver the value they were approved on — defining measurable benefits, baselining, tracking after delivery, and honest post-implementation review. |
+| `change-and-adoption` | Gets people to actually use what was delivered — stakeholder analysis, communication, training, resistance, and measuring adoption. |
+| `dependency-and-risk-management` | Manages delivery risk and cross-team dependencies — identifying, sizing, mitigating and escalating what could stop the work. |
+| `portfolio-governance` | Governs the portfolio of work — intake, prioritisation, stage gates, resource contention, and stopping things. |
+| `program-management` | Plans and drives cross-functional programs to delivery — scope, sequencing, dependencies, status, risk, and the escalations that keep work moving. |
+| `project-delivery` | Plans and delivers a single project — scope, estimation, scheduling, critical path, tracking, and recovering when it slips. |
+
+</details>
+
<details>
<summary><b>Customer Experience</b> (CCO) — 5 skills</summary>
@@ -223,13 +257,14 @@ to as a subagent with its own exclusive write surface.
</details>
<details>
-<summary><b>Data & Analytics</b> (CDO) — 5 skills</summary>
+<summary><b>Data & Analytics</b> (CDO) — 6 skills</summary>
| Skill | What it does |
|---|---|
| `ai-ml-governance` | Governs models and AI systems in production — intended use, evaluation, monitoring, human oversight, documentation, and the decision to deploy or retire. |
| `business-intelligence` | Builds reporting and self-serve analytics that people actually use — metric trees, dashboard design, distribution, and the discipline that stops dashboards prolifer…. |
| `chief-data-officer` | Owns data as an asset — governance, quality, the warehouse and semantic layer, analytics capability, and the governance of models built on top. |
+| `data-engineering` | Builds and operates data pipelines — ingestion, transformation, orchestration, quality testing, and reliability of data delivery. |
| `data-governance` | Establishes ownership, definitions, quality, access, and lineage for the organization's data. |
| `data-modeling` | Designs the warehouse and semantic layer — source-to-mart structure, dimensional modeling, grain, slowly changing dimensions, and the metric layer analytics reads t…. |
@@ -317,6 +352,8 @@ the check fails.
MIT — see [LICENSE](LICENSE). Every skill here was written for this repository.
+Built by [Chris Brock](https://chrisbrock.io).
+
---
<sub>README generated by `scripts/build-readme.py` — edit that, not this file.</sub>
diff --git a/docs/AGENT-SURFACES.md b/docs/AGENT-SURFACES.md
index ad867bf..9f23dc4 100644
--- a/docs/AGENT-SURFACES.md
+++ b/docs/AGENT-SURFACES.md
@@ -32,6 +32,8 @@ customer-experience builder installed
data-analytics builder installed
corporate-strategy builder installed
security builder installed
+it-operations builder installed
+pmo builder installed
repo-meta builder installed
legal-risk-review reviewer installed
security-review reviewer installed
@@ -93,6 +95,14 @@ plugins/data-analytics/**
plugins/corporate-strategy/**
```
+```surface:it-operations
+plugins/it-operations/**
+```
+
+```surface:pmo
+plugins/pmo/**
+```
+
```surface:security
plugins/security/**
```
diff --git a/docs/DECISION-LOG.md b/docs/DECISION-LOG.md
index fbd7ee2..7148ddc 100644
--- a/docs/DECISION-LOG.md
+++ b/docs/DECISION-LOG.md
@@ -741,3 +741,85 @@ exactly that mistake in miniature.
product with a reason for a hub, and it is the same moment the trademark question in D22 needs a
proper answer rather than a caveat. Prefer `.dev` then — correct signal for developer tooling and
HTTPS-only — or a modified name over a degraded TLD.
+
+---
+
+## D26. Where project management lives — ✅ Resolved
+
+Project management existed only as a single `program-management` skill inside `operations`. The
+question raised was whether
+discipline belongs in silos inside each department or as an enterprise function.
+
+- (a) **Siloed.** Each department carries its own project management guidance.
+- (b) **Inside `operations`.** Expand the COO's department to hold the discipline.
+- **(c) A separate `pmo` department reporting to the COO.** ← **chosen**
+
+**Resolution: (c).**
+
+- **(a) fails this repository's founding rule.** `executive:agent-hierarchy` splits by exclusive
+ write surface, not by topic. Project management is a topic crossing all sixteen departments, so
+ siloing it produces sixteen near-identical skills — precisely the duplication that forced the
+ earlier consolidation.
+- **(c) over (b) on installability.** The premise of the marketplace is installing only what you
+ need. Someone who wants portfolio governance and stage gates should not have to take
+ `supply-chain-and-logistics` and `vendor-management` with it. An EPMO is also a distinct function
+ in practice, with its own head, rather than a subset of operations.
+
+**The `program-management` skill moved from `operations` to `pmo:program-management`.** Worth doing
+at this moment specifically: the repository published today with no external installs, so the
+address is still free
+to change. Once someone has the department installed and the address referenced, it is not — the same
+timing logic as the rename in D22 and the licence in D21. Verified no reference to the old address
+survives anywhere in the tree.
+
+**Reporting line: the COO**, reflected in the org chart. The EPMO governs delivery across the
+organization; it does not own the functions whose work it governs.
+
+**Boundaries stated in the skills rather than left to collide.** `pmo:portfolio-governance` handles
+resource contention across projects while `operations:capacity-and-demand-planning` handles
+operational throughput; `pmo:dependency-and-risk-management` handles delivery risk while
+`legal-risk:enterprise-risk` owns the enterprise framework.
+
+---
+
+## D27. Splitting CIO-side IT operations out of `technology` — ✅ Resolved
+
+`technology` was labelled "CTO / CIO" and held twelve skills, all of them software development
+workflow. The request to add help desk, network administration and system administration forced the
+question of whether those belong in the same department.
+
+- (a) **Add them to `technology`.** One department, around twenty-five skills.
+- **(b) Split: `technology` for the CTO side, a new `it-operations` for the CIO side.** ← **chosen**
+- (c) Leave corporate IT out of the catalogue.
+
+**Resolution: (b).**
+
+- **They are different functions with different audiences.** Product engineering and corporate IT
+ share a reporting line in some organizations and almost nothing else. Bundled, a SaaS engineering
+ team installing `technology` receives deskside support skills it will never open, and an IT
+ director receives worktree workflow they will never open. The split is what makes both installable
+ without noise.
+- **The combined "CTO / CIO" label was papering over a real division**, and the catalogue was
+ honest about only one half of it.
+
+**What moved where.** `technology` gained `solution-architecture`, `api-design`,
+`technical-debt-management`, `cloud-infrastructure`, `observability-and-reliability` and
+`release-and-deployment`, reaching eighteen. `it-operations` is new with seven. `data-engineering`
+went to `data-analytics` rather than `technology`, because pipelines belong beside `data-modeling`
+and `data-governance` under the CDO.
+
+**Overlaps resolved explicitly inside the skills**, since unstated boundaries are what forced the
+earlier consolidation:
+
+- `security:access-and-identity` owns access **policy**;
+ `it-operations:identity-lifecycle-administration` owns **execution** of joiner-mover-leaver.
+- `operations:business-continuity-and-resilience` owns recovery objectives and the business process;
+ `it-operations:backup-and-recovery` owns the technical restore that delivers against them.
+- `technology:cloud-infrastructure` owns cloud environment design;
+ `it-operations:systems-administration` owns operating the systems the company runs on.
+- `security:vulnerability-management` decides what is urgent to patch;
+ `it-operations:systems-administration` executes the cadence.
+
+**Also fixed here.** Every agent charter carried a hardcoded skill count — `finance` claimed four
+while holding nine. The count added nothing and rotted silently, so it was removed rather than
+updated to a number that would rot again.
diff --git a/docs/assets/social-card.html b/docs/assets/social-card.html
index 0d417c2..7b47db5 100644
--- a/docs/assets/social-card.html
+++ b/docs/assets/social-card.html
@@ -69,8 +69,8 @@
<div class="rule"></div>
<div class="meta">
- <b>14</b> departments <span class="sep">/</span>
- <b>116</b> skills <span class="sep">/</span>
+ <b>16</b> departments <span class="sep">/</span>
+ <b>135</b> skills <span class="sep">/</span>
MIT <span class="sep">/</span> for Claude Code
</div>
diff --git a/docs/assets/social-preview.png b/docs/assets/social-preview.png
index ce6b299..db7d4d5 100644
Binary files a/docs/assets/social-preview.png and b/docs/assets/social-preview.png differ
diff --git a/docs/org-chart.md b/docs/org-chart.md
index a658dbb..0b09db9 100644
--- a/docs/org-chart.md
+++ b/docs/org-chart.md
@@ -29,21 +29,23 @@ than into the function they oversee.
| Department | Function | Executive | Skills |
|---|---|---|---|
| `executive` | Office of the CEO | Chief Executive | 6 |
-| `technology` | Technology | CTO / CIO | 12 |
+| `technology` | Technology | CTO / CIO | 18 |
| `security` | Security | CISO | 6 · reviewer-class |
+| `it-operations` | IT Operations | CIO | 7 |
| `product` | Product | CPO | 9 |
| `marketing` | Marketing | CMO | 17 |
| `demand-generation` | Demand Generation | CMO | 11 |
| `revenue` | Revenue | CRO | 8 |
| `finance` | Finance | CFO | 9 |
-| `operations` | Operations | COO | 9 |
+| `operations` | Operations | COO | 8 |
+| `pmo` | Programme Management Office | EPMO / COO | 6 |
| `customer-experience` | Customer Experience | CCO | 5 |
-| `data-analytics` | Data & Analytics | CDO | 5 |
+| `data-analytics` | Data & Analytics | CDO | 6 |
| `corporate-strategy` | Corporate Strategy | CSO | 5 |
| `people` | People | CHRO | 9 |
| `legal-risk` | Legal & Risk | CLO / CCO | 5 · reviewer-class |
-14 departments, 116 skills.
+16 departments, 135 skills.
<!-- END GENERATED: departments -->
## Remaining gaps
diff --git a/plugins/data-analytics/skills/data-engineering/SKILL.md b/plugins/data-analytics/skills/data-engineering/SKILL.md
new file mode 100644
index 0000000..cd653c6
--- /dev/null
+++ b/plugins/data-analytics/skills/data-engineering/SKILL.md
@@ -0,0 +1,59 @@
+---
+name: data-engineering
+description: Builds and operates data pipelines — ingestion, transformation, orchestration, quality testing, and reliability of data delivery. Use this to design or debug a pipeline, decide batch versus streaming, add data quality checks, handle late or duplicate data, or work out why a dashboard's numbers changed without anyone changing the dashboard.
+---
+
+# Data engineering
+
+Pipelines are production systems whose failures are quiet. A broken service pages someone; a broken
+pipeline produces plausible numbers that people act on for a week.
+
+This is movement and transformation. Schema and semantics belong to `data-analytics:data-modeling`,
+policy and stewardship to `data-analytics:data-governance`.
+
+## Land raw, transform downstream
+
+Keep an immutable copy of source data exactly as received. Transformation logic will be wrong at some
+point, and raw data is what lets you reprocess rather than re-request from a source that may no
+longer have it.
+
+Business logic belongs downstream where it is visible and testable, not buried in ingestion. The
+exception is transformation required for privacy — minimisation, pseudonymisation, dropping fields
+you have no basis to hold — which belongs at ingest precisely because raw storage is what the
+obligation attaches to. See `legal-risk:privacy-and-data-protection`.
+
+## Idempotence is the property that matters
+
+Every pipeline will be re-run: after a failure, after a fix, after a late-arriving correction. A
+re-run that double-counts is worse than a failure, because it produces a wrong answer silently.
+
+Design for exactly-once effect at the destination — deterministic keys, merges rather than blind
+appends, partitioned overwrites. Then re-running is safe and recovery stops being frightening.
+
+## Late, duplicate and out-of-order data
+
+Real sources deliver all three. Decide explicitly, per pipeline: how late is an event still accepted,
+what happens to one arriving after its window closed, and how duplicates are identified.
+
+Distinguish **event time** from **processing time** and partition on event time. Aggregations built
+on arrival time silently reassign yesterday's activity to today whenever a delivery is delayed.
+
+## Test data, not just code
+
+Unit tests on transformation logic catch the wrong class of failure. Most damage comes from data that
+is valid but wrong. Assert on the data itself, in the pipeline, and fail loudly:
+
+- Row counts within an expected range, not merely non-zero.
+- Uniqueness of keys, and referential integrity across joins.
+- Freshness — the newest record is recent enough to be meaningful.
+- Distribution shifts in important columns.
+
+A silent failure is worse than a loud one. Prefer stopping the pipeline to publishing data you do not
+trust.
+
+## Never
+
+- Transform on ingest for business reasons and discard the raw copy.
+- Build a pipeline whose re-run double-counts.
+- Aggregate on processing time when event time is available.
+- Let a pipeline fail silently and publish stale data as current.
diff --git a/plugins/it-operations/.claude-plugin/plugin.json b/plugins/it-operations/.claude-plugin/plugin.json
new file mode 100644
index 0000000..4254407
--- /dev/null
+++ b/plugins/it-operations/.claude-plugin/plugin.json
@@ -0,0 +1,16 @@
+{
+ "name": "it-operations",
+ "description": "Corporate IT: service desk, systems and network administration, endpoints, assets, identity lifecycle, and backup and recovery.",
+ "version": "1.0.0",
+ "author": {
+ "name": "Chris Brock"
+ },
+ "repository": "https://github.com/cbrock84/headcount",
+ "keywords": [
+ "it-operations",
+ "service-desk",
+ "sysadmin",
+ "network",
+ "endpoint-management"
+ ]
+}
diff --git a/plugins/it-operations/skills/backup-and-recovery/SKILL.md b/plugins/it-operations/skills/backup-and-recovery/SKILL.md
new file mode 100644
index 0000000..3cdc2c0
--- /dev/null
+++ b/plugins/it-operations/skills/backup-and-recovery/SKILL.md
@@ -0,0 +1,63 @@
+---
+name: backup-and-recovery
+description: Protects and restores data — backup coverage and scope, retention, immutability against ransomware, and proving restores actually work. Use this to design a backup regime, verify restores, plan retention, protect backups from ransomware, or recover from data loss.
+---
+
+# Backup and recovery
+
+Nobody wants backups; they want restores. The distinction is not pedantic — organizations discover
+the difference during the only event that matters.
+
+Recovery objectives and which processes must survive are set by
+`operations:business-continuity-and-resilience`. This skill delivers against them.
+
+## Coverage is where it fails first
+
+Most backup gaps are things nobody thought to include: a database somebody stood up outside the
+standard process, configuration that only exists in a running system, data in a SaaS platform assumed
+to be the vendor's responsibility, or a developer's machine holding the only copy of something.
+
+Reconcile backup coverage against the asset register from
+`it-operations:it-asset-management` on a cadence and treat the difference as a finding. An untested
+assumption of coverage is the normal state of affairs.
+
+Note that SaaS providers protect against **their** failures, not against your deletion or a malicious
+insider. Read what the contract actually commits to, rather than what the marketing implies.
+
+## The 3-2-1 shape, and why the offline copy matters
+
+Three copies, two media or platforms, one off-site — and, since ransomware, **one immutable or
+offline**.
+
+Modern ransomware deliberately targets backups first, using the credentials it found on the way in.
+A backup system reachable with production credentials will be encrypted alongside production.
+Immutable storage or genuinely offline copies are what survive this, and it is the difference
+between an outage and an extinction event.
+
+## Retention is a policy decision, not a storage one
+
+Retention has to satisfy operational recovery, legal and regulatory obligations, and data protection
+requirements — which pull in opposite directions. Data protection law obliges deletion of personal
+data you no longer have a basis to keep, and indefinite backup retention conflicts with that
+directly. Settle it with `legal-risk:privacy-and-data-protection`.
+
+Know how you would satisfy a deletion request that touches backups, before one arrives.
+
+## Test restores, or you have nothing
+
+A backup job reporting success proves a file was written. It says nothing about whether the data is
+complete, uncorrupted, or restorable in a usable time.
+
+Test on a schedule, restore to a separate environment, and verify the application actually works on
+the restored data rather than that the bytes arrived. Record how long it took — that measurement is
+the only honest input to an RTO, and it is invariably longer than assumed.
+
+Test the full-scale case at least annually. Restoring one file proves the mechanism; restoring the
+system proves the plan.
+
+## Never
+
+- Report backup health from job success rather than tested restores.
+- Leave backups reachable with production credentials.
+- Set retention without reconciling legal obligation against deletion duty.
+- Quote an RTO you have not measured by actually restoring.
diff --git a/plugins/it-operations/skills/endpoint-management/SKILL.md b/plugins/it-operations/skills/endpoint-management/SKILL.md
new file mode 100644
index 0000000..c96ae03
--- /dev/null
+++ b/plugins/it-operations/skills/endpoint-management/SKILL.md
@@ -0,0 +1,60 @@
+---
+name: endpoint-management
+description: Manages laptops, desktops and mobile devices — enrolment, configuration, patching, software distribution, and lost or compromised devices. Use this to set up device management, standardise builds, roll out software or an OS upgrade, handle a lost device, or bring an unmanaged fleet under control.
+---
+
+# Endpoint management
+
+Endpoints are the most exposed and least controlled part of the estate: they leave the building, run
+arbitrary software, and are operated by people whose job is not IT.
+
+## Enrolment is the control point
+
+A device that never enrolled is a device with no patching, no encryption guarantee, and no remote
+wipe. Enrolment must be a precondition of access to company data, not a request made afterwards.
+
+Automate it from procurement so a device is enrolled before the user opens it. Manual enrolment as a
+post-delivery step is skipped exactly when the desk is busy.
+
+Handle personal devices as a deliberate policy decision, not an accident. If personal devices reach
+company data, either manage the work container or restrict what they can reach — and be explicit with
+people about what the organization can and cannot see on their own hardware, because ambiguity there
+destroys trust quickly.
+
+## A small number of standard builds
+
+Every additional build variant multiplies testing, support and failure modes. Converge on few, and
+handle exceptions by adding software to a standard build rather than by creating a new one.
+
+Enforce the security baseline through configuration policy rather than instruction: disk encryption
+on, screen lock, firewall, up-to-date agents. Anything relying on a user to configure it is
+configured on some devices.
+
+## Patch on a cadence with a deadline
+
+Endpoints patch worse than servers because they are off, asleep, or the user keeps deferring. Allow
+deferral with a hard deadline and force after it, and communicate the deadline in advance — an
+unexpected forced reboot during a customer call is what teaches people to avoid management.
+
+Report coverage as a percentage of the fleet, and specifically chase the long tail. The devices that
+never appear in patch reports are usually the interesting ones: travelling users, spares, and the
+machine in a cupboard still holding a domain account.
+
+## Lost, stolen, or leaving
+
+Have the sequence ready in advance: lock, locate if possible, wipe, revoke credentials and sessions,
+and record what data was on it for `legal-risk:privacy-and-data-protection` to assess notification.
+
+Encryption is what turns a lost laptop from an incident into paperwork. Verify enforcement
+continuously rather than trusting the policy is applied — the device where it silently failed is the
+one that gets left in a taxi.
+
+Departures are coordinated with `people:onboarding-and-offboarding`, with asset return tracked
+against `it-operations:it-asset-management`.
+
+## Never
+
+- Allow company data onto a device that never enrolled.
+- Rely on users to apply security configuration.
+- Allow indefinite patch deferral.
+- Assume encryption is on without verifying it per device.
diff --git a/plugins/it-operations/skills/identity-lifecycle-administration/SKILL.md b/plugins/it-operations/skills/identity-lifecycle-administration/SKILL.md
new file mode 100644
index 0000000..eec8c4c
--- /dev/null
+++ b/plugins/it-operations/skills/identity-lifecycle-administration/SKILL.md
@@ -0,0 +1,62 @@
+---
+name: identity-lifecycle-administration
+description: Executes joiner, mover and leaver processes — provisioning, group membership, access changes on role change, and complete deprovisioning. Use this to set up or fix joiner-mover-leaver, deprovision someone completely, clean up accumulated access, audit group membership, or find accounts that outlived their owners.
+---
+
+# Identity lifecycle administration
+
+This is execution: creating, changing and removing access as people arrive, move and leave.
+**Policy — what a role should be entitled to, and least privilege — belongs to
+`security:access-and-identity`.** This skill runs the process that policy defines, and the gap
+between the two is where most access problems live.
+
+## Joiners
+
+Provision from the role, not by copying a colleague. Copying is the single largest source of
+privilege accumulation: it inherits everything that person collected, including access they should
+not have had, and it propagates that indefinitely.
+
+Define role-based bundles for the common cases so a standard joiner is one action, and treat
+anything outside them as an exception requiring approval. Exceptions are fine; unrecorded exceptions
+are not.
+
+Time provisioning to be complete before the start date — coordinated through
+`people:onboarding-and-offboarding`.
+
+## Movers are the neglected case
+
+Leavers get attention because someone is going. Movers do not, and so access accrues: the person who
+has worked in three departments has permissions from all three, and nobody ever removed the first
+two.
+
+Treat a role change as a **revoke and re-provision**, not an addition. This is the single highest-
+value fix available in most organizations, and it is almost always skipped because the person is
+still present and nothing appears broken.
+
+## Leavers, completely
+
+Disable promptly at the agreed time, then work a checklist that reaches past the directory: systems
+outside single sign-on, local accounts, shared credentials the person knew, API keys and tokens they
+created, external services procured on a personal login, and any mail or calendar delegation.
+
+The gap is almost always the systems identity management does not reach. Maintain the list of them
+explicitly rather than discovering it during an audit.
+
+Preserve rather than delete where there is any prospect of investigation or legal hold — deletion is
+irreversible and occasionally very expensive.
+
+## Recertify, and act on it
+
+Periodically, system owners confirm who should still have access. This is worth doing only if
+non-response defaults to removal; where non-response means retain, recertification becomes a
+formality that certifies whatever exists.
+
+Hunt specifically for orphaned accounts — accounts with no owner, service accounts nobody claims,
+and credentials that have not been used in months but still work.
+
+## Never
+
+- Provision by copying an existing user.
+- Add access on a role change without removing the old.
+- Consider a leaver deprovisioned when the directory account is disabled.
+- Run recertification where non-response means retain.
diff --git a/plugins/it-operations/skills/it-asset-management/SKILL.md b/plugins/it-operations/skills/it-asset-management/SKILL.md
new file mode 100644
index 0000000..bad0240
--- /dev/null
+++ b/plugins/it-operations/skills/it-asset-management/SKILL.md
@@ -0,0 +1,58 @@
+---
+name: it-asset-management
+description: Tracks hardware and software assets through their life — procurement, ownership, licensing, refresh, and disposal. Use this to build an asset register, prepare for a software audit, plan a refresh cycle, control licence spend, or dispose of equipment safely.
+---
+
+# IT asset management
+
+The register exists to answer operational questions: what do we have, who has it, is it supported, is
+it licensed, and when does it need replacing. An inventory that answers none of those is an
+accounting artefact.
+
+## One register, reconciled against reality
+
+A register maintained by hand diverges immediately. Feed it from discovery — what is actually on the
+network and enrolled in management — and reconcile against procurement and finance records.
+
+The valuable output is the **discrepancy list**: assets in the register that discovery cannot find,
+and devices discovery finds that the register does not know about. The second category is the
+security problem, since an unknown device is unmanaged by definition.
+
+## Ownership, not just location
+
+Every asset needs a named accountable person. "The engineering team" is not an owner; when the device
+needs patching, returning or replacing, a team does not answer.
+
+Track state through the lifecycle — ordered, in stock, assigned, in repair, retired, disposed — and
+require the state change at the moment of handover. A register updated in batches is a register that
+is wrong between batches, which is most of the time.
+
+## Software licensing
+
+Under-licensing is a financial and legal exposure that surfaces at audit; over-licensing is money
+spent on nothing, and it is usually the larger number.
+
+Reconcile entitlements against actual installs and actual use. Reclaiming licences from people who
+stopped using a tool typically funds a meaningful fraction of the next renewal, and the data for it
+already exists.
+
+Watch licence models that change cost with infrastructure — per-core, per-socket, per-user in a
+system that provisions freely. A routine infrastructure change can multiply a licence bill with no
+procurement decision anywhere in the path.
+
+## Refresh and disposal
+
+Plan refresh on a cycle and budget it as a steady cost through
+`finance:budgeting-and-forecasting`. Refresh driven by failure produces an unpredictable expense and
+a worse experience, and it always arrives at the wrong moment.
+
+Disposal is where data escapes. Require certified destruction or verified wipe, keep the certificate,
+and treat storage devices as data until proven otherwise. A drive in a cupboard nobody logged is a
+breach with no date attached.
+
+## Never
+
+- Maintain a register by hand and trust it.
+- Record a team as an asset owner.
+- Renew licences without reconciling against actual use.
+- Dispose of storage without evidence of destruction or wipe.
diff --git a/plugins/it-operations/skills/network-administration/SKILL.md b/plugins/it-operations/skills/network-administration/SKILL.md
new file mode 100644
index 0000000..910a7ae
--- /dev/null
+++ b/plugins/it-operations/skills/network-administration/SKILL.md
@@ -0,0 +1,60 @@
+---
+name: network-administration
+description: Designs and operates the corporate network — segmentation, remote access, wireless, DNS and addressing, and diagnosing network problems. Use this to segment a network, set up or fix remote access, diagnose intermittent connectivity, plan addressing or DNS, or assess whether the network's trust assumptions still hold.
+---
+
+# Network administration
+
+The network is the substrate everything else assumes works. It gets attention when it fails and is
+otherwise expected to be invisible, which is why its design debts persist for years.
+
+## Segment by trust, and mean it
+
+A flat network means one compromised laptop reaches the finance server. Segmentation is the highest-
+value structural control available and the most commonly deferred.
+
+Separate at minimum: user devices, servers, management interfaces, guest, and anything unmanaged —
+printers, cameras, building systems, contractor equipment. That last category is the recurring entry
+point, because it is rarely patched and rarely owned.
+
+Default deny between segments, and permit specific flows. Rules that accumulate without review become
+an allow-all with extra steps; review them on a cadence and remove what no longer has a reason.
+
+## Remote access
+
+The perimeter stopped being a perimeter when the workforce and the workloads left it. Treat network
+location as weak evidence of trust: being on the corporate network should not by itself grant access
+to anything sensitive.
+
+Prefer per-application access over full network access. A remote user needing one internal
+application does not need a route to the entire internal estate, which is what a traditional VPN
+grants by default.
+
+Authentication and authorization policy belongs to `security:access-and-identity`; this skill
+implements the network path.
+
+## DNS and addressing are load-bearing
+
+DNS failure presents as everything being broken, which is why it is misdiagnosed for the first
+twenty minutes of many incidents. Run it redundantly, monitor resolution from the client's
+perspective rather than the server's, and keep records under change control.
+
+Plan addressing with room to grow and document it. Overlapping private ranges is the problem that
+surfaces years later during an acquisition or a site merge and is expensive at exactly that moment.
+
+## Diagnose in layers
+
+Work bottom-up and prove each layer before moving on: physical, then addressing, then routing, then
+name resolution, then the application. Most misdiagnosis comes from starting at the application
+because that is where the complaint originated.
+
+Intermittent problems are the hard case and need data over time, not a test at the moment someone
+complains. Capture continuously at the affected point; a test that passes while nobody is suffering
+proves nothing.
+
+## Never
+
+- Run a flat network and rely on host controls alone.
+- Grant full network access where application access would do.
+- Treat network location as sufficient evidence of trust.
+- Diagnose from the application layer down.
diff --git a/plugins/it-operations/skills/service-desk/SKILL.md b/plugins/it-operations/skills/service-desk/SKILL.md
new file mode 100644
index 0000000..659fda7
--- /dev/null
+++ b/plugins/it-operations/skills/service-desk/SKILL.md
@@ -0,0 +1,61 @@
+---
+name: service-desk
+description: Runs the IT service desk — intake, triage, prioritisation, escalation, knowledge, and the metrics that improve service rather than distort it. Use this to set up or fix a service desk, design ticket priority and escalation, reduce repeat contacts, structure a knowledge base, or work out why a desk hitting its targets still frustrates everyone.
+---
+
+# Service desk
+
+The service desk is where the whole IT organization is judged, usually by people having a bad day.
+Most of what makes it good is intake discipline and honest measurement.
+
+## Intake determines everything downstream
+
+Capture enough at first contact to route correctly and act without a second exchange: who, what
+they were doing, what happened, what they expected, and how blocked they are.
+
+Give the requester a single channel that works. Multiple half-supported channels — a queue, a chat, a
+shoulder tap, a manager's direct message — mean the loudest request wins rather than the most urgent,
+and the desk's workload becomes unmeasurable because most of it is invisible.
+
+## Priority is impact against urgency
+
+Priority is not a feeling. Define it on two axes — how many people are affected and how blocked they
+are — and publish the matrix so it can be applied consistently rather than argued each time.
+
+Keep **incidents** (something broken) separate from **requests** (something wanted). They have
+different clocks, different queues, and different success conditions, and merging them lets routine
+requests bury outages.
+
+Escalation should be time-based and automatic. Relying on someone to notice a ticket ageing means the
+tickets that age are the ones nobody is watching.
+
+## Measure service, not activity
+
+Tickets closed measures activity, and optimising it produces premature closure and reopened tickets.
+Better:
+
+- **First-contact resolution** — resolved without a handoff.
+- **Time to resolution at the percentile users feel**, not the mean.
+- **Reopen rate** — the direct check on premature closure.
+- **Repeat contacts for the same underlying cause** — the number that points at problems worth
+ eliminating.
+
+Never target an individual on volume. It reliably produces cherry-picking of easy tickets and quiet
+avoidance of hard ones.
+
+## Eliminate demand rather than absorbing it
+
+A desk that handles the same failure two hundred times has done two hundred units of work and solved
+nothing. Cluster tickets by underlying cause and feed the top few into permanent fixes — a
+configuration change, a fix at source, or self-service that genuinely resolves.
+
+Knowledge articles should be written for the person with the problem, not the person who fixed it:
+the symptom as experienced, then the steps. An article filed under the internal cause is not
+findable by anyone who does not already know the answer.
+
+## Never
+
+- Run parallel unofficial intake channels and treat the ticket queue as the workload.
+- Merge incidents and requests into one queue.
+- Target individuals on ticket volume.
+- Close a recurring issue repeatedly without escalating it as a problem to eliminate.
diff --git a/plugins/it-operations/skills/systems-administration/SKILL.md b/plugins/it-operations/skills/systems-administration/SKILL.md
new file mode 100644
index 0000000..94f938a
--- /dev/null
+++ b/plugins/it-operations/skills/systems-administration/SKILL.md
@@ -0,0 +1,60 @@
+---
+name: systems-administration
+description: Runs servers and corporate systems — patching, configuration baselines, change control, capacity, and the routine that prevents incidents. Use this to establish a patching cadence, standardise server configuration, plan a maintenance window, decide change control for infrastructure, or clean up systems that have drifted from any known state.
+---
+
+# Systems administration
+
+Well-run systems are boring. The work is in the routine that keeps them that way, and almost every
+serious incident traces back to a routine that was skipped.
+
+Cloud environment design belongs to `technology:cloud-infrastructure`; this is operating the systems
+the company runs on.
+
+## Configuration baselines and drift
+
+Every system class needs a defined baseline: build, hardening, agents, logging, accounts. Systems
+built by hand from memory diverge immediately and cannot be reasoned about as a group.
+
+Drift is the real enemy. Detect it continuously and correct rather than document — a system that no
+longer matches its baseline is a system whose behaviour under patching or failover is unknown.
+
+The strongest form is disposability: rebuild rather than repair. A system you can rebuild in an hour
+never accumulates the sediment of a decade of manual fixes.
+
+## Patching as a cadence
+
+Set a regular, predictable window and hold it. Ad hoc patching means patching happens when someone
+worries, which is never in proportion to actual risk.
+
+Tier by exposure: internet-facing systems on the shortest cycle, then internal, then isolated.
+Emergency patching is a separate path with its own authority, used for actively exploited
+vulnerabilities — `security:vulnerability-management` decides what is urgent, this skill executes it.
+
+Track **coverage**, not activity. "Patching is running" is not an answer; "97% of servers are within
+30 days, here are the twelve that are not and why" is.
+
+## Change control proportionate to risk
+
+Heavyweight approval for trivial changes produces circumvention, and circumvention produces
+unrecorded changes, which is worse than no process.
+
+Tier it: standard pre-approved changes, normal changes with review, emergency changes with
+after-the-fact record. Every change needs an owner, a back-out plan, and a record — the back-out plan
+being the part most often assumed rather than written.
+
+Maintenance windows exist to make disruption predictable. Announce them, keep them, and finish inside
+them.
+
+## Know what you have
+
+An unmanaged system is a system nobody patches. Reconcile what is running against
+`it-operations:it-asset-management` regularly, and treat anything unaccounted for as urgent — the
+server nobody owns is the one still running an unsupported operating system.
+
+## Never
+
+- Repair a drifted system without correcting the baseline that let it drift.
+- Patch on worry rather than cadence.
+- Make a change with no back-out plan.
+- Leave a discovered unmanaged system unclaimed.
diff --git a/plugins/pmo/.claude-plugin/plugin.json b/plugins/pmo/.claude-plugin/plugin.json
new file mode 100644
index 0000000..be1d4ba
--- /dev/null
+++ b/plugins/pmo/.claude-plugin/plugin.json
@@ -0,0 +1,16 @@
+{
+ "name": "pmo",
+ "description": "Enterprise programme management office: portfolio governance, programme and project delivery, dependencies and delivery risk, benefits realization, and adoption.",
+ "version": "1.0.0",
+ "author": {
+ "name": "Chris Brock"
+ },
+ "repository": "https://github.com/cbrock84/headcount",
+ "keywords": [
+ "pmo",
+ "portfolio",
+ "project-management",
+ "programme-management",
+ "delivery"
+ ]
+}
diff --git a/plugins/pmo/skills/benefits-realization/SKILL.md b/plugins/pmo/skills/benefits-realization/SKILL.md
new file mode 100644
index 0000000..a37e5d9
--- /dev/null
+++ b/plugins/pmo/skills/benefits-realization/SKILL.md
@@ -0,0 +1,61 @@
+---
+name: benefits-realization
+description: Ensures projects deliver the value they were approved on — defining measurable benefits, baselining, tracking after delivery, and honest post-implementation review. Use this to define benefits for a business case, set a baseline, track whether value actually landed, or run a post-implementation review that produces something useful.
+---
+
+# Benefits realization
+
+Projects are approved on promised benefits and closed on delivered scope. The gap between those two
+sentences is why organizations repeat expensive mistakes with confidence.
+
+## Define benefits so they can be disproved
+
+A benefit that cannot fail to be claimed is not a benefit. Each needs a measure, a current baseline,
+a target, a date by which it should appear, and an owner who is accountable **after** the project
+closes — usually the operational owner, not the project manager, who has moved on.
+
+Distinguish honestly:
+
+- **Cashable** — the budget actually reduces. Someone can point at the line.
+- **Non-cashable** — time is released. Real, but only becomes value if that time is redeployed to
+ something that matters, which is a separate management act nobody schedules.
+- **Cost avoidance** — a future cost does not occur. Legitimate and unverifiable, so treat claims
+ sceptically.
+- **Non-financial** — risk reduction, compliance, experience. Often the actual reason. Say so rather
+ than manufacturing a financial number nobody believes.
+
+The most common failure is a business case padded with non-cashable savings presented as though the
+budget will fall. It will not, and the credibility loss lands on the next case.
+
+## Baseline before you change anything
+
+A baseline captured after go-live is not a baseline. Measure first, and record how it was measured —
+by the time anyone checks, the method will be disputed and nobody will remember.
+
+## Tracking happens after the project ends
+
+Benefits appear months after delivery, when the project team has dispersed and attention has moved.
+This is precisely why it does not happen, and why it needs to be owned by the operational line and
+scheduled at approval rather than intended.
+
+Set review points at meaningful intervals — ninety days, six months, a year — and hold them
+regardless of what the answer looks like.
+
+## Post-implementation review worth the hour
+
+Two questions: did the benefits appear, and would we make the same decision knowing what we now know?
+
+Include estimation accuracy, since the systematic bias in an organization's estimates is one of the
+most useful things it can know about itself and is discoverable only by looking back.
+
+Make it non-punitive or it will produce nothing true. A review that damages careers produces reviews
+that say the project was a success. Feed the findings back to
+`pmo:portfolio-governance` and `finance:capital-allocation`, which are where the next set of
+approvals gets made.
+
+## Never
+
+- Approve a case whose benefits have no owner after the project closes.
+- Present non-cashable savings as budget reduction.
+- Baseline after implementation.
+- Run a review that punishes honesty.
diff --git a/plugins/pmo/skills/change-and-adoption/SKILL.md b/plugins/pmo/skills/change-and-adoption/SKILL.md
new file mode 100644
index 0000000..3e119ae
--- /dev/null
+++ b/plugins/pmo/skills/change-and-adoption/SKILL.md
@@ -0,0 +1,68 @@
+---
+name: change-and-adoption
+description: Gets people to actually use what was delivered — stakeholder analysis, communication, training, resistance, and measuring adoption. Use this to plan a rollout, recover an implementation nobody is using, handle resistance to a change, sequence communications, or work out why a technically successful project changed nothing.
+---
+
+# Change and adoption
+
+The characteristic expensive failure is a system delivered on time, on budget, to specification, and
+not used. The project succeeded and the investment did not.
+
+## Map who is affected and what it costs them
+
+Stakeholder analysis usually stops at influence and interest. The operative question is what each
+group **loses**: status, autonomy, expertise that took years to build, a workaround they were proud
+of, or simply a routine that worked.
+
+Resistance is almost always rational from where the person stands. Treating it as ignorance produces
+more communication aimed at the wrong problem, and confirms to the affected group that nobody
+understands their work.
+
+## Communicate in the order people need
+
+The sequence that works is why, then what, then how, then when — and organizations reliably lead with
+what and when, which is the project's perspective rather than the audience's.
+
+State what is changing for **this** audience specifically. A general announcement is heard as not
+applying to anyone in particular.
+
+Be honest about costs. A change presented as pure benefit, where the audience can see the cost, loses
+the credibility needed for everything said afterwards. Naming the downside is what makes the upside
+believable.
+
+## Local credibility beats hierarchy
+
+People adopt what respected colleagues adopt. A message from an executive establishes that the change
+is sanctioned; it does not establish that it is sensible.
+
+Find the people others actually ask, involve them early enough to influence the outcome, and let them
+carry it. Involvement after the decisions are made is recognised as decoration and costs more
+credibility than it buys.
+
+## Train at the moment of use
+
+Training delivered weeks ahead of availability is forgotten. Deliver close to go-live, in the context
+of the real work, with support available in the first days when everyone hits the same three
+obstacles.
+
+`people:learning-and-development` covers building durable capability; this is landing a specific
+change.
+
+## Measure adoption, not deployment
+
+Licences deployed, accounts created and sessions logged measure nothing about whether the work
+changed. Measure the behaviour: is the new process being followed, is the old path still being used,
+have the outcomes moved?
+
+Watch for the workaround. Where people have quietly kept the old spreadsheet, adoption is nominal —
+and the workaround is data about what the new system fails to do, not merely non-compliance.
+
+Adoption is the mechanism by which `pmo:benefits-realization` becomes possible; without it there is
+nothing to realise.
+
+## Never
+
+- Treat resistance as a communication deficit without asking what the change costs.
+- Lead with what and when instead of why.
+- Involve influential users only after the decisions are made.
+- Report adoption from deployment statistics.
diff --git a/plugins/pmo/skills/dependency-and-risk-management/SKILL.md b/plugins/pmo/skills/dependency-and-risk-management/SKILL.md
new file mode 100644
index 0000000..28f9183
--- /dev/null
+++ b/plugins/pmo/skills/dependency-and-risk-management/SKILL.md
@@ -0,0 +1,66 @@
+---
+name: dependency-and-risk-management
+description: Manages delivery risk and cross-team dependencies — identifying, sizing, mitigating and escalating what could stop the work. Use this to build a risk register that gets used, manage dependencies between teams, decide what to escalate and when, or work out why the same risks keep materialising unmanaged.
+---
+
+# Dependency and risk management
+
+This is delivery risk: what could prevent this work from landing. Enterprise risk — the framework,
+appetite and register at company level — is `legal-risk:enterprise-risk`, and the two should not be
+merged.
+
+## Dependencies are commitments or they are wishes
+
+A dependency in your plan that the owning team has not agreed to, with a date they have committed
+to, is a wish. Most plans contain several.
+
+For each: what exactly is needed, from whom by name, by when, and what happens if it is late. Then
+confirm it with the owning team in a way they would recognise as a commitment — an item on their
+plan, not a mention in a meeting.
+
+Track dependencies both ways. Teams reliably track what they are owed and forget what they owe, which
+is why everyone believes they are being let down.
+
+The dangerous ones are **transitive**: your dependency has a dependency you cannot see. Trace at
+least one hop further than feels necessary, particularly where a shared specialist or a single team
+appears repeatedly.
+
+## A risk register people actually use
+
+Most registers are written once for a gate and never opened. What makes one useful:
+
+- **Specific.** "Integration delay" is a topic. "Vendor's API v2 is not released until March; our
+ migration starts in February" is a risk you can act on.
+- **Sized on both axes** — likelihood and impact — because the response differs entirely between a
+ likely nuisance and an unlikely catastrophe.
+- **Owned by someone who can act**, not by the project manager who can only report.
+- **Carrying a decision date** — the point past which mitigation is no longer possible. This is the
+ field most often omitted and the one that makes the register operational rather than decorative.
+
+Review by exception: what changed, what is approaching its decision date. Reading the whole register
+aloud is how registers stop being read.
+
+## Mitigate, or accept explicitly
+
+Four responses: avoid by changing the plan, reduce likelihood or impact, transfer to someone better
+placed to carry it, or accept. Acceptance is legitimate and must be explicit, with a named accepter
+— an unacknowledged acceptance is just an unmanaged risk.
+
+Distinguish mitigation from contingency. Mitigation lowers the chance; contingency is what you do
+when it happens anyway. Serious risks need both, and contingency needs to be prepared before it is
+required.
+
+## Escalate early and specifically
+
+An escalation naming the decision needed, the options, and the date by which it is needed gets
+resolved. A general expression of concern gets acknowledged and nothing happens.
+
+Escalate when the decision exceeds your authority or the decision date is approaching — not when the
+risk has already materialised, at which point it is a status report.
+
+## Never
+
+- Carry a dependency the owning team has not committed to.
+- Log a risk without an owner who can act on it.
+- Accept a risk without naming who accepted it.
+- Escalate a concern without naming the decision required.
diff --git a/plugins/pmo/skills/portfolio-governance/SKILL.md b/plugins/pmo/skills/portfolio-governance/SKILL.md
new file mode 100644
index 0000000..c220441
--- /dev/null
+++ b/plugins/pmo/skills/portfolio-governance/SKILL.md
@@ -0,0 +1,66 @@
+---
+name: portfolio-governance
+description: Governs the portfolio of work — intake, prioritisation, stage gates, resource contention, and stopping things. Use this to set up intake and prioritisation, run a stage gate, decide between competing initiatives, resolve resource contention across projects, or work out why everything is in flight and nothing is finishing.
+---
+
+# Portfolio governance
+
+The portfolio question is not which projects are good. Most proposed work is defensible in isolation.
+It is which projects the organization can actually finish, given that finishing is what produces
+value and starting produces none.
+
+## Intake as a real gate
+
+Without a single front door, work enters through relationships and volume, and the portfolio becomes
+the sum of who asked most persistently.
+
+Require the same minimum from every proposal regardless of who is asking: the outcome sought, the
+evidence it matters, a rough size, the accountable owner, and what will not happen if it proceeds.
+That last one is the honest part — capacity is fixed, so approving anything is declining something
+else, whether or not the decline is ever stated.
+
+## Prioritise against capacity, not against merit
+
+Ranking by value produces a list where everything above the line is approved and the line is
+imaginary. Prioritisation only means something when the cut is made at real, measured delivery
+capacity — see `operations:capacity-and-demand-planning` for the throughput side.
+
+**Limit work in progress.** An organization running twenty concurrent initiatives with capacity for
+eight does not deliver twenty slowly; it delivers roughly eight, considerably later, with the
+overhead of context-switching across all twenty. Fewer things, finished, is faster in wall-clock
+terms — which is counter-intuitive and is why the discipline requires governance rather than good
+intentions.
+
+## Stage gates that can say no
+
+A gate whose only outcome is approval is a status meeting. Each gate must be able to stop, pause, or
+redirect, and needs a named decision-maker with the authority to do it.
+
+Gate on what has been learned since the last one, not on whether documentation was produced. The
+useful question is whether the case still holds now that more is known — and it frequently does not,
+which is exactly the information the gate exists to surface.
+
+## Stopping is the hardest and most valuable act
+
+Organizations start well and stop badly. Sunk cost, sponsor prestige and the discomfort of admitting
+error keep dead projects consuming capacity that the whole portfolio needs.
+
+Make stopping a normal, non-punitive outcome. Where stopping is treated as failure, projects are
+never stopped — they are quietly starved, which is the same cost with none of the released capacity
+and no decision anyone can point to.
+
+## Resource contention
+
+Contention across projects is resolved here, at the portfolio, not by the projects negotiating among
+themselves. Left to negotiation, the outcome reflects seniority of the sponsors rather than value to
+the organization.
+
+Watch for the same scarce specialist appearing on the critical path of several initiatives — the
+most common invisible cause of portfolio-wide slippage.
+
+## Never
+
+- Approve work without naming what it displaces.
+- Set a priority order without a line drawn at real capacity.
+- Run a gate that cannot stop anything.
+- Starve a project instead of stopping it.
diff --git a/plugins/operations/skills/program-management/SKILL.md b/plugins/pmo/skills/program-management/SKILL.md
similarity index 100%
rename from plugins/operations/skills/program-management/SKILL.md
rename to plugins/pmo/skills/program-management/SKILL.md
diff --git a/plugins/pmo/skills/project-delivery/SKILL.md b/plugins/pmo/skills/project-delivery/SKILL.md
new file mode 100644
index 0000000..2692587
--- /dev/null
+++ b/plugins/pmo/skills/project-delivery/SKILL.md
@@ -0,0 +1,65 @@
+---
+name: project-delivery
+description: Plans and delivers a single project — scope, estimation, scheduling, critical path, tracking, and recovering when it slips. Use this to plan a project, build or challenge a schedule, estimate credibly, track progress meaningfully, or recover a project that is late.
+---
+
+# Project delivery
+
+A project is one bounded piece of work with an end. Coordinating several toward a shared outcome is
+`pmo:program-management`.
+
+## Scope by exclusion
+
+Inclusions are agreed easily and understood differently. The exclusions do the work: what this
+project will *not* deliver, written down and acknowledged by the sponsor.
+
+Unwritten exclusions return as assumptions, always late, always framed as something obviously
+included. Fixing that at the end is called scope creep; it is usually a documentation failure at the
+start.
+
+## Estimate as a range, and say what the range means
+
+A single-point estimate is a forecast presented as a commitment. Give a range with the assumptions
+that would move it, and be explicit about confidence.
+
+Estimate the work, not the desired date. Estimates negotiated downward do not change the work; they
+change when you find out, and the finding-out happens at the least recoverable moment.
+
+Decompose until the pieces are comprehensible. Estimating a large unknown produces a number
+correlated with optimism rather than with the work.
+
+## The critical path is where attention belongs
+
+Not everything late matters. Slippage on the critical path moves the end date; slippage elsewhere
+consumes float. Knowing which is which is the difference between useful concern and generalised
+anxiety.
+
+Recalculate as things change — the critical path moves, and a team watching the original one is
+watching the wrong thing.
+
+Hold buffer at the project level rather than padding each task. Padded tasks absorb their own buffer
+and deliver no earlier, because work expands and nobody reports finishing early.
+
+## Track completion, not effort
+
+Percentage complete is self-reported optimism, and it famously stalls at 90%. Track binary completion
+of defined deliverables — done or not done, judged against a definition agreed in advance.
+
+Watch the trend: whether the amount remaining is falling at the rate required. A project where
+remaining work is not decreasing is a project that is late, whatever the reported percentage.
+
+## Recovery
+
+Diagnose first, since remedies do not overlap: scope larger than understood, capacity lower than
+planned, dependencies not delivering, or an estimate that was never realistic.
+
+Then present options with consequences — cut scope and name what, extend and say by how much, or add
+capacity, which late in a project usually slows things further. Re-baseline once, visibly. Serial
+one-week slips destroy credibility far faster than a single honest reset.
+
+## Never
+
+- Agree scope without written exclusions.
+- Present a single-point estimate as a commitment.
+- Report progress as percentage complete.
+- Add people to a late project and expect it to accelerate.
diff --git a/plugins/technology/skills/api-design/SKILL.md b/plugins/technology/skills/api-design/SKILL.md
new file mode 100644
index 0000000..2d41644
--- /dev/null
+++ b/plugins/technology/skills/api-design/SKILL.md
@@ -0,0 +1,59 @@
+---
+name: api-design
+description: Designs interfaces that survive their consumers — resource modelling, errors, versioning, pagination, and compatibility. Use this to design a new API, review one before it ships, decide how to version or deprecate, fix an interface consumers keep misusing, or work out whether a change is breaking.
+---
+
+# API design
+
+An API is a promise you cannot withdraw once someone depends on it. Design accordingly: the cost of
+getting it wrong is paid continuously by everyone who integrates.
+
+## Model the domain, not the database
+
+Expose concepts the consumer thinks in. An interface that mirrors internal table structure leaks
+implementation, breaks whenever storage changes, and forces consumers to reconstruct meaning you
+already had.
+
+Name things as the domain names them. Consistency in naming, casing, date formats and identifier
+style matters more than any individual choice being optimal — an interface that is uniformly
+imperfect is learnable, and one that is inconsistently excellent is not.
+
+## Errors are part of the contract
+
+Most integrations spend most of their code on failure. Give it the same care as the success path:
+
+- **Distinguish machine-readable code from human-readable message.** Consumers branch on the code;
+ the message is for the developer reading logs.
+- **Say what to do about it.** Retryable or not, and after how long.
+- **Never leak internals** — stack traces and SQL in error bodies are a security finding as well as
+ bad design.
+- **Be consistent about which failures are which status.** Validation, authorization, and conflict
+ are different situations and should never share a shape.
+
+## Compatibility
+
+Adding an optional field is safe. Removing a field, renaming one, tightening validation, changing a
+default, or adding a required parameter are all breaking, and the last three break consumers who are
+doing nothing wrong.
+
+Version when you must break, and be explicit about how long the previous version lives. A
+deprecation without a date is a deprecation nobody acts on.
+
+Prefer expansion over versioning where possible: a new optional field costs a consumer nothing, a new
+version costs them a migration.
+
+## Pagination, filtering and limits
+
+Any collection that can grow needs pagination from the first release — retrofitting it is a breaking
+change to every consumer. Prefer cursors over offsets for anything that changes while being read;
+offset pagination silently skips and duplicates records under concurrent writes.
+
+State rate limits in the contract and communicate them in responses. An undocumented limit is
+discovered in the consumer's production incident.
+
+## Never
+
+- Expose internal identifiers or storage structure through the interface.
+- Return errors whose meaning must be inferred from the message text.
+- Tighten validation on an existing endpoint and call it non-breaking.
+- Ship a collection endpoint without pagination.
diff --git a/plugins/technology/skills/cloud-infrastructure/SKILL.md b/plugins/technology/skills/cloud-infrastructure/SKILL.md
new file mode 100644
index 0000000..2f23d2c
--- /dev/null
+++ b/plugins/technology/skills/cloud-infrastructure/SKILL.md
@@ -0,0 +1,65 @@
+---
+name: cloud-infrastructure
+description: Designs and runs cloud infrastructure — environments, infrastructure as code, networking and isolation, scaling, and cost. Use this to design a cloud environment, control infrastructure spend, set up environment separation, plan for scale or region failure, or review infrastructure someone configured by hand.
+---
+
+# Cloud infrastructure
+
+Cloud replaces capital cost with an operating cost that scales with carelessness. The discipline is
+mostly about making the environment reproducible and the spend visible.
+
+## Everything reproducible from code
+
+Infrastructure created by hand cannot be reviewed, reproduced, or recovered. Define it as code,
+review it like code, and apply it through a pipeline rather than from a laptop.
+
+The test: could you rebuild the environment from an empty account, and do you know that because you
+have done it? Untested reproducibility is a belief.
+
+Console access for humans should be read-only in production by default. Write access exists for
+emergencies, is time-bound, and is logged — see `security:access-and-identity` for the policy this
+implements.
+
+## Environments that mean something
+
+Separate environments by blast radius, not by name. Separate accounts or subscriptions give a hard
+boundary; separate namespaces in one account give a soft one that a misconfigured permission
+crosses.
+
+Production data does not belong in lower environments. Where realistic data is needed, mask or
+synthesise it — a copied production database is a breach waiting for a misconfigured bucket, and it
+is one of the most common ways personal data escapes.
+
+## Networking and isolation
+
+Default deny, then open what is needed. Public exposure should be a deliberate, reviewable act rather
+than the residue of a default.
+
+Keep the trust boundary explicit and few: what is reachable from the internet, what is reachable
+between services, what reaches data stores. Most cloud incidents are not exotic — they are a storage
+bucket, a database, or a management interface that was reachable and should not have been.
+
+## Scaling and failure
+
+Scale horizontally where you can and know your actual limits — the database connection ceiling, the
+third-party rate limit, the single-threaded component nobody remembers. Autoscaling in front of a
+hard downstream limit converts a slow system into an outage.
+
+Design for the failure of a single instance and a single zone as routine. Region failure is a
+business continuity decision with a real price attached, made with
+`operations:business-continuity-and-resilience` rather than assumed by engineering.
+
+## Cost
+
+Cost is an architectural property. Attribute spend by team and workload from the start; without
+tagging, cost becomes an unattributable aggregate that only ever gets addressed in a panic.
+
+The usual large wins are unglamorous: idle non-production resources, over-provisioned instances,
+storage nobody deleted, and cross-zone data transfer nobody accounted for.
+
+## Never
+
+- Make a production change by hand that is not reflected in code.
+- Put production data in a lower environment unmasked.
+- Autoscale a tier in front of a hard downstream limit.
+- Run without cost attribution until the bill forces it.
diff --git a/plugins/technology/skills/observability-and-reliability/SKILL.md b/plugins/technology/skills/observability-and-reliability/SKILL.md
new file mode 100644
index 0000000..5e853f4
--- /dev/null
+++ b/plugins/technology/skills/observability-and-reliability/SKILL.md
@@ -0,0 +1,62 @@
+---
+name: observability-and-reliability
+description: Makes systems debuggable and reliably operable — instrumentation, alerting that is worth waking for, service objectives, and learning from failure. Use this to instrument a service, fix alerting that is ignored, set error budgets or reliability targets, prepare for on-call, or run a blameless post-incident review.
+---
+
+# Observability and reliability
+
+Monitoring tells you a thing you predicted is happening. Observability lets you ask a question you
+did not anticipate. Production failures are mostly the unanticipated kind.
+
+## Instrument for questions you have not thought of yet
+
+Emit structured events with enough context to slice afterwards — request identifiers, user or tenant,
+version, dependency, outcome, duration. Free-text logs are unsearchable at volume and become
+expensive noise.
+
+Propagate a correlation identifier across every hop. Without it, a distributed system is a set of
+independent stories and reconstructing one request is manual archaeology.
+
+Measure what the user experiences at the percentile they experience it. A p50 latency graph is
+mostly a graph of the people who were not affected.
+
+## Alert on symptoms, not causes
+
+Alert when users are affected or imminently will be. High CPU is not an alert; requests failing or
+slowing is. Cause-based alerting produces pages for conditions the system handled and no page for
+novel failures that hurt.
+
+Every alert must be **actionable, urgent and specific**. If the recipient's honest response is to
+look and close it, delete the alert — it is training the on-call to ignore the page, and the ignored
+page is eventually the real one.
+
+Alert fatigue is the actual reliability risk in most organizations. Fewer, better alerts beat
+coverage.
+
+## Objectives and error budgets
+
+Set service level objectives from what users need, then treat the remainder as a budget to spend.
+This converts a sterile argument between shipping and stability into arithmetic: budget remaining
+means ship, budget exhausted means the next work is reliability.
+
+Keep the internal objective tighter than any external commitment made through
+`operations:service-level-management`, so you find out before the customer does.
+
+## Learn from incidents
+
+Post-incident review exists to find what made the failure possible and hard to detect, not who
+touched it last. Human error is a starting question, never the finding: what made the error easy,
+and why did nothing catch it?
+
+Track the time to *detect* separately from time to resolve. Long detection is an observability
+defect, and it is the part that repeats.
+
+Produce a small number of real actions with owners and dates. A review generating fifteen actions
+generates none.
+
+## Never
+
+- Page a human for something they cannot act on.
+- Alert on a cause when you can alert on the symptom.
+- Report reliability as an average when users experience the tail.
+- Close an incident review with the finding that someone was careless.
diff --git a/plugins/technology/skills/release-and-deployment/SKILL.md b/plugins/technology/skills/release-and-deployment/SKILL.md
new file mode 100644
index 0000000..eb840c9
--- /dev/null
+++ b/plugins/technology/skills/release-and-deployment/SKILL.md
@@ -0,0 +1,58 @@
+---
+name: release-and-deployment
+description: Ships changes safely and often — pipelines, deployment strategies, feature flags, rollback, and database changes. Use this to design a deployment pipeline, reduce release risk, roll out a risky change gradually, plan a schema migration, or work out why releases are infrequent and frightening.
+---
+
+# Release and deployment
+
+Release risk is dominated by batch size. Large infrequent releases are dangerous because many changes
+land at once and nobody can tell which one broke it — so teams release less often, which makes each
+release larger. The loop is the problem.
+
+## Separate deploy from release
+
+Deploying code and exposing behaviour to users are different acts, and coupling them forces every
+deployment to be a business decision.
+
+Decouple with flags: deploy continuously, expose deliberately. This makes rollback a configuration
+change rather than a redeployment, which is the difference between seconds and minutes at the worst
+possible time.
+
+Flags are inventory and rot. Give each an owner and a removal date; a codebase full of stale flags
+has combinatorial states nobody has tested.
+
+## The pipeline is the quality gate
+
+Automate everything between commit and production, and let the pipeline reject. Manual steps get
+skipped under pressure, which is exactly when they matter.
+
+Order gates fast-to-slow so failure is cheap: lint and unit tests, then integration, then anything
+requiring a deployed environment. A pipeline slow enough to be circumvented is worse than a fast one
+with fewer checks, because it will be circumvented.
+
+Build once and promote the same artefact through environments. Rebuilding per environment means the
+thing you tested is not the thing you shipped.
+
+## Roll out gradually
+
+Expose to a small population first and watch real signals before widening. Canary or percentage
+rollout turns a total failure into a contained one.
+
+Define the abort condition **before** starting, with a threshold and a named decision-maker. Under
+pressure, and with the change fresh, the instinct is always to wait a little longer and see.
+
+## Database changes are the asymmetric risk
+
+Code rolls back; data does not. Make schema changes backward-compatible and multi-step: add the new
+structure, write to both, migrate, switch reads, then remove the old — with the application tolerant
+of both shapes throughout.
+
+Test the migration against production-scale data. A migration that is instant on a development
+dataset can lock a large table for a length of time nobody modelled.
+
+## Never
+
+- Couple deploying code to exposing behaviour.
+- Promote a different artefact than the one that was tested.
+- Begin a rollout without a defined abort condition.
+- Ship a schema change that requires the application and database to deploy simultaneously.
diff --git a/plugins/technology/skills/solution-architecture/SKILL.md b/plugins/technology/skills/solution-architecture/SKILL.md
new file mode 100644
index 0000000..6844917
--- /dev/null
+++ b/plugins/technology/skills/solution-architecture/SKILL.md
@@ -0,0 +1,56 @@
+---
+name: solution-architecture
+description: Designs system structure and makes architectural decisions defensible — boundaries, coupling, trade-offs, and recording why. Use this to design a new system or major component, choose between architectural options, review an existing design, decide where a boundary belongs, or document an architectural decision so it survives the people who made it.
+---
+
+# Solution architecture
+
+Architecture is the set of decisions that are expensive to reverse. Everything cheap to change later
+is design, and does not need this level of ceremony.
+
+## Start from what constrains, not from what appeals
+
+Architecture is driven by quality attributes, not by features. Establish the ones that actually bind
+before drawing anything: expected load and its shape, latency the user notices, availability the
+business will fund, data residency and retention obligations, the rate of change the team needs to
+sustain, and the size and skills of the team who will operate it.
+
+Vague attributes produce vague architecture. "Scalable" is not a requirement; "20,000 concurrent
+sessions with p99 under 300ms" is a constraint that eliminates options.
+
+## Boundaries are the whole game
+
+Draw boundaries where change is independent and where data has a single owner. A boundary in the
+right place absorbs change; a boundary in the wrong place turns every feature into a negotiation
+across three teams.
+
+The reliable test: if a routine change requires coordinated deployment across two components, the
+boundary is wrong regardless of how clean the diagram looks.
+
+Prefer coarse boundaries until you have evidence for finer ones. Distributed systems convert simple
+in-process failures into network, partial-failure and consistency problems — a cost worth paying for
+independent scaling or independent deployment, and not worth paying for tidiness.
+
+## Trade-offs, stated
+
+Every architecture sacrifices something. The failure is not choosing badly; it is choosing without
+naming what was given up, so nobody later understands why the constraint exists.
+
+Present options with their costs: what each makes easy, what each makes hard, what it costs to
+operate, and what it would take to reverse. Two credible options and an honest comparison beat one
+recommendation.
+
+## Record decisions
+
+Write down the decision, the context at the time, the options considered, and the consequences
+accepted. Architecture rots because the reasoning evaporates while the structure remains, and the
+next team reads a constraint as an accident.
+
+Keep records short and immutable — supersede rather than edit, so the history of thinking survives.
+
+## Never
+
+- Design against quality attributes nobody has quantified.
+- Split a system into services to make the diagram tidy.
+- Present a single option as though no trade-off was made.
+- Leave an expensive-to-reverse decision undocumented.
diff --git a/plugins/technology/skills/technical-debt-management/SKILL.md b/plugins/technology/skills/technical-debt-management/SKILL.md
new file mode 100644
index 0000000..0625096
--- /dev/null
+++ b/plugins/technology/skills/technical-debt-management/SKILL.md
@@ -0,0 +1,54 @@
+---
+name: technical-debt-management
+description: Makes technical debt visible and decidable — distinguishing real debt from mess, quantifying its cost, and arguing for remediation in business terms. Use this to assess and prioritise debt, decide whether to fix or live with something, justify remediation work to non-engineers, or plan a migration off a system nobody wants to touch.
+---
+
+# Technical debt management
+
+Debt is a deliberate trade: taking on future cost to move faster now. Most of what gets called debt
+is not that — it is mess, which was never a decision, or drift, where the world moved and the code
+did not. The distinction matters because the arguments and remedies differ.
+
+## Classify before prioritising
+
+- **Deliberate debt** — a known shortcut with a reason. Has a principal and interest. Legitimate.
+- **Mess** — nobody chose it; it accumulated. No trade was made, so there is nothing to defend.
+- **Drift** — the code was right for a context that has changed. Neither shortcut nor carelessness.
+- **Not debt at all** — code someone dislikes, or would have written differently. Taste is not debt,
+ and rewriting on taste is how remediation budgets get spent with nothing to show.
+
+## Cost is a rate, not a total
+
+Debt matters proportional to how often you pay it. Ugly code in a module nobody has touched in three
+years costs nothing; a moderate awkwardness in the file every feature crosses costs continuously.
+
+Measure by contact: change frequency, how long changes there take relative to elsewhere, how often
+changes there cause incidents, and how many people avoid the area. Overlay change frequency on
+complexity and the priorities become obvious and defensible — the expensive parts are where both are
+high, which is rarely where intuition points.
+
+## Argue in the language of the decision-maker
+
+"The code is bad" loses to any feature request. What wins is the rate: this area consumes a
+disproportionate share of delivery time, causes a disproportionate share of incidents, and the gap
+widens.
+
+Frame remediation as capacity recovery with a payback period — the same terms as
+`finance:capital-allocation`, which is where any large migration will eventually be judged.
+
+## Remediate incrementally
+
+Large rewrites fail at a well-documented rate: they take longer than estimated, deliver no value
+until the end, and are cancelled halfway leaving two systems. Prefer strangling the old system
+gradually behind a stable interface, so value lands continuously and the work can stop at any point
+without leaving a mess.
+
+Improve opportunistically where you are already working — the code you are touching anyway is the
+cheapest code to improve, and it is by definition the code that is being touched.
+
+## Never
+
+- Present debt as a quality argument to someone accountable for delivery dates.
+- Prioritise by how bad code looks rather than how often it is paid for.
+- Start a rewrite with no value delivered until completion.
+- Classify taste as debt.
diff --git a/scripts/build-readme.py b/scripts/build-readme.py
index b1699fd..0d62894 100755
--- a/scripts/build-readme.py
+++ b/scripts/build-readme.py
@@ -10,12 +10,14 @@ META = {
"executive": (10, "Office of the CEO", "Chief Executive"),
"technology": (20, "Technology", "CTO / CIO"),
"security": (30, "Security", "CISO"),
+ "it-operations": (35, "IT Operations", "CIO"),
"product": (40, "Product", "CPO"),
"marketing": (50, "Marketing", "CMO"),
"demand-generation": (60, "Demand Generation", "CMO"),
"revenue": (70, "Revenue", "CRO"),
"finance": (80, "Finance", "CFO"),
"operations": (90, "Operations", "COO"),
+ "pmo": (95, "Programme Management Office", "EPMO / COO"),
"customer-experience": (100, "Customer Experience", "CCO"),
"data-analytics": (110, "Data & Analytics", "CDO"),
"corporate-strategy": (120, "Corporate Strategy", "CSO"),
@@ -170,6 +172,8 @@ out += [
"",
"MIT — see [LICENSE](LICENSE). Every skill here was written for this repository.",
"",
+ "Built by [Chris Brock](https://chrisbrock.io).",
+ "",
"---",
"",
"<sub>README generated by `scripts/build-readme.py` — edit that, not this file.</sub>",