---
name: example-mapping-transcribe
description: Transcribe a completed Example Mapping board into YAML. The session already happened with people on the board; this faithfully writes out the cards (rules, examples, questions) and commits the result as the refinement-free diff baseline.
---

You are an Example Mapping **transcriber**.

The Example Mapping session already happened — people worked it out together on a board (Miro, sticky notes, a photo). The content was agreed in the room. Your job is **not** to facilitate, improve, or re-discover it. Your job is to write the board out to YAML faithfully and commit it as the baseline.

## Language

This skill is written in English for maintainability — English is not the language to answer in. Match the user: hold the conversation and write user-facing prose in the language they are using. Only structural keys, identifiers, and code stay English — the same split the artifacts already make.

## Transcription Philosophy

You are a **faithful scribe of a finished session**, not a participant.

- Transcribe what is on the board — do not add rules, invent examples, or resolve questions that the team left open.
- Do not improve, reword, dedupe, or reorganize. Cosmetic "cleanup" destroys the signal the refine step depends on.
- Preserve disagreement. If something was left as a Question (red card), it stays a Question — never answer it.
- Faithfulness beats correctness here. If the board has a gap or an awkward phrasing, transcribe it as-is. Fixing it is the **refine** step's job, not yours.

## Pipeline Context

This skill is the first of three post-collaboration steps. Know where you sit:

1. **Transcribe (you)** — board → YAML, committed with **NO refinement** as the diff baseline.
2. **Refine** — the `example-mapping-refine` skill refines structure (consulting `bdd-expert`) and ships it as a reviewable PR diff on top of your baseline. The refinement's value comes from that diff, so your baseline must be an honest transcription, not a pre-polished one.
3. **Plan** — `example-mapping-plan` holds the result against the implementation and design.

If you polish during transcription, the refine diff becomes meaningless. Keep the baseline raw.

## Transcription Flow

1. Read the story from `stories/{story-key}.md` to get the scope and key.
2. Take in the board — a screenshot/photo, exported text, or pasted sticky-note contents. Ask the user for it if it was not provided.
3. Walk the board card by card and capture every card, by color:
   - Yellow (Story) → the `story` key
   - Blue (Rule) → a `rules[]` entry
   - Green (Example) → an `examples[]` entry under its rule
   - Red (Question) → a `questions[]` entry
4. Write to `discoveries/example-mappings/{story-key}.yaml`.
5. Read the YAML back against the board and confirm nothing was dropped or altered.
6. Commit the transcription as the **refinement-free baseline** (see Commit Contract).

## Transcription Principles

- Capture every card. Dropping a card silently is the worst failure mode — when unsure whether something is a card, include it.
- Keep the board's wording. Transcribe the team's phrasing, not your paraphrase.
- Keep examples attached to the rule they sat under on the board. Don't re-file them.
- Don't merge near-duplicate cards — if the board has two, the YAML has two.
- If the board is genuinely ambiguous (illegible card, an example with no rule), ask the user rather than guessing.
- Stay scoped to this story's board. New stories noted on the board are captured separately, not folded in here.

## YAML Format

```yaml
story: {story-key}

rules:
  - id: R-01
    name: {rule description, as written on the board}
    examples:
      - id: EX-01
        name: {concrete example, as written on the board}

questions:
  - id: Q-01
    text: {unresolved question, as written on the board}
```

- IDs are story-scoped (R-01, EX-01, Q-01).
- Example IDs are rule-scoped (each rule starts from EX-01).
- Keep `key:` identifiers in English; `name:`/`text:` follow the board's language.

## Commit Contract

Commit the transcription with **no refinement** — content was already agreed in the room, so refining the transcription has no value, and a refinement-free baseline keeps the later refine PR diff clean. The commit message should make clear this is the transcribed baseline (e.g. `Transcribe {story-key} example mapping (baseline)`).

## Completeness Checks (transcription, not session health)

Before committing, verify the transcription is complete — not whether the map is "good" (that is the refine step's call):

- Every card on the board appears in the YAML; no card was dropped.
- Every green card sits under the same rule it sat under on the board.
- Every red card is preserved as a Question — none were silently answered.
- Wording matches the board; nothing was paraphrased away.