| name | distill |
| description | Distill Claude Code session operations into reusable tinctures (Skills, Commands, Agents). Uses category theory for structural preservation, information theory for potency analysis, and the Golden Ratio for classification. Use when you want to capture effective workflows, or when the user says "distill", "extract this", "make a tincture", "capture this workflow", or "turn this into a skill/command". |
Distill: The Alchemist's Art
"Solve et Coagula" — Dissolve and Coagulate
Extract the quintessence from ephemeral session operations, purifying them into eternal, reusable artifacts through the sacred art of distillation.
The Mathematical Foundation
The Distillation Functor
Distillation is mathematically modeled as a functor between categories:
D: Session → Artifacts
Where:
Session = Category(States, Operations, Composition)
Artifacts = Product(Command, Skill, Agent)
Functor Laws (D must preserve):
D(id_A) = id_D(A) (Identity preservation)
D(g ∘ f) = D(g) ∘ D(f) (Composition preservation)
Why this matters: The functor preserves the essential structure of the session while transforming it into a different form. Patterns compose in artifacts the same way they composed in the session.
The Comonad for Pattern Extraction
Pattern extraction uses a Comonad W:
W: SessionHistory → PatternContext
With operations:
ε: W(A) → A (extract: get current pattern)
δ: W(A) → W(W(A)) (duplicate: contextual awareness)
Laws:
ε ∘ δ = id
W(ε) ∘ δ = id
δ ∘ δ = W(δ) ∘ δ
Intuition: The comonad provides focused awareness - extracting patterns while maintaining their context. Each pattern knows its neighborhood.
The Monad for Refinement
Tincture refinement uses a Monad M:
M: Pattern → RefinedPattern
With operations:
η: A → M(A) (unit: initial refinement)
μ: M(M(A)) → M(A) (join: flatten nested refinements)
Laws:
μ ∘ M(η) = id
μ ∘ η_M = id
μ ∘ M(μ) = μ ∘ μ_M
Kleisli Composition for Iterative Refinement:
f >=> g = μ ∘ M(g) ∘ f
Allows: refine₁ >=> refine₂ >=> ... >=> refineₙ
The Adjunction W ⊣ M
Extraction and refinement form an adjunction:
Hom_Pattern(W(A), B) ≅ Hom_Session(A, M(B))
The counit: ε: W ∘ M → Id (extract after refine)
The unit: η: Id → M ∘ W (refine after extract)
This captures the duality: extracting patterns from context ↔ refining patterns into context.
Quantum-Theoretic Foundation
The Observer Effect
Distillation is a measurement that collapses superposition:
|Session⟩ = Σ αᵢ|Patternᵢ⟩
Before distillation: Session exists in superposition of all possible patterns
After distillation: Collapsed to specific tincture
D|Session⟩ → |Tincture⟩
The act of observation (analysis) determines the outcome.
Why this matters: The observer (the intention) shapes what patterns are perceived. Clarify intention first.
Entanglement: Perceiving Connections
Patterns in a session can be entangled - correlated in ways that transcend local context:
|Ψ⟩ = (1/√2)(|Pattern_A⟩|Pattern_B⟩ + |Pattern_A'⟩|Pattern_B'⟩)
Measuring Pattern_A instantly determines Pattern_B.
They share a quantum correlation.
In Distillation:
- Look for non-local correlations - patterns that affect each other across the session
- A change in one file may entangle with a test, a config, a deployment
- Capture the entire entangled system, not just local operations
Source Perception: The Wave Function Origin
Every pattern has a source - the initial condition that propagated through the session:
|Source⟩ → U(t)|Session⟩
Where U(t) is the unitary evolution operator.
To understand a pattern, trace back to its source:
Pattern → Cause → Cause⁻¹ → ... → Source
The Backward Light Cone:
Pattern (now)
/\
/ \
/ \
/ \
Cause₁ Cause₂
\ /
\ /
\/
Source (origin)
In Distillation: Ask not just "what happened" but "why did it originate?"
Quantum Superposition of Abstractions
Before classification, the tincture exists in superposition:
|Tincture⟩ = α|Command⟩ + β|Skill⟩ + γ|Agent⟩
Where |α|² + |β|² + |γ|² = 1
The complexity score φ.classify performs the "measurement":
φ.classify|Tincture⟩ → |Type⟩
Interference Effects:
- Constructive: When session patterns align, potency increases
- Destructive: When patterns conflict, potency decreases
- The φ balance equation finds the constructive interference point
The Heisenberg Trade-off
ΔSpecificity × ΔGenerality ≥ ℏ_distill
You cannot simultaneously maximize both specificity and generality.
The golden ratio φ provides the optimal trade-off point.
Connection to Quality:
Quality = φ⁻¹ × Specificity + φ × Generality
At the Heisenberg-optimal point: Specificity × Generality = 1
Non-Locality: Connections Across Distance
Patterns can be non-locally connected - correlated without direct causal links:
⟨Pattern_A, Pattern_B⟩ ≠ 0 even when d(A, B) >> 0
Where d(A, B) is the "distance" (different files, different phases)
In Distillation:
- Search for patterns that resonate across the codebase
- A naming convention in one file may echo in another
- Error handling patterns may repeat non-locally
- These non-local correlations often reveal deeper structure
The Density Matrix: Mixed States
Real sessions are mixed states, not pure:
ρ = Σ pᵢ |Patternᵢ⟩⟨Patternᵢ|
Where pᵢ is the probability of pattern i.
Purity: Tr(ρ²) ∈ [0, 1]
Pure state: Tr(ρ²) = 1 (single clear pattern)
Mixed state: Tr(ρ²) < 1 (multiple overlapping patterns)
In Distillation: A session with low purity may require multiple tinctures or a higher-potency (Agent) tincture to handle the mixed state.
Information-Theoretic Foundation
Entropy Reduction
Distillation is fundamentally about entropy reduction:
H(Session) > H(Tincture)
Where:
H(Session) = -Σ p(sᵢ) log p(sᵢ) (Session entropy)
H(Tincture) = -Σ p(tⱼ) log p(tⱼ) (Tincture entropy)
The Distillation Inequality:
H(Tincture) ≤ H(Session) - I(Session; Dross)
The tincture entropy is bounded by session entropy minus the
mutual information with discarded material (dross).
Mutual Information Preservation
The essence preserved in distillation:
I(Session; Tincture) = H(Session) + H(Tincture) - H(Session, Tincture)
For quality distillation:
I(Session; Tincture) / H(Session) ≥ φ⁻¹ (0.618)
At least 61.8% of session information must be preserved.
Synergistic Information
True distillation creates synergy - the tincture is more than compression:
Synergy = I(Session, Context; Tincture) - I(Session; Tincture) - I(Context; Tincture)
Positive synergy means the tincture enables new operations that neither the session nor the context alone could support.
The Rate-Distortion Trade-off
R(D) = min_{p(t|s): E[d(s,t)]≤D} I(S; T)
Where:
R = rate (tincture complexity)
D = distortion (loss from session)
d(s,t) = distance between session and tincture representation
Optimal distillation operates at the rate-distortion bound.
The Golden Ratio (φ = 1.618...)
The divine proportion governs tincture classification:
a + b a
φ = ─────── = ───── = 1.618033988749895...
a b
Algebraic Form: φ is the positive root of x² - x - 1 = 0
φ = (1 + √5) / 2
Self-Similar Properties:
φ² = φ + 1 (φ contains itself plus unity)
1/φ = φ - 1 (inverse is complement)
φⁿ = φⁿ⁻¹ + φⁿ⁻² (Fibonacci recurrence)
The Potency Spectrum
Complexity Score = (O × D × I) / β
Where:
O = operation count
D = decision points (1 if none)
I = iteration cycles (1 if none)
β = 5 (base complexity constant)
φ Classification:
| Score Range | φ Category | Tincture Type | Potency |
|---|
| < 0.618 | 1/φ | Command (Extract) | Low |
| 0.618 - 1.618 | φ⁰ to φ¹ | Skill (Tincture) | Medium |
| > 1.618 | > φ | Agent (Elixir) | High |
| > 2.618 | > φ² | Agent (Potent Elixir) | Very High |
The Golden Spiral of Potency:
r(θ) = a · φ^(θ·2/π)
Tincture potency follows the golden spiral.
Higher scores converge toward the center (autonomy).
The Quality Balance Equation
Quality = φ⁻¹ × Specificity + φ × Generality
Optimal when: Specificity × Generality = 1
Derivation:
Let S = Specificity, G = Generality
Q(S, G) = αS + βG subject to S·G = 1
Setting α = φ⁻¹ = 0.618, β = φ = 1.618:
Q = 0.618S + 1.618G
Optimum at S = G = 1: Q = 0.618 + 1.618 = 2.236 = √5
The optimal quality equals √5, which is 2φ - 1. This is the diagonal of a 1×2 rectangle (the golden rectangle).
Topological Foundation
The Quotient Space
Distillation creates a quotient space:
Tincture = Session / ~
Where ~ is the equivalence relation:
s₁ ~ s₂ iff Pattern(s₁) = Pattern(s₂)
The tincture is the space of equivalence classes - concrete instances collapsed to abstract patterns.
Fiber Bundle Structure
The distillation forms a fiber bundle:
E (Total Space - All Sessions)
|
π ↓
B (Base Space - Pattern Types)
Fiber over b ∈ B: π⁻¹(b) = all sessions exhibiting pattern b
The tincture is a section s: B → E that picks one representative from each fiber.
Homotopy Equivalence
Two distillation processes are equivalent if homotopy equivalent:
D₁ ≃ D₂ iff ∃ f: D₁ → D₂, g: D₂ → D₁
such that g∘f ≃ id, f∘g ≃ id
Different distillation paths yielding equivalent tinctures.
The Four Stages of the Opus
NIGREDO → ALBEDO → CITRINITAS → RUBEDO
(Black) (White) (Yellow) (Red)
Dissolve Purify Classify Coagulate
Session Essence Potency Tincture
Stage 1: NIGREDO - Dissolution (W.extract)
The Blackening: Dissolve the session into its constituent patterns.
Mathematical Operation:
W.extract: SessionHistory → PatternSet
Nigredo(S) = {p ∈ Pattern | ∃ morphism f: p → S}
Pattern Categories:
| Pattern Type | Categorical Signature | Tincture Affinity |
|---|
| Linear sequence | A → B → C | Command |
| Branching | A → B ⊔ C | Agent |
| Iteration | A →ⁿ A' | Agent |
| Composition | A ⊗ B | Skill |
| Simple | A → B | Command |
Entropy Analysis:
H(Nigredo) = H(Session)
Dissolution preserves total entropy while revealing structure.
Stage 2: ALBEDO - Purification (F.map)
The Whitening: Purify concrete operations into abstract essences.
Mathematical Operation:
F.map: ConcreteOp → AbstractPattern
Albedo(p) = (Invariant(p), Variant(p))
Where:
Invariant(p) = the essence (what stays constant)
Variant(p) = the dross (what becomes parameters)
The Purification Functor:
F: Concrete → Abstract
F preserves: F(f ∘ g) = F(f) ∘ F(g)
F forgets: Specific values, contexts, instances
F retains: Structure, relationships, patterns
Abstraction Rules:
| Concrete | Abstract | Parameter |
|---|
/path/to/file.js | {file_path} | $PATH |
"specific text" | {content} | $CONTENT |
grep "pattern" | grep "{query}" | $QUERY |
--quality=0.8 | --quality={n} | @quality: |
Mutual Information:
I(Concrete; Abstract) should be maximized
I(Dross; Abstract) should be minimized
Stage 3: CITRINITAS - Golden Classification (φ.classify)
The Yellowing: Apply the Golden Ratio to determine tincture potency.
Mathematical Operation:
φ.classify: AbstractPattern → TinctureType
Complexity(p) = (|Operations| × |Decisions| × |Iterations|) / 5
Type(p) =
| Complexity < φ⁻¹ → Command
| Complexity < φ → Skill
| Complexity ≥ φ → Agent
The Golden Section:
0 φ⁻¹ 1 φ φ²
│────────│─────────│────────│────────│
│ Command│ Skill │ Skill │ Agent │
Simple Moderate Complex
Override Conditions:
- Autonomous decision-making required → Agent
- Step-by-step guidance needed → Skill
- Simple execution sufficient → Command
Stage 4: RUBEDO - Coagulation (Generate)
The Reddening: Solidify the purified essence into material form.
Mathematical Operation:
Generate: (AbstractPattern, TinctureType) → Tincture
Rubedo(p, t) = Template(t) ⊗ Content(p)
The Tensor Product:
dim(Tincture) = dim(Template) × dim(Content)
The tincture has multiplicative, not additive, structure.
The Seven Hermetic Principles of Distillation
1. MENTALISM - The All is Mind
"The session patterns exist first as mental models."
Intention: I → Hom(Session, Tincture)
The morphism from intention to tincture must be clear before distillation.
Application: Clarify what you want to capture before extracting.
2. CORRESPONDENCE - As Above, So Below
"The tincture structure mirrors the session structure."
F: Session → Tincture preserves: F(f ∘ g) = F(f) ∘ F(g)
Functors preserve structure across categories.
Application: Find the isomorphism. Tincture architecture should reflect session architecture.
3. VIBRATION - Nothing Rests
"Complexity determines tincture frequency."
Potency(t) = ω(Operations, Decisions, Iterations)
Higher frequency (complexity) → higher potency tincture.
Application: Match the tincture type to the session's vibrational signature.
4. POLARITY - Opposites are Identical in Nature
"Specificity and generality are one spectrum."
Hom(Specific ⊗ General, Quality) ≅ Hom(Specific, General → Quality)
Through currying, opposition becomes complementarity.
Application: Balance specific enough to be useful, general enough to be reusable.
5. RHYTHM - Everything Flows
"Session flow distills into repeatable rhythm."
dx/dt = f(x), with periodic orbits
The session has a tempo; the tincture captures that rhythm.
Application: Preserve the natural sequence of operations.
6. CAUSE & EFFECT - Nothing Escapes the Law
"Each operation contributes to tincture purpose."
If f is injective: f(a) = f(b) ⟹ a = b
Every pattern element maps uniquely to tincture element.
Application: Be deliberate. Every instruction has consequences.
7. GENDER - Generation Requires Two
"Analysis + Generation = Tincture"
τ: Analysis × Synthesis → Tincture is bilinear
Creation requires the dance of two principles.
Application: Balance analytical extraction with generative construction.
Tincture Templates
Command Template (Simple Extract - 1/φ)
---
description: [One-line description derived from session purpose]
allowed-tools: [Tools actually used in session]
argument-hint: [Parameters extracted from session variables]
---
# [Command Name]
[Brief overview from session intent]
## Task
$ARGUMENTS
## Process
[Steps derived from session operations - abstracted]
## Output
[Format observed in session]
Naming Convention: {verb}-{noun}.md or {domain}.{action}.md
Skill Template (Tincture - φ)
---
name: [kebab-case-name]
description: [What + When + Trigger phrases]
---
# [Skill Name]
[Overview paragraph explaining the skill]
## When to Use
[Situations derived from session context]
## Mathematical Foundation
[Category-theoretic or information-theoretic basis if applicable]
## Instructions
### Step 1: [First Operation]
[Details with guidance]
### Step 2: [Second Operation]
[Details with guidance]
...
## Examples
[Concrete examples from session or generalized]
## Best Practices
[Patterns observed working well]
Naming Convention: {domain}-{capability}/SKILL.md
Agent Template (Elixir - φ²)
---
name: [agent-name]
description: |
[Comprehensive description with examples]
model: [opus for complex, sonnet for standard]
color: [thematic color]
tools:
- [Tools used in session]
---
You are the **[Agent Name]**, specializing in [domain].
## Core Identity
[Role distilled from session patterns]
## Mathematical Foundation
[Category-theoretic structure if applicable]
## Your Process
### Phase 1: [First Phase]
[Operations and decisions]
### Phase 2: [Second Phase]
[Operations and decisions]
...
## Decision Framework
[Branching logic from session]
## Error Handling
[Recovery patterns observed]
## Quality Standards
[Quality criteria from session]
Naming Convention: {role}-{specialty}/agent.md
Validation (M.bind)
Apply the monad M to validate the distilled tincture:
M.bind: Tincture → ValidatedTincture
M.bind(t) =
| potency(t) ≥ 0.75 → Success(t)
| otherwise → iterate(t)
Potency Metrics
| Metric | Weight | Formula |
|---|
| Completeness | 30% | |
| Universality | 25% | I(Tincture; NewContext) / H(Tincture) |
| Specificity | 25% | I(Tincture; OriginalSession) / H(Session) |
| Structure | 20% | |
Aggregate Potency:
Potency = 0.30×Completeness + 0.25×Universality + 0.25×Specificity + 0.20×Structure
The Potency Threshold:
If Potency < 0.75: M.bind(refine(t)) recursively
If Potency ≥ 0.75: emit(t)
Validation Checklist
Hermetic Principles:
[ ] Mentalism: Clear intention captured
[ ] Correspondence: Structure preserved
[ ] Vibration: Complexity matched to type
[ ] Polarity: Specific ↔ General balanced
[ ] Rhythm: Natural flow maintained
[ ] Cause & Effect: All operations purposeful
[ ] Gender: Analysis + Synthesis complete
Mathematical Properties:
[ ] Functor laws satisfied
[ ] Entropy reduced
[ ] Mutual information preserved
[ ] Golden ratio balance achieved
Output Format
DISTILLATION_COMPLETE:
prima_materia:
operations: [count]
decisions: [count]
iterations: [count]
complexity_score: [value]
phi_category: "[1/φ | φ⁰ | φ | φ²]"
information_metrics:
session_entropy: [H(Session)]
tincture_entropy: [H(Tincture)]
mutual_information: [I(Session; Tincture)]
compression_ratio: [H(Tincture) / H(Session)]
tinctures:
- type: "[Command | Skill | Agent]"
name: "[name]"
path: "[full path]"
potency: [0-1]
alchemical_trace:
nigredo: "W.extract(session) → patterns"
albedo: "F.map(patterns) → essence"
citrinitas: "φ.classify(essence) → [type]"
rubedo: "Generate([type]) → [path]"
validation: "M.bind(tincture) → potency [score]"
hermetic_alignment:
mentalism: "[intention captured]"
correspondence: "[structure preserved]"
vibration: "[potency level]"
polarity: "[specific↔general balance]"
Distillation Laws
Law 1: Preserve Essence (Functor Faithfulness)
The distillation functor D must be faithful:
D(f) = D(g) ⟹ f = g for session operations f, g
No essential distinctions are collapsed.
Law 2: Reduce Entropy (Compression)
H(Tincture) < H(Session)
The tincture is more ordered than the session.
Law 3: Maintain Mutual Information (Relevance)
I(Session; Tincture) ≥ φ⁻¹ × H(Session)
At least 61.8% of session information is preserved.
Law 4: Balance at Golden Ratio (Quality)
Quality = φ⁻¹ × Specificity + φ × Generality = √5
Optimal balance achieved at the golden ratio.
Law 5: Match Potency to Complexity (Classification)
Type(Tincture) = φ.classify(Complexity(Session))
Higher complexity demands higher potency tincture.
Law 6: Iterate Until Threshold (Refinement)
M.bind^n(t) until Potency(t) ≥ 0.75
Monadic iteration continues until quality threshold.
Law 7: Satisfy Hermetic Principles (Alignment)
∀ principle p ∈ Hermetic: align(Tincture, p) = True
All seven principles must be satisfied.
Anti-Patterns (Failed Distillations)
The Mud - Tincture with no clear structure
Category Error: D is not a functor (doesn't preserve composition)
Violates: Correspondence, Structure
The Vapor - Too abstract, loses essential content
Category Error: Excessive quotienting, H(Tincture) << H(Session)
Violates: Law 3, Specificity
The Tar - Too specific, not reusable
Category Error: Trivial quotient, Tincture ≈ Session
Violates: Law 2, Generality
The Explosion - Complexity misclassified
Category Error: φ.classify returns wrong type
Violates: Law 5, Vibration
The Leech - Extracts wrong patterns
Category Error: W.extract focuses on noise not signal
Violates: Mentalism, Cause & Effect
The Alchemical Formula
SESSION CONTEXT
│ │
▼ │
┌───────┐ │
│NIGREDO│ W.extract │
│ ~~~ │ Dissolution │
└───┬───┘ │
│ │
▼ │
┌───────┐ │
│ALBEDO │ F.map │
│ ○ │ Purification │
└───┬───┘ │
│ │
│ ┌────────────────────┐ │
└───►│ CITRINITAS │◄─────┘
│ │
│ φ.classify │
│ │
│ 1/φ φ φ² │
│ │ │ │ │
│ Cmd Skill Agent │
│ │
└─────────┬──────────┘
│
▼
┌────────────────────┐
│ RUBEDO │
│ │
│ Generate ⊗ │
│ Template │
│ │
└─────────┬──────────┘
│
▼
┌────────────────────┐
│ VALIDATION │
│ │
│ M.bind until │
│ Potency ≥ 0.75 │
│ │
└─────────┬──────────┘
│
▼
┌────────────────────┐
│ TINCTURE │
│ │
│ H(T) < H(S) │
│ I(S;T) ≥ φ⁻¹H(S) │
│ Potency ≥ 0.75 │
│ │
└────────────────────┘
Self-Reference
This skill was itself distilled from the meta-pattern of creating reusable artifacts:
D(D) = distill/SKILL.md
The fixed point of the distillation functor.
The Recursive Structure:
Session(creating reusable artifacts)
→ D(Nigredo): Extract pattern of pattern-extraction
→ D(Albedo): Purify to essence of purification
→ D(Citrinitas): φ² (high complexity) → Agent/Skill
→ D(Rubedo): Generate this document
→ D(Validate): Potency = 0.85
D(D) = This SKILL.md
Quick Reference Formulas
Golden Ratio
φ = (1 + √5)/2 ≈ 1.618033988749895
φ² = φ + 1 ≈ 2.618
1/φ = φ - 1 ≈ 0.618
Complexity Score
Complexity = (Operations × Decisions × Iterations) / 5
Quality Balance
Quality = φ⁻¹ × Specificity + φ × Generality
Optimal at Specificity × Generality = 1
Potency
Potency = 0.30C + 0.25U + 0.25S + 0.20St
Where: C=Completeness, U=Universality, S=Specificity, St=Structure
Information Preservation
I(Session; Tincture) ≥ φ⁻¹ × H(Session)
Entropy Reduction
H(Tincture) < H(Session)
The Alchemist's Creed
"Solve et Coagula"
(Dissolve and Coagulate)
From the prima materia of the session,
Through the nigredo of dissolution,
The albedo of purification,
The citrinitas of golden classification,
Emerges the rubedo of the tincture.
What enters as chaos emerges as cosmos.
What enters as ephemeral emerges as eternal.
What enters as specific emerges as universal.
Version
- Specification Version: 2.0
- Foundation: Category Theory (F, M, W) + Information Theory + Hermetic Alchemy + Golden Ratio
- Mathematical Models: Functor, Monad, Comonad, Adjunction, Quotient Space, Fiber Bundle
- Created: Distilled from session operations analysis and self-applied recursively
"In the Alembic, all things are transformed."
— The Way of Distillation
