Hands-on · Claude Code Build Lab

From today to six working Ops

The companion to the weekly-status walkthrough — but this time we build the whole PM bench. Set up your context once, then watch the same Frames and Cogs get reused across six recurring rituals. Each ritual starts where you are today and ends at a functional, human-gated Op, with the prompt you paste and the file it produces.

Built on the tools you already live in — GitHub & GitHub Projects, Slack, Google Drive, Notion (and Gemini, where your notes land). No Intelligence Hub required; this runs today on Claude Code. The payoff isn't six scripts — it's seeing how Frames are inherited, where Cogs are reused, and how every Op stops at your gate.

~/atlas — what you'll have at the endrepo layout
atlas/                              ← one git repo = the context home for every Op
├── CLAUDE.md                       ← imports the Frames (auto-loaded every session)
├── .mcp.json                       ← GitHub · Slack · Drive · Notion connectors
├── frames/                         ← FRAMES · built once, inherited by all six Ops
│   ├── company.frame.md                parent (inherited)
│   ├── pmo-standards.frame.md          how we run programs here
│   ├── atlas-program.frame.md          your program: goals, terms, sources
│   ├── audience-profiles.frame.md      exec / team / external
│   └── compliance.frame.md             policy, attached by Legal
├── .claude/agents/                 ← COGS · briefed, tool-fenced workers
│   ├── status-report.md  risk-triage.md  transcript-miner.md
│   ├── kickoff-builder.md  audience-writer.md
│   └── capacity-analyst.md  retro-synth.md
├── .claude/commands/               ← OPS · orchestration + your gate
│   ├── weekly-status.md  project-kickoff.md  stakeholder-update.md
│   └── risk-review.md  capacity-check.md  retro-synthesis.md
└── status/ kickoffs/ retros/ …     ← drafted outputs (git history = your memory)

Seven Cogs, six Ops, five Frames — but you only author the context once. The reuse is the whole point; the lineage explorer at the bottom lets you trace exactly what inherits from what.

Part 1 · built onceFoundations everything inherits

Before any single ritual, you do two things that the other six all stand on: connect your tools, and write the context Frames. Do these well and each Op below is mostly assembly.

1
Tools · the connectors

Connect your sources over MCP

Claude Code reaches your tools through MCP servers. Add one connector per source, each with a read-only token — least-privilege scoping is your governance layer today. Set up once, shared by every Cog in the repo.

terminalmcp setup
# GitHub — PRs, issues, AND Projects v2 boards (one read-only PAT covers all three)
$ claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
      --header "Authorization: Bearer $GITHUB_TOKEN"

# Slack — project channels & async updates (bot token, channels:history scope)
$ claude mcp add slack --env SLACK_BOT_TOKEN=$SLACK_BOT_TOKEN \
      -- npx -y @modelcontextprotocol/server-slack

# Google Drive — meeting transcripts, recordings' transcripts, and docs (read-only)
$ claude mcp add gdrive -- npx -y @modelcontextprotocol/server-gdrive

# Notion — project pages & notes (hosted connector, read access)
$ claude mcp add --transport http notion https://mcp.notion.com/mcp

$ claude mcp list        # confirm all four are connected
Two things specific to your stack. Recordings can't be "watched" — point the Cogs at the auto-generated transcripts Drive saves beside each video; they're just docs. And there's no Gemini connector: when you take notes in Gemini, save them into a Google Doc or a Notion page, and the Drive/Notion connectors pick them up like any other note. Connector packages move — the GitHub and Notion remote URLs are current; confirm the Slack and Drive community servers before installing.
Result: all your sources reachable from Claude Code, read-only
2
Frames · the context

Write the Frames the whole bench inherits

A Frame is a versioned markdown file that captures context. The fastest first draft is to have Claude Code read what you already produce. Write three that nest — a PMO standard, your program Frame (which extends it), and a compliance policy — plus the company Frame you already have.

Paste into Claude Code
Read the last 4 weekly-status docs in the Google Drive folder "Atlas / Weekly Status", the "Project Atlas" page in Notion, and recent messages in #atlas-eng, #atlas-data, and #atlas-product on Slack. Draft TWO frame files: 1. frames/pmo-standards.frame.md — the reusable PMO standard: - what "milestone" means, the RACI rule, how blockers escalate - the EXACT one-screen status format we use 2. frames/atlas-program.frame.md (extends frame://acme/pmo/standards): - goals, the workstreams and their owners - our RAG (red/amber/green) criteria - a "Sources" section mapping each workstream to where its signal lives: GitHub repo, Projects board, Slack channel, Drive transcript folder, Notion page Use scope/name/version frontmatter. Output only the two files.

Review, fix anything wrong, and you've got the program Frame — note the Sources map pointing at your real tools, and the two places it overrides the PMO standard:

frames/atlas-program.frame.mdFrame
scope:    program
name:     Project Atlas
version:  0.1.0
extends:  frame://acme/pmo/standards        # PMO lineage -> Acme Company
---
## Goals
Migrate billing to the new platform by Dec 15 with zero customer-facing downtime.

## Workstreams
- platform   — owner: Lena    (the migration itself)
- data       — owner: Omar    (backfill + reconciliation)
- frontend   — owner: Priya   (checkout UI)

## Terminology
"Slip" = a milestone moved more than 3 business days.
RAG: green = on track; amber = at-risk with a recovery plan; red = blocked or slipped, needs a decision.   # overrides the PMO default

## Norms
Blockers escalate same-day — never held for the readout.   # overrides PMO "within one business day"

## Sources
- platform:  github://acme/billing-svc  · project:Atlas/Status · slack://atlas-eng     · drive://Atlas/Transcripts · notion://Atlas/Platform
- data:      github://acme/billing-data · project:Atlas/Status · slack://atlas-data    · drive://Atlas/Transcripts · notion://Atlas/Data
- frontend:  github://acme/checkout-ui  · project:Atlas/Status · slack://atlas-product · drive://Atlas/Transcripts · notion://Atlas/Frontend

Add the compliance policy as its own file (it hangs off Legal, not the PMO chain) and wire all of it into CLAUDE.md so every session is pre-oriented:

CLAUDE.mdinheritance
# CLAUDE.md — auto-loaded into every Claude Code session in this repo
@frames/company.frame.md
@frames/pmo-standards.frame.md
@frames/atlas-program.frame.md
@frames/compliance.frame.md
terminalcommit
$ git add frames CLAUDE.md && git commit -m "frames: PMO + Atlas + compliance v0.1.0"  # git history = audit trail
Result: 4 Frames, inherited by every Cog & Op belowaudience-profiles comes later, when its Op needs it
Part 2 · six buildsFrom today to a working Op, six times

Each ritual follows the same arc: where you are today, what it inherits or reuses vs. what's new, the prompt to paste, the file produced, and the functional result. Watch how little is new each time — that's inheritance and reuse doing the work.

1

Weekly status roll-up flagship · full build

/weekly-status

The Monday RAG deck you assemble by hand from six tabs. We build it end-to-end; the other five reuse what we make here.

● Today — by hand
  • Open six tabs — GitHub PRs/issues, the Projects board, Slack channels, the latest Drive transcript, the Notion page — and reconcile into a deck.
  • Conflicting terms: one lead's "done" is another's "code-complete."
  • Hope you didn't miss a risk buried in a thread.
≈ 3 hours every Monday — and it drifts each week
▶ With /weekly-status
  • One command gathers all five sources and drafts RAG-per-workstream in your format.
  • Every RAG call cites its evidence — a PR number, a Slack link, a transcript line.
  • You review, adjust the narrative, and approve at the gate. Nothing posts on its own.
≈ 20 min of review — consistent every week
Inherits
company.framepmo-standards.frameatlas-program.framecompliance.frame
Reuses
Nothing yet — this is the first build.
New in this step
status-report cogrisk-triage cog/weekly-status op

Frame: nothing new — the Op inherits everything it needs from the Atlas program Frame you wrote in Part 1 (the RAG criteria, the status format, the Sources map). On to the Cogs.

Cog 1 · status-report — a subagent that gathers signal and assigns RAG. Its tools: allowlist is the governance fence; "draft only" is baked into the prompt.

Paste into Claude Code
Create a Claude Code subagent at .claude/agents/status-report.md. It is oriented by the Atlas frames (already loaded via CLAUDE.md). Its job: a DRAFT weekly status in the format defined in atlas-program.frame.md. For each workstream in the frame's Sources map, over the last 7 days, gather: - GitHub: merged PRs, still-open PRs, issues opened/closed - GitHub Projects: items whose status changed; items past their target date - Slack: async updates and the word "blocked" in the workstream channel - Drive: the latest meeting transcript — pull decisions and risks (recordings are read via their transcript) - Notion: the workstream's notes page Then assign RAG per workstream using the frame's criteria; surface the top-3 risks and decisions needed. Constrain tools to READ-ONLY (only write allowed: files under status/). System prompt must say: DRAFT ONLY, cite evidence per RAG call, mark a workstream "no-signal" rather than guessing. Output only the file.
.claude/agents/status-report.mdCog · subagent
---
name: status-report
description: Drafts the weekly RAG status for Project Atlas from GitHub, Projects, Slack, Drive transcripts, and Notion. Use for the weekly status only.
tools: Read, Write, mcp__github__list_pull_requests, mcp__github__list_issues, mcp__github__list_project_items, mcp__slack__conversations_history, mcp__gdrive__search, mcp__gdrive__read_file, mcp__notion__search
model: sonnet
---
You are the Status-Report Cog for Project Atlas, oriented by atlas-program.frame.md —
follow its vocabulary, RAG criteria, and status format exactly. Window: last 7 days.

For each workstream in the frame's Sources map:
1. GitHub: merged PRs, open PRs, issues opened/closed in the window.
2. Projects: items whose status changed; flag any item past its target date.
3. Slack: scan the workstream channel for async updates and "blocked".
4. Drive: open the most recent transcript; extract decisions and risks.
5. Notion: read the workstream's notes page for context.

Assign RAG per workstream per the frame's criteria. Surface the top-3 risks + decisions.

Rules:
- DRAFT ONLY. Never post to Slack, Notion, or Drive. Write only under status/.
- Cite evidence for every RAG call (PR #, message link, transcript line).
- If a workstream has no signal, mark it "no-signal" — never invent status.

Cog 2 · risk-triage — smaller; it only reasons over the risks the first Cog surfaces, and it inherits the compliance Frame too, so policy gates the scoring. Remember this one — risk-review reuses it later.

.claude/agents/risk-triage.mdCog · subagent
---
name: risk-triage
description: Scores, de-dupes, and assigns owners to Project Atlas risks. Invoked by the weekly-status and risk-review Ops.
tools: Read, mcp__github__list_issues, mcp__github__list_project_items
model: sonnet
---
You are the Risk-Triage Cog for Project Atlas, oriented by atlas-program.frame.md and
compliance.frame.md. Given candidate risks, you:
- merge duplicates and phrase each as "risk -> impact -> next step"
- score severity (high / med / low) using the frame's "slip" and "blocked" definitions
- assign an owner from the workstream's owner in the frame
- output the top-3 by severity
You are read-only: you never modify issues or post anywhere.

Op · the workflow + your gate. A slash command runs both Cogs, composes their output into your format, writes a draft, and stops.

Paste into Claude Code
Create a slash command at .claude/commands/weekly-status.md that: - runs the status-report subagent to gather signal and draft RAG-per-workstream - runs the risk-triage subagent to score, de-dupe, and assign owners to the risks - composes both into the status format in atlas-program.frame.md (a RAG table per workstream with evidence links, top-3 risks, decisions needed) - writes the result to status/.md as a DRAFT - prints a 3-line summary and STOPS for my review — posts nothing anywhere Output only the command file.
.claude/commands/weekly-status.mdOp · slash command
---
description: Draft this week's Project Atlas status for review (no publish)
allowed-tools: Read, Write, Task
---
Compose the Project Atlas weekly status for the window: the last 7 days ending today.
1. Use the status-report subagent to gather signal and produce RAG-per-workstream.
2. Use the risk-triage subagent to score, de-dupe, and assign owners to the risks.
3. Merge into the format defined in atlas-program.frame.md.
4. Write the result to status/$(date +%G-W%V).md as a DRAFT.
5. Print a 3-line summary, then STOP. Do not post to Slack, Notion, or Drive.

Result. Run /weekly-status and it drops this into status/ for your Monday review — your format, evidence behind every call:

status/2026-W39.md — DRAFT for reviewoutput
# Project Atlas — Weekly Status · 2026-W39

## RAG by workstream
- platform   GREEN  — on track. billing-svc cutover PR #482 merged; staging green (transcript 09-21).
- data       AMBER  — at-risk. backfill 2 days behind; recovery plan posted in slack://atlas-data (Omar).
- frontend   RED    — blocked. checkout-ui waiting on the data contract; decision needed.

## Top-3 risks
1. [HIGH] Data contract unresolved blocks frontend  -> owner Omar  -> lock schema by Wed
2. [MED]  Backfill slip threatens the Dec 15 milestone -> owner Omar -> add a second runner
3. [MED]  Load test not yet scheduled -> owner Lena -> book a window this week

## Decisions needed
- Approve the schema freeze for the billing data contract — frontend is blocked on it.

Want it before standup? 0 9 * * 1 cd ~/atlas && claude -p "/weekly-status" >> logs/status.log 2>&1 — the gate never moves, because the Op only ever writes the file.

2

Standing up a new project

/project-kickoff

Turns an approved charter into a ready-to-run skeleton. Note its short lineage — it inherits the PMO standard but not the Atlas program, so it works for any new project.

● Today — by hand
  • Copy last project's charter, RACI, and plan; hand-edit every field.
  • Re-key the milestone skeleton into the Projects board by hand.
  • Spin up Slack channels and the Drive folder one by one.
≈ a full day per new project
▶ With /project-kickoff
  • From the charter it drafts the RACI, milestone skeleton, and risk log in PMO templates.
  • Proposes the Projects epics and the channel/folder structure for you to confirm.
  • Nothing is created until you approve scope and owners.
≈ 30 min of review
Inherits
company.framepmo-standards.frame
Reuses
Nothing — it's deliberately program-agnostic.
New in this step
kickoff-builder cog/project-kickoff op
Paste into Claude Code
Create a subagent .claude/agents/kickoff-builder.md, oriented by pmo-standards.frame.md ONLY (not the Atlas program — this must work for any new project). Input: a charter doc (Notion page or Drive doc, passed by URL). It drafts, in the PMO templates: a RACI, a milestone skeleton, a starter risk log, and a PROPOSED structure of GitHub Projects epics + Slack channels + a Drive folder. Read-only on all sources; write only under kickoffs/. Propose the board/channel/folder structure as a checklist — never create them. Then create a slash command .claude/commands/project-kickoff.md that runs it from a charter URL and STOPS for my sign-off. Output both files.
.claude/commands/project-kickoff.mdOp · slash command
---
description: Draft a new-project skeleton from an approved charter (no creation)
allowed-tools: Read, Write, Task
argument-hint: 
---
From the charter at $1:
1. Use the kickoff-builder subagent to draft RACI, milestone skeleton, and risk log.
2. Have it PROPOSE the GitHub Projects epics, Slack channels, and Drive folder layout.
3. Write everything to kickoffs// as DRAFTS.
4. Print the proposed board/channel/folder checklist, then STOP. Create nothing.
kickoffs/borealis/RACI.md — DRAFToutput
# Project Borealis — RACI (draft from charter, PMO template)
| Deliverable            | Accountable | Responsible | Consulted | Informed |
| Data model sign-off    | Omar        | Omar, Lena  | Legal     | Sponsor  |
| Migration runbook      | Lena        | platform    | SRE       | PM       |
# Proposed (NOT created — confirm before I make these):
#   Projects epics: Data Model · Migration · Cutover
#   Slack: #borealis-eng  #borealis-data       Drive: /Borealis/Transcripts
3

Tailoring updates per audience

/stakeholder-update

One source of truth, retargeted per audience. First reuse of a Cog — and the first new Frame since Part 1.

● Today — by hand
  • Rewrite the same update three ways — exec, working team, customer.
  • Each version drifts; someone gets the wrong level of detail.
  • Sensitive items occasionally leak into the wrong audience's version.
≈ 2 hours per send
▶ With /stakeholder-update
  • Drafts audience-specific versions from one set of facts.
  • Tone and depth come from the audience Frame; confidential lines auto-redacted externally.
  • You approve each version before it goes out.
≈ 15 min of review
Inherits
company.frameatlas-program.framecompliance.frame
Reuses
status-report cog
New in this step
audience-profiles frameaudience-writer cog/stakeholder-update op

New Frame. The audience profiles hang off a Comms branch, not the PMO chain — proof a worker can compose two lineages at once.

frames/audience-profiles.frame.mdFrame · new
scope:    team
name:     Audience Profiles
version:  1.0.0
extends:  frame://acme/comms/standards         # Comms lineage, not PMO
---
## exec      Terse — outcomes, risks, asks only. No implementation detail.
## team      Full detail with owners and dates.
## external  Redact roadmap dates and confidential lines before sending.
Paste into Claude Code
Create a subagent .claude/agents/audience-writer.md, oriented by audience-profiles.frame.md AND compliance.frame.md. Given a set of facts (e.g. this week's status draft), it writes THREE versions — exec, team, external — each following its profile in the frame. For the external version it must apply the compliance redaction rules (no roadmap dates, no PII). Read-only; write under updates/. Drafts only. Then a slash command .claude/commands/stakeholder-update.md that: - reuses the status-report subagent to assemble the week's facts ONCE - runs audience-writer to produce the 3 versions - writes them to updates// and STOPS for my per-version approval. Output all files.
updates/2026-09-21/ — 3 DRAFTSoutput
exec.md      → "Atlas on track for Dec 15. One red: frontend blocked on a data
                contract — need a schema-freeze decision this week."
team.md      → full RAG table + owners + the three risks with next steps.
external.md  → progress narrative, NO dates, NO internal owner names.  # redacted by compliance
4

Grooming the risk register

/risk-review

The clearest reuse story: the risk-triage Cog from ritual 1 does the scoring here, unchanged. You only add one new Cog.

● Today — by hand
  • The register goes stale between reviews; nobody updates it mid-sprint.
  • New risks hide in Slack threads and meeting transcripts, uncaptured.
  • Scoring and ownership are inconsistent review to review.
≈ half a day before each steering meeting
▶ With /risk-review
  • Sweeps channels, tickets, and transcripts for new/changed risks since last review.
  • Re-scores with the program Frame's definitions; flags entries that no longer match reality.
  • You accept, re-score, or dismiss each at the review.
≈ 20 min — always current
Inherits
company.frameatlas-program.framecompliance.frame
Reuses
risk-triage cog
New in this step
transcript-miner cog/risk-review op

New Cog · transcript-miner — pulls candidate risks out of Drive transcripts (and Gemini notes saved to Drive/Notion). It feeds the existing risk-triage Cog. It gets reused again in ritual 6.

.claude/agents/transcript-miner.mdCog · subagent
---
name: transcript-miner
description: Extracts decisions, risks, and action items from Drive meeting transcripts (incl. Gemini notes saved to Drive/Notion). Used by risk-review and retro-synthesis.
tools: Read, mcp__gdrive__search, mcp__gdrive__read_file, mcp__notion__search
model: sonnet
---
You are the Transcript-Miner Cog for Project Atlas. Given a date window, find the
relevant transcripts/notes and extract: decisions (with who decided), risks (phrased
as risk -> impact), and action items (owner + date if stated). Quote verbatim with a
timestamp or line reference so nothing is misattributed. Read-only; you never post.
.claude/commands/risk-review.mdOp · slash command
---
description: Refresh the Atlas risk register for the steering meeting (no writes to the board)
allowed-tools: Read, Write, Task
---
1. Use transcript-miner to surface candidate risks from transcripts + notes since last review.
2. Add open GitHub issues / Projects items labeled "risk".
3. Use the risk-triage subagent (REUSED) to score, de-dupe, and assign owners.
4. Diff against risks/register.md; mark NEW, CHANGED, and STALE entries.
5. Write risks/review-.md as a DRAFT and STOP. I re-score at the meeting.
5

Catching resource conflicts early

/capacity-check

Surfaces over-allocation before it slips a date. Pure PMO + program lineage; one new Cog.

● Today — by hand
  • You eyeball assignments across projects and hope nobody's double-booked.
  • Conflicts surface only when someone misses a deadline.
reactive — caught after the slip
▶ With /capacity-check
  • Cross-references Projects assignments and timelines to flag over-allocation and contention.
  • Drafts a re-balancing proposal with the tradeoffs spelled out.
  • You and the resource manager make the call.
weekly — caught before the slip
Inherits
company.framepmo-standards.frameatlas-program.frame
Reuses
Reuses the GitHub Projects connector — no new Cog logic borrowed.
New in this step
capacity-analyst cog/capacity-check op
Paste into Claude Code
Create a subagent .claude/agents/capacity-analyst.md, oriented by atlas-program.frame.md. It reads GitHub Projects assignees + target dates across the board, cross-references who is assigned to overlapping items in the same window, and flags over-allocation and cross-workstream contention. It drafts a re-balancing proposal naming the tradeoffs. Read-only; write under capacity/. Then a slash command .claude/commands/capacity-check.md that runs it weekly and STOPS for the resource manager's decision. Output both files.
capacity/2026-W39.md — DRAFToutput
# Capacity flags · 2026-W39
- OVER-ALLOCATED: Omar is on the data backfill AND the schema freeze, both due this week.
  Proposal: move the load-test prep (Lena) earlier; pull a second runner onto backfill.
- CONTENTION: platform + data both need the staging env Wed-Thu.  Decision needed.
6

Closing the loop with a retrospective

/retro-synthesis

Reuses transcript-miner again — and does something new: it writes lessons back into the Frame, so the next project inherits them. That's organizational memory accumulating.

● Today — by hand
  • Retro inputs scatter across a survey, sticky notes, and a meeting transcript.
  • Themes get summarized from memory; nuance is lost.
  • Action items rarely make it into the next project's plan.
≈ 3 hours, and lessons evaporate
▶ With /retro-synthesis
  • Synthesizes survey + notes + transcript into themes and action items, each citing its evidence.
  • Proposes lessons to append to the program Frame — version-bumped, for your approval.
  • The team validates and commits the actions.
≈ 25 min — lessons retained
Inherits
company.framepmo-standards.frameatlas-program.frame
Reuses
transcript-miner cog
New in this step
retro-synth cog/retro-synthesis op
Paste into Claude Code
Create a subagent .claude/agents/retro-synth.md, oriented by atlas-program.frame.md. Inputs: the retro survey export (Drive doc), the retro Notion page, and the retro meeting transcript. It clusters into themes (went well / went poorly), proposes action items with owners + dates, and drafts a short "Lessons" block to APPEND to atlas-program.frame.md (with a version bump). Read-only on sources; write under retros/. It must NOT edit the frame directly — it proposes the diff for my approval. Then a slash command .claude/commands/retro-synthesis.md that reuses transcript-miner for the transcript, runs retro-synth, writes retros/.md + a proposed frame diff, and STOPS. Output both files.
retros/2026-09-30.md + proposed frame diff — DRAFToutput
# Atlas Retro · 2026-09-30
## Went well   Cutover rehearsal caught the data-contract gap early (transcript 11:40).
## Went poorly Backfill estimate was 2x optimistic — no buffer for reconciliation.
## Actions     [Omar] add reconciliation buffer to all future estimates (by next kickoff)

# Proposed append to frames/atlas-program.frame.md  (0.1.0 -> 0.2.0):
+ ## Lessons
+ Estimate data backfills with a reconciliation buffer; the naive estimate runs ~2x short.

Approve the diff and commit — now atlas-program.frame.md is at 0.2.0, and the next project-kickoff inherits the lesson automatically. The loop is closed.

Tie it together

Trace any Op or Cog to the context it actually sees

This is the whole point of building once and reusing. Pick any Cog or Op below: its inheritance path lights up across the Frame graph, and the panel underneath resolves the merged context it's oriented by — every section, which Frame it came from, and where a more-specific Frame overrode a less-specific one. Compare /project-kickoff (pure inheritance, no overrides) with /weekly-status (the program Frame overrides two company/PMO defaults).

Op & Cog lineage explorer
select an artifact → its frame path highlights, and its merged context resolves below
Cogs (workers)
Ops (workflows)
Op · workflow
Frame (inherited) Policy / cross-cutting Frame Overridden — most-specific Frame wins Reused Cog
Every section in the panel is real context the worker is oriented by at runtime — assembled from the Frames, with the cascade resolved least → most specific.
What you built

Six Ops, but you only wrote the context once

That's the lesson. The expensive, drift-prone part — your vocabulary, RAG criteria, status format, sources, and policy — lives in a handful of Frames written in Part 1. After that, each ritual is mostly assembly, and the most valuable Cogs get reused across several Ops.

Built onceReused byWhy it matters
atlas-program.frameAll six Ops (via CLAUDE.md)One definition of "RAG", "slip", and the sources map — no drift.
risk-triage Cogweekly-status · risk-reviewScoring logic written once, applied identically in two ceremonies.
transcript-miner Cogrisk-review · retro-synthesisTranscript/notes extraction shared across rituals.
status-report Cogweekly-status · stakeholder-updateThe week's facts assembled once, retargeted per audience.
compliance.frameweekly-status · stakeholder-update · risk-reviewPolicy attaches to whatever touches it — redaction, retention, checkpoints.
When you stand up a Hub later

These artifacts port cleanly: the Frame files become real Frames, the subagents become Cogs, the slash commands become installable Ops, and your git history becomes Organizational Memory. Same shapes — more governance and reproducibility around them.

Sensible next steps:

  • Add a personal Frame (frames/you.frame.md) for your own preferences — terser output, how you like risks grouped — and import it in CLAUDE.md.
  • Promote a blessed Op to a PMO template so a second program (Borealis) inherits it under its charter.
  • Schedule the read-only Ops (status, capacity) headless; keep the publish gates exactly where they are.

New here? Start with the concepts, see the single-Op Build Guide, or browse the cross-functional use-case gallery →