# Creating Distillations

> Projects one existing verified reference onto one existing task axis, gated by a per-distillation applicability check. Produces one distillation file at `corpus.commons/{corpus}/distillations/{task}/{slug}-{task}.md`, optionally with lens-applied sections or per-lens variants. Invoked by `ingesting-resources` Pass G during new-source ingestion and by `creating-applications` during per-distillation orchestration when assembling a new application.

- Skill: `chrisgagne/creating-distillations` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add chrisgagne/creating-distillations`
- Raw SKILL.md: https://api.skillmd.com/api/skills/chrisgagne/creating-distillations/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: chrisgagne (https://skillmd.com/u/chrisgagne)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/chrisgagne/creating-distillations

---


# Creating Distillations

Per-distillation projection of one source onto one task axis. Consumes a (source, task) pair plus an optional lens-set; produces one file plus an index update.

Invoked by:
- `creating-applications`, per-distillation orchestration: once per applicable (source, task) distillation.
- `ingesting-resources` Pass G: once per task axis during a new-source ingest.

Rationale, template structure, evidence discipline, four-outcome lens-applicability gate, and failure modes live in [`projection-protocol.md`](projection-protocol.md). This file is the runbook; that one is the rationale. Read both before invoking.

## When to use

- **Pass G of `ingesting-resources`.** Per task axis in the corpus, the ingest skill calls this skill once with the new (source, task) pair. The applicability gate decides whether to produce a distillation or skip.
- **Per-distillation orchestration in `creating-applications`.** When a new application is being assembled, the orchestrator calls this skill once per (source, task) distillation named in the task spec. Often dispatched as parallel sub-agents.
- **Operator follow-up.** A new task axis has landed and the operator notices a source whose existing deep reference predates the axis: invoke this skill directly to project that source onto the new task.
- **Re-projection after a deep-ref update.** The deep reference has been sharpened (often via Pass G cycling: see [`projection-protocol.md`](projection-protocol.md) §Cycling); the distillation needs to reflect the updated deep.

## When not to use

- The deep reference does not yet exist. Run `ingesting-resources` first.
- The task axis does not yet exist (no distillation directory, no index, no build profile). Run `creating-tasks` → `creating-applications` first.
- The operator wants to project *all* applicable sources onto a new axis. That's the per-distillation orchestration job inside `creating-applications`: invoke it instead, and it will call this skill once per source.

## Pre-flight

Both checks must pass:

1. **Verified deep reference exists.** Path: `corpus.commons/{corpus}/references/{slug}-deep.md`. The deep must have passed Pass I (source-only audit). If the deep does not exist, abort with the operator-facing message *"Deep reference for {slug} not found; run `ingesting-resources` first."*
2. **Task axis exists.** Path: `corpus.commons/{corpus}/distillations/{task-name}/`. The directory plus `task-index.json` (and the human-readable `{TASK-UPPERCASE}-DISTILLATION-INDEX.md` operator-inspection view) must exist. If any are missing, abort with *"Task axis {task-name} not yet scaffolded; run `creating-applications` first."*

If both pre-flight checks pass, the skill proceeds. Otherwise it fails loudly and names the gate that closed.

## Inputs

- The existing task axis name in kebab-case (e.g., `decision-making`, `learning-from-incidents`).
- The slug of the existing verified reference (e.g., `openstax-organizational-behavior`).
- Optionally, one or more lens names. Lens names refer to specs at `corpus.commons/{corpus}/lenses/{lens-slug}.md`. If a named lens has no spec file, abort and direct the operator to run `creating-lenses` first.

## Outputs

- **The distillation file** at `corpus.commons/{corpus}/distillations/{task-name}/{slug}-{task-name}.md`, produced when Pass G.0's source-applicability gate fires *clear yes* or *operator-confirmed yes*. **The distillation includes a `## Runtime triggers this source addresses` section** that maps the source's content to specific triggers from the task spec's seed table (field 2a), with teach-in-the-moment scripts. See "Trigger-grain projection" below.
- **An update to the distillation index** for the task, citing the new distillation in the appropriate phase sections **and adding rows to the per-phase runtime listener tables** for each trigger the source addresses.
- **For each lens** where the per-distillation applicability gate fires beyond *clear no*:
  - **Partial reshape:** a `## Through the {lens-name} lens` section inside the main distillation.
  - **Deep reshape:** a separate per-lens distillation at `corpus.commons/{corpus}/distillations/{task-name}/{slug}-{task-name}-{lens-name}.md`.
- **A skip log** when Pass G.0 fires *clear no* or *operator-confirmed no*. No file is generated; the skip is recorded with the reason. Lens skips at *clear no* are recorded similarly.

If the skill is invoked under parallel-batch orchestration, index updates may be written to a staging file (`_ingest_{task}_{slug}.md` in the distillation directory) instead of the canonical index, to be merged by the orchestrator's consolidator step.

## Procedure

The detailed step-by-step procedure—applicability gate logic, projection-template structure, evidence discipline, lens-as-optional-framing—lives in [`projection-protocol.md`](projection-protocol.md). The runbook summary:

1. **Read the verified deep reference.** The deep is the only input at this step; the source is not re-read. (See `projection-protocol.md` §Failure modes for why.)
2. **Run the source-applicability gate** (`projection-protocol.md` §Pass G.0). Three outcomes: clear yes → proceed; clear no → log skip and exit; ambiguous → ask the operator and proceed per their call.
3. **Project the source onto the task** using the standard nine-section template (`projection-protocol.md` §Projection template). The structure is uniform across the corpus; do not deviate, add sections, or reorder.
4. **For each named lens, run the lens-applicability gate** (`projection-protocol.md` §Lens-as-optional-framing). Four outcomes:
   - **Clear no.** No additional artefact. Log the skip.
   - **Clear yes, partial reshape.** Add a `## Through the {lens-name} lens` section inside the distillation.
   - **Clear yes, deep reshape.** Produce a separate per-lens distillation file.
   - **Ambiguous.** Ask the operator; proceed per their call.
5. **Trigger-grain projection.** Read the task spec's field 2a (seed trigger→response table) and identify which triggers this source can address. For each:
   - Add a row to the distillation's `## Runtime triggers this source addresses` section: trigger | source's content that addresses it | teach-in-the-moment script (1-3 sentences).
   - Add a row to the distillation index's runtime listener table for the appropriate phase: trigger | framework name + cite to this distillation.
   - The source may extend the seed table (surface triggers the spec didn't anticipate but the source clearly addresses); log these extensions in a `## Trigger extensions surfaced by this source` section so the operator can fold them back into the task spec.
   - If the source addresses zero triggers in the seed table, that is a signal Pass G.0 should reconsider: the source may apply at the *phase* level but not at the *moment* level, which means the distillation will be shelf material at runtime even if the phase-routing fires it. Default: still produce the distillation but flag the trigger-mismatch in the distillation header so the operator can address it.
6. **Update the distillation index** to cite the new file(s) in the phase sections where they apply *and* add trigger-table rows for the triggers the source addresses. If running under parallel-batch orchestration, write to a staging file instead and let the orchestrator's consolidator merge it.
7. **Run `npm run build`** to verify the affected profile compiles cleanly. Required after every Mode-2 run when invoked standalone; the orchestrator runs a final build after all per-distillation invocations complete when running under `creating-applications`.

## Re-runs and overwrites

If the distillation already exists for the (source, task) pair, the skill does not silently overwrite. Two paths:

- **Refresh after a deep-ref update.** Delete or rename the existing distillation; rerun the skill. The applicability check runs again; the file is regenerated from the current deep.
- **Merge changes.** The skill does not merge. Generate the new version into a temporary path, diff against the existing, and apply the diff manually.

## Failure modes to watch

The full catalogue with worked examples lives in [`projection-protocol.md`](projection-protocol.md) §Failure modes. The headlines:

- **Skipping the source-applicability gate.** Generating a distillation for a (source, task) pair where the source doesn't actually fit produces a file that strains, reaches, and reads as filler. Better to skip and record the skip.
- **Skipping the lens-applicability gate.** Pre-projecting against every named lens by default inflates the corpus with thin lens-shaped variations of the same content. The default for lenses is *do nothing*; pre-project only where the lens materially reweights the distillation.
- **Re-reading the source.** Distillation projection is from the verified deep, not from the source. Re-reading reintroduces failure modes the deep ref has already audited out (training-prior leakage, drift, evidence-marker confusion).
- **Smuggling new claims into distillations.** If a concept is not in the deep reference, it does not belong in the distillation. Re-ingest if the concept warrants inclusion.
- **Re-extracting verbatim from the source at Pass G.** Verbatim blockquotes in distillations are *copies* of already-audited Pass D blockquotes from the deep ref, with the evidence marker preserved. Re-extracting from the source reopens the failure modes Pass D closed.
- **Mismatched task vocabulary.** The distillation's working vocabulary should be the task's own: *decisions* for decision-making, *stakeholders* for stakeholder-engagement, *incidents* for incident-review, etc. Source-author vocabulary is preserved in the deep reference; task-applied vocabulary lives in the distillations.

## Related skills

- `creating-tasks`: scopes a new task axis. Run before this skill if the named task axis does not yet exist.
- `creating-applications`: assembles a new application. Invokes this skill once per (source, task) distillation.
- `ingesting-resources`: runs the 9-pass protocol. Pass G calls this skill once per task axis the corpus carries.
- `creating-lenses`: designs a lens spec. Run before this skill if a named lens doesn't yet exist.
- `matching-references`: find an existing source by topic before assuming a distillation is needed.