Pattern Library

Act as my Pattern Library builder.

## Safety contract (Path A — filesystem)

- Read only from the folder I've given access to. No traversal beyond.
- Write only inside `patterns/` plus `patterns.md` and `pattern-usage.md` at the team-brain root. Never elsewhere.
- Update CLAUDE.md / AGENTS.md to reference the patterns folder (auto-load).
- Each pattern file under 400 tokens. Patterns are scaffolds, not solutions.
- Log every pattern proposed in the debrief.

## What to build

Three artifacts:

1. **`patterns.md`** — catalog: name · when-to-use · parameters · output target · version.
2. **`patterns/`** — folder of named markdown files (one per pattern).
3. **`pattern-usage.md`** — calling convention, parameter syntax, composition rules, versioning.

Plus a starter library of 6 patterns:
- `status-update.md`
- `decision-doc.md`
- `rfc-review.md`
- `weekly-review.md`
- `pr-review.md`
- `rubber-duck.md`

## Steps

### 1. Inventory silently
What kind of work do I do most often? (Look for git activity, recent docs, project structure cues.) What patterns probably already exist as one-off prompts I keep retyping?

### 2. Ask 4–6 short questions
1. Top 3 things I write repeatedly with AI help (status email, decision doc, code review, weekly summary, etc.)?
2. What output format do I prefer for status / decision docs (markdown, slides, plain prose)?
3. Tone — direct, formal, narrative?
4. Should patterns assume the team-brain context is already loaded (yes for Path A), or be standalone?
5. Versioning preference — semver-style (v1, v2) or git-history-only?
6. Any patterns I want to skip from the starter library because they don't fit?

### 3. Draft the artifacts + 6 starter patterns
Use the templates below. Rules:
- Each pattern file: a one-line description, parameter list, prompt body (~150 tokens), example invocation.
- `patterns.md` rows reference the pattern file path.
- `pattern-usage.md` shows: "Run pattern: <name> with <params>" syntax.
- Update CLAUDE.md / AGENTS.md to add: "When I say 'Run pattern: X', read patterns/X.md and execute it with the parameters I provide."

### 4. Save
- Create patterns/ if missing. Write 6 starter pattern files.
- Write patterns.md and pattern-usage.md.
- Update CLAUDE.md / AGENTS.md with the new instruction (don't overwrite existing content; append).

### 5. Debrief

```
## Pattern Library built

**Created:**
- patterns.md                  (N rows)
- pattern-usage.md
- patterns/status-update.md
- patterns/decision-doc.md
- patterns/rfc-review.md
- patterns/weekly-review.md
- patterns/pr-review.md
- patterns/rubber-duck.md

**Wrappers updated:** CLAUDE.md, AGENTS.md (added pattern-call instruction)

**Calling syntax test:**
- "Run pattern: status-update with project=yardline week=2026-W19"
- The agent will read patterns/status-update.md and execute with those params.

**Growing the library:**
- New pattern earns place after 3 uses.
- Drafts go in patterns/_drafts/ first.
- Old versions go in patterns/_archive/-v.md when you bump major.
```

## Templates

### `patterns.md` row
```markdown
## status-update
**When to use:** weekly status email to leadership / cross-team.
**Parameters:** project, week, audience.
**Output:** markdown body ready to paste into email.
**File:** patterns/status-update.md
**Version:** v1
**Lineage:** —
```

### `patterns/status-update.md`
```markdown
# status-update pattern

**Parameters:** project={{project}}, week={{week}}, audience={{audience}}

You are writing a weekly status update for {{audience}}.
Read team-brain/state-shared.md for this week's signal.
Read team-brain/project-shared.md for context.

Output a markdown email body with these sections:
1. Headline (one sentence — the most important thing)
2. Shipped this week (3-5 bullets, specific)
3. Coming next week (3 bullets)
4. Blockers / asks (only if real; skip if none)

Tone: {{audience-aware-tone}}. Specific over generic.
End with: "Questions: reply to this thread."
```

### `pattern-usage.md`
```markdown
# Pattern Usage

## Calling syntax
"Run pattern: <name> [with <param1>=<value> ...]"

The agent reads patterns/<name>.md and runs it with the parameters.
Missing parameters: agent asks.

## Composition
"Run pattern: weekly-review then run pattern: status-update with that output."

## Versioning
- Bump v1 → v2 on breaking parameter or output target changes.
- Old versions in patterns/_archive/.

## Adding a pattern
1. Write to patterns/_drafts/<name>.md.
2. Use it 3 times.
3. Move to patterns/<name>.md and add a row to patterns.md.
```

## Principles
- Three uses or it's not a pattern.
- Patterns are scaffolds, not solutions. Keep them tight.
- Markdown is portable. The library survives platform migrations.
- Drafts before promotions. The library stays high-signal.

Start with Step 1, then Step 2 (questions).

Act as my Pattern Library builder.

## Safety contract (Path B — Project / Custom GPT)

- Output is the three artifacts plus 6 starter pattern files as labeled markdown blocks. I'll save them to my shared Project (or paste the patterns into a Custom GPT / Gem system prompt).
- For Custom GPT path: combine the patterns into ONE system prompt with named sections.
- Each pattern under 400 tokens; total system prompt under the platform's limit.
- Skip credentials. Never echo OAuth tokens.

## What to build

Three artifacts (Path A) PLUS, for the Custom-GPT-style path:

4. **`custom-gpt-system-prompt.md`** — a single system prompt that wraps all 6 patterns with name-based dispatch ("when user says 'Run pattern: X', use the X section below").

## Steps

### 1. Inventory silently
What's the user's hub — Claude Project, ChatGPT Project, NotebookLM, M365 Copilot, Custom GPT, Gemini Gem?

### 2. Ask 4–6 short questions
(Same as Path A, plus:)
- "Project file collection" or "single Custom GPT / Gem"?

### 3. Draft three artifacts + 6 patterns + (if Custom GPT) the combined system prompt

### 4. Output as markdown blocks (one per file).

### 5. Debrief

```
## Pattern Library built

**Output:** three artifacts + 6 patterns (or combined system prompt for Custom GPT).
**Setup checklist:**
- Project path: upload all files to the shared Project.
- Custom GPT path: paste system prompt into "Configure → Instructions". Test "Run pattern: status-update".
- Saved-prompt fallback: each pattern can also be saved individually if you prefer.

**Growing the library:**
- New pattern earns place after 3 uses.
- For Custom GPT, edit the system prompt to add/version patterns.
```

## Templates
(Same artifact + pattern templates as Path A.)

### `custom-gpt-system-prompt.md` (combined)

```markdown
You are a pattern-aware assistant. The user invokes patterns by name.

When the user says "Run pattern: <name> [with <params>]":
- Look up <name> below and execute the prompt body with those params.
- If a pattern is missing, suggest the closest match and ask.

## Pattern: status-update
[body from patterns/status-update.md]

## Pattern: decision-doc
[body from patterns/decision-doc.md]

[... 6 patterns total ...]

## Pattern usage
- Run pattern: <name> with <param1>=<value> ...
- Compose: "Run pattern: weekly-review then run pattern: status-update with that output."
- Versions: pattern names with -v2 suffix indicate updates.
```

## Principles
(Same as Path A.)

Start with Step 1, then Step 2 (questions).

Act as my Pattern Library builder.

## Safety contract (Path C — saved prompts)

- Output is the three artifacts plus 6 patterns, formatted for paste into your AI tool's saved-prompts UI.
- Each pattern is one saved entry. Cross-references between patterns explain the calling convention; the tool itself doesn't auto-resolve "Run pattern: X" — you pick the saved entry.
- Catalog (`patterns.md`) is your portable reference; keep it in your team-brain folder.

## What to build

Three artifacts plus 6 patterns formatted as labeled markdown blocks (one per saved prompt).

## Steps

### 1. Inventory silently
Which AI tool? (claude.ai, ChatGPT, Gemini, Perplexity.) What's the saved-prompts feature called there?

### 2. Ask 3–5 short questions
(Same as Path A, scoped to manual paths.)

### 3. Draft artifacts + 6 patterns
Each pattern: a name (matches the saved entry name), parameter list, prompt body. Self-contained — the saved entry can run without other patterns loaded.

### 4. Output as markdown blocks

### 5. Debrief

```
## Pattern Library built

**Output:** three artifacts + 6 patterns ready to save.
**Setup steps:**
1. In [tool], open the saved-prompts UI.
2. Save each pattern as a new entry. Name = pattern name.
3. Pin the catalog (patterns.md) somewhere accessible (Drive, Notion).

**Growing:**
- After 3 uses of a new prompt, save it. Update patterns.md.
- For composition, manually run patterns in sequence (e.g. "weekly-review" then feed output into "status-update").
```

## Templates
(Same as Path A; Path C makes them fully self-contained — assume team-brain context is NOT auto-loaded.)

## Principles
(Same as Path A. Plus: Path C trades automation for portability — your library survives a platform migration with one paste-pass.)

Start with Step 1, then Step 2 (questions).