back to slides
Workshop reference · session 1 · "what happens after the workshop" deep-dive

Where your prompts go after the workshop

From Project to Cowork to Skill — the surfaces your team-asset prompt can live on. The Monday move is one Project per pattern. Everything else is optional.

Sources cited inline. Last updated 2026-05-03 · WebMD HS workshop · author: Tony Bùi
jump: 1 · Project recipe 2 · 5 Projects pattern 3 · Cowork 4 · Hybrid team 5 · The ladder Sources

TL;DR

1 · The Project recipe
the Monday move

Take your two artifacts → create a Claude Project → name it after the pattern. The rest of this section is just the rule for what goes where inside it.

Worked example — turning the workshop output into a real Project on Monday morning. Five steps, ~10 minutes.
  • Step 1 — open Claude.ai → Projects → New Project Name it after the pattern + slot, not the task. Good: Drafter — User Stories. Bad: Member-Consent-PRD-stories. The pattern repeats; the task doesn't.
  • Step 2 — paste Context Card on top + RCTCO prompt below into custom instructions Both stay there forever. Every new chat in this Project starts with both loaded. See the "Custom instructions" tab for the exact layout.
  • Step 3 — upload 3-5 reference files into knowledge Past shipped artifacts (last 3 PRDs that passed review), the domain glossary, the 5-tests rubric, any spec template. RAG-retrieved on demand — not always-loaded.
  • Step 4 — start a chat, fill the Context placeholders, ship Each new task = new chat in the same Project. The role / template / output schema are already loaded; you only fill what changed.
  • Step 5 — invite teammates, save the URL in your team's Notion/Confluence One pinned page: "Team Prompts." Five links. That's the entire library on day 1.
If it changes per task → knowledge file.
If it applies every chat → custom instructions.

Why this rule? Custom instructions get injected into every conversation in the Project — they consume tokens always. Knowledge files are RAG-retrieved on demand. Putting variable stuff in instructions wastes tokens; putting always-needed stuff in knowledge means it sometimes doesn't surface. Source: PromptKits, 2026 + Anthropic Help — What are Projects.

  • Custom instructions = "the contract" Role, output schema, constraints, voice rules, Context Card. Things you'd say at the start of every conversation if you had to. Keep it tight — every token here costs every chat.
  • Knowledge files = "the library" Past artifacts, glossaries, reference specs, rubrics, examples. Things Claude pulls when the task warrants. RAG-retrieved on paid plan (10× capacity).
Layout for a Drafter Project: Context Card on top (sets the stage), RCTCO prompt below (the actual contract). Paste this into the Project's custom-instructions field, swap the bracketed bits for your team's reality.
# ===== CONTEXT CARD ===== # Always-true background about this team. Stays loaded every chat. Team: [WebMD Health Services Vietnam — PM team] Product: [member-facing wellbeing platform] Audience: [US enterprise HR buyers, end-user is employee] Voice: clear, US-English, no jargon, evidence-first. Compliance non-negotiables: - HIPAA-aligned PHI handling - PDPL (VN data privacy) for cross-border - Accessibility: WCAG 2.1 AA Glossary: see [glossary.md] in knowledge. Past shipped reference: [last-3-prds.md] in knowledge. # ===== RCTCO PROMPT — DRAFTER ===== # The contract. Every new chat in this Project runs under this. ROLE: You are a senior product manager drafting user stories for the team above. CONTEXT: The user will paste a feature brief or PRD section in their first message. Treat it as the only source of truth for the feature; do NOT invent business rules. TASK: Generate 3-7 user stories in INVEST format covering the feature. Group by user role. CONSTRAINTS: - Each story: "As a [role], I want [capability], so that [outcome]" - Each story has 3-5 acceptance criteria in Given/When/Then - Flag any story that touches PHI with [COMPLIANCE — HIPAA] - Flag any cross-border data flow with [COMPLIANCE — PDPL] - If the brief is ambiguous, ASK — don't guess OUTPUT: Markdown. One H2 per role. Stories as H3. End with a "Open questions" section if anything was unclear.

Knowledge files for this same Drafter Project: last-3-prds.md, glossary.md, 5-tests-rubric.md, invest-criteria-examples.md, compliance-tag-cheatsheet.md. None of those need to be in the prompt — they get pulled when relevant.

Apply the rule to 8 common items. The point isn't memorizing a list — it's training the muscle so any new item lands in the right slot.

ItemGoes whereWhy
Output schema (markdown headings, INVEST format) Custom instructions Applies every chat. The shape of the answer never varies.
Voice rules ("clear, US English, no jargon") Custom instructions Same. Voice is constant per Project.
Last 3 shipped PRDs (reference for style) Knowledge file Useful as examples but only retrieved when relevant. Don't pay tokens every chat.
Domain glossary (50+ terms) Knowledge file Big, mostly-irrelevant-per-chat. RAG pulls the few terms that match.
Compliance non-negotiables (HIPAA / PDPL flags) Custom instructions Must apply every chat or it'll be silently skipped on the chat where it matters.
The 5-tests rubric for "is this a good story" Knowledge file Reference doc. Pulled when reviewer-mode questions come up. Optional.
Today's PRD section being turned into stories Paste in chat Per-task input. Lives in the conversation, not the Project shell.
Team's Context Card (audience, product, team) Custom instructions The reason the Project exists. Always loaded. Top of the instructions.
2 · The 5 Projects pattern
anti-fragmentation

One Project per pattern, not per task. The 5 patterns from slide 12 ARE your 5 Projects. The lesson is the org structure.

[X]
Anti-pattern A — 1 Project per task 5 tasks → 5 Projects → 50 Projects in 2 months. Nobody can find anything. Each Project drifts independently. The shared skeleton (voice, schema, compliance) gets re-typed in every Project — and slowly diverges.
[X]
Anti-pattern B — 1 Project, 5 prompts as knowledge files Knowledge files are RAG-retrieved, not always-injected. Asking "draft user stories" might pull drafter-prompt.md or might pull reviewer-prompt.md if the wording is ambiguous. You can work around with strict naming (PROMPT-01-drafter.md) and explicit invocation ("use PROMPT-01") but it's awkward and breaks for non-engineers.

Source: JD Hodges, "Claude Project Instructions Examples 2026" on the RAG-ambiguity workaround.

[OK]
1 Project per pattern 5 patterns → 5 Projects, each holds many tasks. Each Project's custom instructions = the canonical RCTCO skeleton + Context Card for that pattern. Each task = a new chat where you fill the Context placeholders.
  • Drafter Project Generates: user stories, PRD sections, marketing copy, briefs. Same INVEST/structured-output skeleton, only Context changes per chat.
  • Synthesizer Project Compresses: meeting notes → decisions, 5 docs → 1 brief, research → executive summary. Same "input → distilled output" skeleton.
  • Reviewer Project Audits: PRDs, specs, copy, code. Same defect-table-output skeleton with severity tags and compliance flags.
  • Critic Project Pressure-tests plans: pre-mortems, hypothesis-killing, red-team. Same adversarial-stance skeleton.
  • Translator Project Restates: VN ↔ EN, exec ↔ engineer, jargon ↔ plain. Same fidelity-first skeleton.

Why this works: a Drafter prompt for user stories is structurally identical to a Drafter prompt for marketing copy — same R, T, C, O slots, only Context changes. Same with Reviewer for PRDs vs Reviewer for specs. The pattern IS the reusable unit.

The 5 patterns you learned today are 5 saved Project URLs tomorrow.
One library. Every teammate. Same shape.

Anthropic's own recommendation in the same neighborhood: "create template projects for workflows you repeat frequently". The pattern-per-Project version is the cleaner refinement.

3 · Cowork — the desktop upgrade
NEW · Feb 2026 · all paid plans

Anthropic's desktop app. "Claude Code power for knowledge work" — agentic, file/folder access, multi-app, non-developer audience. Use it only when local-file access matters.

Cowork shipped GA Feb 2026 on macOS + Windows. Anthropic's own positioning is verbatim: "Claude Code power for knowledge work." All paid plans include it. Try it: claude.com/product/cowork.
  • Same Skills you installed today work in Cowork tomorrow Anthropic explicitly designed Skills to be portable. Enable in Settings → Features and the same SKILL.md runs in claude.ai, Projects, Claude Code, AND Cowork. The unit of capability travels.
  • Reads local files directly — no upload Cowork sees folders on your machine. PRDs, specs, codebases, briefs sit on disk and Cowork reads them in place. No "drag-and-drop into the chat" friction.
  • Agentic multi-step actions Closer to Claude Code's behavior than Project's. Can chain tool calls, read multiple files, write back, hit MCP servers — within a friendly chat UI rather than a terminal.
  • For the audience that won't open a terminal PMs, designers, ops, copywriters. Cowork is the on-ramp. Engineers stay in Claude Code. Same skills run on both — same team, two surfaces.
"Cowork = Claude Code power for knowledge work." — Anthropic product page, 2026
The honest split. Most rows tie. The two that matter: local-file access and agentic multi-step. If those aren't bottlenecks, Project is fine.
Capability Project (web) Cowork (desktop)
Skills (run a SKILL.md)YESYES
Reads local files directlyNO (must upload)YES
Agentic multi-steplimitedYES
MCP serverslimitedYES
Friendly chat UIYESYES
Knowledge files (uploaded library)YESvia Projects-in-Cowork
Required: desktop OSnomacOS / Windows only
Suitable for non-tech userYESYES
Costpaid planpaid plan

Sources for the comparison: claude.com/product/cowork, TestingCatalog GA report, Skills explained — Anthropic. Full table with Claude Code column in the research file.

Cowork sits between Project (rung 2) and Skill-in-Claude-Code (rung 4) on the ladder. It's "Project but with file access and agentic actions." Don't migrate by default — migrate when one of these is actually true:

  • You're constantly uploading the same files into a Project If every chat starts with "let me re-upload the latest spec," Cowork's local-file access pays for itself. Open the folder once.
  • You need multi-step actions across local files "Read these 3 PRDs, write a synthesized brief, save to /briefs/." Project can't do the read-and-write loop on disk. Cowork can.
  • You want MCP servers (Notion, GitHub, Slack, your own) Cowork inherits Claude Desktop's MCP plumbing. Project's MCP support is limited.
  • A non-engineer teammate wants Claude Code's power without the terminal This is the textbook fit. Same skills, same Projects, friendlier surface. Onboard them on Cowork; don't make them learn the CLI.
[!]
Don't migrate just because it's new. Cowork is young (Jan 2026 preview, Feb 2026 GA). Feature parity is moving. If your current Projects work, leave them. The friction of moving 5 Projects' worth of context outweighs the benefit unless one of the four conditions above is real.
4 · The hybrid team pattern
engineers + non-engineers · 3-tier distribution

Engineers want git. Non-engineers won't git pull. The cleanest answer: Git is canonical, Notion/Confluence is the consumer mirror, Project link is the actual usage.

Most teams give up on Git for prompt sharing within 2 weeks. Notion (or Confluence, or Coda) wins because it has WYSIWYG editing, comments + mentions, built-in version history, search that works, and no terminal. But Notion lacks code-style review, semver, and CI-integrated evals. Pick either side and you lose the other.

"Notion is way more approachable for non-engineers, making it well-suited for teams with PMs, designers, and researchers." — Medium, "How to Build a Prompt Library Your Team Will Actually Use" (2025)

Even OpenAI runs this split internally — engineers in GitHub, cross-functional in Notion. Notion customer story. The eng/non-eng split is a real org property, not a tooling failure.

  • Tier 1 — Git is canonical prompts/<pattern>/<name>.md in the team repo. Owned by tech leads. Versioned, PR-reviewed, eval-gated. This is the source of truth — exactly what the team-prompt-repo ref describes.
  • Tier 2 — CI exports each prompt to Confluence/Notion on every merge ~50-line Python script + GitHub Action. Reads prompts/**/*.md, pushes to a Confluence space as read-only pages. Non-engineers see the same content, never touch git. Drift = zero, because there's only one source.
  • Tier 3 — Each Confluence page has an "Open in Claude Project" button Link to a pre-configured Project that has that prompt loaded as custom instructions. Click → fresh chat, ready to use. Non-engineer never copies/pastes a prompt — they open a Project.
  • Change flow stays sane Non-engineer wants a change → leaves Confluence comment OR files a ticket. Engineer edits the markdown in git. CI re-syncs Confluence. Same Project URL, fresh prompt next chat.
For WebMD HS specifically: you likely already have Confluence (Atlassian shop, given YouTrack). Same recipe, swap Notion → Confluence. The Git→Confluence sync is a 1-2 day engineering task. Day-1 implementable for one tech lead.

This mirrors how design systems work — and design systems are a solved problem:

  • Figma = canonical (designers own) Source of truth for components. Versioned. Changes require approval. Git equivalent.
  • Storybook = consumer view (engineers + PMs read) Auto-generated from Figma + code. Read-only. Searchable, shareable, no Figma license needed. Confluence/Notion equivalent.
  • Production component = the actual usage (everyone uses) Final rendered button in the app. Project link equivalent — the surface the actual work happens on.
One source. Two views. Three surfaces.
Same shape that already works for design systems.
5 · The ladder
5 rungs · climb only when you need to

Where the same prompt can live, in increasing reach + commitment. Each rung adds capability and operational weight. Most teams should stop at rung 2. Some climb to 4-5.

1
Prompt today · R1-R2
What
RCTCO + 3-turn loop. A markdown file, or a paste in chat.
Who runs it
You, in your hands.
Tests pass when
The 5-tests rubric clears (clear role, full context, named task, hard constraints, locked output).
2
Project today · end of R3
What
Custom instructions (the contract) + knowledge files (the library). Pinned URL.
Who runs it
Your team. Anyone with the Project link.
Tests pass when
A new teammate opens the link, asks a Drafter question, gets a usable answer with no setup.
3
Cowork this week · optional
What
Desktop agent. Same Skill, plus local-file access + multi-step + MCP.
Who runs it
Non-engineers who'd benefit from local files and agentic actions, without a terminal.
Tests pass when
Cowork reads a folder of PRDs and produces a synthesized brief — no upload, one chat.
4
Repo session 2 prep
What
prompts/<pattern>/<name>.md in git. Versioned (semver), PR-reviewed, eval-gated.
Who runs it
Tech-lead-owned. Consumer-mirrored to Confluence/Notion via CI for non-engineers.
Tests pass when
Promptfoo eval blocks merge on regression. CHANGELOG names the failure mode each version defends.
5
Skill session 2
What
A SKILL.md Claude Code (or Cowork) auto-loads when triggered by keyword. Lives in the repo, ships with the codebase.
Who runs it
Anyone running Claude Code or Cowork in the project. The capability comes free with the repo.
Tests pass when
Typing the trigger phrase loads the right skill, and the skill's own evals pass on every PR.
Climbing rule: only move up a rung when the rung below is the bottleneck.
Don't build a Repo if the Project still works. Don't build a Skill if the Repo isn't being read.

Key sources cited

Cowork — official + launch coverage
Projects — instructions vs knowledge, multi-prompt patterns
Hybrid team distribution — eng + non-eng
Vault prior art (workshop ref deck)