A hand-built Claude Code operating system for running senior transformation work: one engine that analyses, one engine that remembers.
I run an 8 figure cost productivity programme at a large ASX-listed infrastructure services enterprise (~$6B revenue, ~35,000 people). This repository is the system I built to run it. Procurement reviews, working-capital models, board papers, client dashboards, evidence ledgers, all of it flows through here.
The premise: AI delivers leverage when it is engineered into the workflow, not summoned ad-hoc.
This is not a cost-out shop with an AI wrapper bolted on. Two co-equal engines run underneath everything in here.
Thinking, then process, then branded output. Five agents and two human-approval gates turn a question into an executive-ready deliverable, and neither gate is optional: exec work dies at the partner review, not at the analysis.
Read more: methodology/pipeline.md
Capture, then summarise, then remember. Every meeting, every weekly synthesis, every mistake is written into a wiki graph and a persistent memory index that loads automatically at the start of the next session, so the system compounds instead of starting from zero each time.
Read more: brain/
.
├── skills/ 38 custom Claude Code skills across 6 families
│ ├── README.md master index of every skill
│ ├── pipeline/ five-agent analytical pipeline + gates
│ ├── program/ transformation programme management
│ ├── documents/ executive Word / Excel / PowerPoint output
│ ├── analysis/ data + commercial insight
│ ├── product/ scoping + storyboarding + personas
│ └── utility/ integrations: Smartsheet, Notion, SAP, DuckDB
├── brain/ knowledge engine: capture -> summarise -> remember
│ ├── 1-capture/ meeting notes to structured wiki entries
│ ├── 2-summarise/ weekly synthesis per workstream
│ └── 3-remember/ durable memory + wiki graph writes
├── methodology/ the pipeline, the gates, the audit logic
├── examples/ sanitised artefacts from real programme work
└── docs/ diagrams + tiles + screenshots
Six layers. Ingest, data, pipeline, output, audit, knowledge. The pipeline is the spine, but the surface around it is what makes the work survive an executive review.
Five agents and two human-approval gates run every analytical deliverable:
| Stage | What it does |
|---|---|
| Agent 1: Clean | Ingest, normalise, classify |
| Gate: Working Construct | Hypothesis-driven story skeleton (MBB practice). I sign off before any analysis runs |
| Agent 2: Analysis | DuckDB, spend cube, structured data cuts |
| Agent 3: Synthesis | Findings to implications |
| Agent 4: Blueprint | Deck architecture and key messages |
| Gate: Partner Review | Pre-delivery critique: substance, structure, audience |
| Agent 5: Final Deck | PPTX / Word / HTML, executive-ready |
The gates are not optional. They exist because exec deliverables die at the partner review, not at the analysis.
Full detail: methodology/pipeline.md
The Pipeline turns a question into a deliverable. The Brain turns the ordinary work of running a programme, meetings, weekly updates, decisions, mistakes, into something that compounds instead of evaporating at the end of every session.
Three stages, always in the same order:
| Stage | What it does |
|---|---|
| 1. Capture | Turns a raw meeting into a structured, linked wiki note |
| 2. Summarise | Synthesises a week of notes into a per-workstream update, applying a so-what filter, not just aggregating |
| 3. Remember | Writes durable findings into the wiki graph and a persistent memory index, both loaded automatically at the start of the next session |
The persistent memory index is the novel piece. It is what lets a new session start already knowing what the last one learned, instead of re-deriving it from scratch. Most AI setups are stateless: whatever the system learned last week is gone by the time it is needed again. This one is not.
The output is visible in the wiki graph itself: roughly 616 notes connected by 1,925 links, a navigable structure the next analysis can query instead of a folder of dead files.
Full detail: brain/README.md
38 skills across 6 families (pipeline, program, documents, analysis, product, utility), each versioned markdown with a structured front-matter. Skills are composable, idempotent where possible, and reviewed like code. Full list: skills/README.md. The interesting ones:
route-task: routes any incoming task to the right thinker lens (CSO/CFO/CAO etc.) and the right output skillpipeline-working-construct: builds the hypothesis skeleton before analysis runspipeline-partner-review: pre-delivery critique simulating an MBB partner passclevel-review: gate for any senior-audience deliverableexec-comms: visual + structural format discipline (callouts, parallel tables, banned-word scans)program-steerco-pack: board-grade programme view from live dataprogram-exec-summary: one-page summaries that survive an ExCoanalysis-commercial-insight: classifies cost problems by lever, timeline, and size before any analysis runsdocuments-davila7-xlsx: Excel outputs with formulas, cover sheet, brand audit baked in
Skills are not prompts. They are versioned software. They have a description, a trigger contract, a process, and an output specification. They are reviewed, audited, refactored, and removed.
Real patterns from real programme work, reproduced here as sanitised, fictional-data examples:
examples/dashboard/: a client-facing benefit dashboard (structured data to styled HTML/PNG, brand-adaptable, one-operator build)examples/exec-summary/: a one-page decision brief run through the exec-comms formatting discipline pass- Steerco packs and decision briefs (Word + PPTX, brand-audited)
- Category reviews backed by 8M+ rows of SAP spend (DuckDB local query layer)
- Treasury-grade working capital models (live formulas, CFO-defensible audit trail)
The system remembers not just projects, but mistakes. Every silent SQL trap, every library that produces files the reader cannot open, every field that lies about its contents: each one becomes a durable engineering rule that gets written into the standards, not just fixed and forgotten. The next build avoids it.
This is the efficiency flywheel. Rework cycles compound in the wrong direction; captured gotchas compound in the right one. After enough cycles the build is correct on the first pass because the traps were already catalogued.
Full set: methodology/engineering-standards.md
Three reasons:
- Most public AI content is toy demos. Senior operators need to see real workflows that survive a real partner review. There is not enough of this online. Here is one.
- The system is the value. Individual prompts are commodities. The opinionated, composed, audited system is what produces leverage at the ExCo level.
- I want to talk to AI companies building for senior operators. This repo is the fastest way to show what I care about: orchestration, taste, audit, accountability.
For commercial and confidentiality reasons:
- No employer financials, vendor names, contract counterparties, or specific $ savings by category
- No client-confidential outputs (everything in
/examples/is sanitised, fictional data) - No internal employer data (the SAP / spend cube / project data files are not committed)
- No personal correspondence
The skills themselves are generic. They work in any senior-stakeholder workflow.
Jacob Ooi. Sydney. Head of Transformation, a large ASX-listed infrastructure services enterprise.
- LinkedIn: linkedin.com/in/jacobooi (DM is the fastest way to reach me)
Open to conversations with AI teams. Most interested in agentic orchestration, evaluation, audit, and taste.
MIT for the skills themselves. The methodology is what it is: borrow it, fork it, ship better than I did.