crystalline

name

crystalline

description

A working algebra for human-LLM collaboration framed as lapidary practice — cutting, viewing, and re-cutting structured light. Use this skill whenever the user invokes any of the operation-tokens (`distill`, `refract`, `project`, `intersect`, `unite`, `differ`, `cleave`, `twin`, `crystallize`, `nucleate`, `anneal`, `recrystallize`, `polish`, `rotate`, `traverse`, `inspect`, `grade`), names a crystalline object (corpus, gem, facet, lattice, lens, scaffold, seed, plane, inclusion, mother liquor), or describes work in these terms (e.g., "let me cut this differently," "refract this through the skeptic lens," "find the cleavage plane," "twin this argument," "crystallize this material into the scaffold," "polish this passage," "inspect for inclusions"). Especially fits comparative analysis under a shared lens, structured decomposition of an argument or topic, multi-perspective rendering, scaffold-filling from raw material, calibrated epistemic grading, and any task where the user wants composable operations rather than a single ask. Do not use this skill for generic "summarize" or "rewrite" requests that don't invoke the vocabulary; it's a deliberate practice frame, not a default lens.

The crystalline interface: a working algebra for human–LLM interaction

A chat box is the wrong shape. The exchange between a human and a language model is not a conversation but a lapidary act — a process of cutting, viewing, and re-cutting structured light. What follows is a working framework for that act: an opening essay defending the metaphor, a lexicon of named objects and operations with type signatures, a pattern library of prompts that instantiate each operation, and a short note on where the crystal cracks. The goal is a small, composable algebra a power user can hold in mind — rigorous enough to chain, beautiful enough to want to.

---

Why crystalline is the right shape

Every metaphor we use for working with language models smuggles in a theory of what is happening. Conversation implies a single thread, two voices, and turn-taking — and so it hides the most interesting fact about an LLM, which is that any output is one draw from a vast distribution of equally plausible outputs. Search implies the answer pre-exists somewhere and the system retrieves it; this misrepresents both the model (which generates) and the user (who is rarely looking up anything precise). Building is solid but lightless: a wall is finished or unfinished, but it has no spectrum, no angle of incidence, no inside seen from outside. Database is rigid. Oracle is mystical. Each of these metaphors describes a slice of what happens but distorts the whole.

The crystalline metaphor gets four things right at once that no other image gets right together. It is structured. A crystal has a lattice — a deep, repeating substrate that determines what shapes it can take and where it will naturally split. Knowledge has a similar substrate: ontologies, type structures, the implicit ordering of concepts under generality. It is optical. A crystal interacts with light: it refracts, disperses, reflects, returns. Meaning behaves the same way. The same proposition entering an interpretive medium emerges bent, sometimes split into spectrum, sometimes doubled along an unsuspected axis. It is made. Rough crystal exists in nature, but a gem is cut. Someone decides which facets to grind, at which angles, accepting that the cut is a commitment — that some light will be returned and some lost. Every prompt is a cut. And it is alive to perspective. Pleochroism is the phenomenon by which certain crystals show different colors when viewed from different angles. Tanzanite is blue, purple, and red-violet depending on how you turn it — not because it has changed, but because it is anisotropic. A good answer is pleochroic. The user who learns to rotate it sees more than the user who reads it once and stops.

The most generative move in the metaphor is treating refraction as reinterpretation. When light enters a denser medium, it bends; it does not arrive on the other side along the same line. When a question enters a model, it bends through the model's training, the user's framing, the chosen persona, the surrounding context. The output is a refracted ray — the same question made different by the medium it traveled through. Two different lenses produce two different refractions. A lens is not a filter that hides things; it is a structure that bends. This is why "summarize" and "translate to a child" and "argue against" and "rewrite as a haiku" are not different tasks but different lenses on a single gem of meaning, each producing its own refractive ray.

Three more crystallographic facts deserve to be load-bearing. The first is cleavage. A crystal has planes along which it naturally wants to split, set by its atomic geometry; if you strike it correctly, it parts cleanly, and if you strike it incorrectly, it shatters. Knowledge has cleavage planes too: an argument wants to split into premises and conclusions; a topic wants to divide into mechanism and consequence; a project wants to bifurcate into what is technical and what is political. A skilled cutter respects the cleavage. A skilled prompter learns to hear, in a chunk of context, where the seam is. The second fact is inclusion. Real crystals contain trapped fragments of other matter — a mineral grown alongside, a bubble of fluid, a needle of rutile. In gemology, inclusions are sometimes flaws and sometimes signatures of authenticity (silk in ruby, horsetails in demantoid). In an LLM output, an inclusion is an embedded assumption, a quoted phrase, a hallucinated source, a stylistic tic absorbed from training. To inspect a gem is to name its inclusions — not to pretend they aren't there, and not to dismiss them, but to let the user see what is mineral and what is foreign. The third is clarity, graded. Gemology distinguishes a flawless diamond from one that is internally flawless from one with very slight inclusions, and it grades emeralds on a different scale because emeralds are expected to be heavily included. Epistemic confidence is not a number; it is a tiered grading whose baseline depends on the material. A crystalline interface should let the user see clouds where there are clouds and demand clarity where clarity is the standard.

Calvino, in the "Exactitude" memo, declared himself a partisan of the party of the crystal, opposed to the party of the flame: precise, stable, faceted form against turbulent unceasing transformation. He admitted envy of the flame; the crystal is not the only beauty, and not always the right one. But for an interaction in which a question is being made into an artifact, the crystal is exactly right. It is the form that holds while still admitting light. Wittgenstein, in the Investigations, warned that the crystalline purity of logic was a requirement we had imposed, not a discovery we had made — and so it is here. We do not claim that knowledge is crystalline. We claim that treating LLM interaction as a lapidary practice gives users primitives they can compose, where treating it as a chat gives them only the affordances of speech. The metaphor is a tool, and tools, as Bret Victor insists, shape thought.

What follows builds the tool out: a small set of named objects, a small set of named operations on them, type signatures that say which operations consume what and return what, prompt templates that show how to perform each operation in practice, and worked examples of operations chained into workflows. The goal is the same goal Christopher Alexander pursued for buildings — a pattern language whose elements compose, whose grammar is shared, and whose deployment generates a quality the user recognizes but cannot quite name. Here it has a name. We will call it clarity.

---

The lexicon: objects, operations, and their type signatures

The lexicon has two registers. Objects are the nouns the system manipulates. Operations are the verbs that take objects to objects. Type signatures, given in a Haskell-flavored pseudocode, declare what each operation expects and produces. Composition follows the obvious rule: if f : A → B and g : B → C then g ∘ f : A → C, and the algebra is the set of legal chains.

Objects

A corpus is raw material — an unstructured or loosely structured body of text, data, or context: Corpus = Set Item. A corpus is what you have before you have decided what shape to give it. Slack threads, a folder of papers, a transcript, a scratchpad. The corpus is the rough.

A gem is a corpus that has been cut: it has structure, an explicit set of facets, and a history of operations: Gem = (Content, Lattice, [Op]). Where a corpus is what you brought, a gem is what you made. Gems can be re-cut; gems can be combined; gems carry their provenance.

A facet is a single articulated angle on a gem — one perspective, one rendering, one slice: Facet g a = (Gem g, Aspect a, View). Facets share edges with adjacent facets; together they constitute the face-up appearance of the gem.

A lattice is the ordered structure of concepts within or across gems, with a partial order ≤ giving generality: Lattice = (Concepts, ≤, ⊓, ⊔). Borrowed directly from Formal Concept Analysis: every set of objects-and-attributes induces a complete lattice in which sub-concepts sit below super-concepts, meets exist, joins exist, and one can navigate by adding or dropping attributes. The lattice is the skeleton of generality; the gem is its embodiment in a particular cut.

A lens is a structure-preserving viewing apparatus that takes a whole and returns a focused part, with the ability to put back: Lens s a = (get : s → a, put : s → a → s). The lens laws — that putting back what you got changes nothing, that what you put is what you get, that the last put wins — are exactly the discipline that distinguishes a real perspective from a distortion. Lenses compose: drilling in is just function composition. A persona, a retrieval index, a constraint grammar, a style, an audience model — each is a lens.

A scaffold is a structured skeleton with named slots awaiting content: Scaffold = Tree (Slot | Filled). Borrowed from Christopher Alexander: a pattern that calls smaller patterns to complete it. Filling out the meat on the bones is a primary operation; the scaffold is the bones. A document outline, a function signature, a memo template, a lattice with empty nodes.

A seed is a small nucleus that, dropped into a saturated context, directs growth: Seed = Item. An exemplar, a crystal of the right form, a single aphorism around which a longer essay will accrete. Seeds bypass random nucleation.

A plane (cleavage plane) is a declared axis along which a gem will split cleanly: Plane = Predicate × Predicate. Planes are discovered, not chosen — the cutter who picks the wrong plane shatters the stone.

An inclusion is an embedded foreign artifact within a gem: a quotation, a borrowed assumption, an unverified claim, a stylistic fragment from the training corpus: Inclusion = (Origin, Region, Kind). Inclusions are sometimes flaws, sometimes provenance.

A mother liquor is the residual context discarded after crystallization: the parts of the corpus that did not make it into the gem but that constituted its growth medium. Worth keeping in case you need to recrystallize.

Operations

The following table gives the core operations and their types. Each is described in prose afterward.

Operation	Type signature	One-line reading
distill	Corpus → Gem	extract structured essence from raw material
refract	Lens s a → Gem s → [Facet a]	split a gem into spectral facets through a lens
project	Lens s a → Gem s → Facet a	render one specific face
intersect	Lens → Gem → Gem → Gem	find shared structure under a common view
unite	Gem → Gem → Gem	merge two gems into a larger one
differ	Gem → Gem → Gem	what is in the first but not the second
cleave	Plane → Gem → (Gem, Gem)	split along a discovered seam
twin	Axis → Gem → (Gem, Gem)	generate a paired alternative reading
crystallize	Scaffold → Material → Gem	fill the scaffold
nucleate	Seed → Context → Gem	grow a gem from a seed in a saturated context
anneal	Gem → Gem	slow iterative refinement; relieve strain
recrystallize	Gem → Gem	dissolve and regrow to purify
polish	Gem → Gem	surface-level finishing of phrasing
rotate	Angle → Gem → Gem	shift the privileged viewing axis
traverse	Path → Lattice → [Concept]	navigate the concept lattice
inspect	Gem → [Inclusion]	enumerate embedded artifacts and their kinds
grade	Gem → Clarity	calibrated epistemic-confidence reading

Distill takes raw material and returns a structured gem; it is the operation of looking at a Slack export, a transcript, or a research dump and producing the lattice latent in it. A distillation is lossy — that is its point — but the loss is principled. The mother liquor remains on disk. Refract is the spectral operation: a single gem entering a lens emerges as multiple facets, each a coherent rendering on a different wavelength. Pleochroism is the static version (the gem already shows different colors from different angles); refraction is the dynamic act of producing them. Project is refract's singular cousin: one lens, one face, no spectrum.

Intersect and unite are the Boolean operations on gems, but with the FCA twist: they take place under a lens, which determines what counts as the same and what counts as different. Two gems intersected under a methodological lens yield their shared method; intersected under a topical lens, their shared topic. Differ gives asymmetric contrast; symmetric difference is the sometimes-useful operation of "where these disagree." Cleave is the discovery operation: presented with a gem, find the plane along which it wants to split, and split it there. Twin is the productive duplication: a gem reflected across an axis — yes-and-no, mechanism-and-consequence, technical-and-political — producing a pair that share a composition surface. Twinning is not contradiction; it is structural dualism.

Crystallize fills a scaffold. Given a structured skeleton with named slots and given material to draw from, populate the slots in a way consistent with the scaffold's grammar. Nucleate is the inverse: given a seed and a saturated context, grow outward from the seed until a coherent gem forms. The first asks "given the bones, where is the meat?"; the second asks "given this aphorism, what is the essay?"

Anneal, recrystallize, and polish are the three refinement operations, distinguished by depth. Polish is surface: phrasing, rhythm, transitions. Anneal is structural relaxation under sustained low heat: re-read, re-arrange, allow strain to leave. Recrystallize is dissolution and regrowth: throw out the current cut and reform from the same chemistry. Rotate changes the optic axis — the privileged angle along which the gem reads as a single voice — without re-cutting. Traverse walks the lattice, producing a path from concept to concept by adding or dropping attributes; it is how one navigates from "this idea" to "the more general idea above it" to "the sibling specialization." Inspect audits inclusions; grade assigns a tiered clarity, distinguishing cosmetic from structural uncertainty.

This list is not closed. The discipline of the framework is that every legitimate move in human–LLM interaction should be expressible as a composition of these primitives, and where it cannot, a new primitive should be named — not invented as jargon, but recognized in the metaphor.

---

Prompt patterns: how to perform each operation

Each operation below has a copyable scaffold. The convention is that angle brackets mark slots the user fills, and {{double braces}} mark objects from the workspace (a previously distilled gem, a saved lens, a stored scaffold). The patterns are written to be model-agnostic. They lean on the model's ability to follow named primitives if those names are introduced once at the top of a session.

Distill: corpus → gem

Distill the following corpus into a gem. Identify the lattice of concepts present (general → specific). For each concept, name it precisely, give a one-sentence intent, and list the items in the corpus that instantiate it. Mark concepts whose support is thin as cloudy. Discard repetition into a separate mother liquor section.

Corpus: <<<paste corpus>>>

The output of a good distillation is not a summary but a structure: a small lattice with concepts as nodes, items as evidence, and an explicit cloudiness annotation. It is reusable — the next operation can take this gem as input.

Refract: gem × lens → facets

Refract {{gem}} through the following lens, returning one facet per spectral line. The lens is <lens description>. For each facet, give it a name, render the gem from that angle in 3–6 sentences, and note what the angle reveals that other angles obscure. Do not collapse the facets into a synthesis.

Lenses worth keeping in a personal library: the skeptic, the implementer, the historian, the adversary's strongest version, the new hire, the next decade, the budget, the failure mode, the child, the lawyer, the artist. Each is a Lens s a whose get extracts a coherent face and whose put defines what edits in that view mean for the whole.

Project: gem × lens → one facet

Project {{gem}} through {{lens}}. Render only the single face this lens selects, with no other angles considered. Be uncompromising in the lens's voice.

Project is what Refract becomes when only one wavelength is wanted. It is the appropriate operation for executive summaries, for code comments, for the email that goes out.

Intersect through a lens: gem × gem × lens → gem

Intersect {{gemA}} and {{gemB}} under the lens of <shared aspect>. Return only the structure they share under this view: shared concepts, shared evidence, shared moves. List explicitly what each gem contributes that the other does not (this is the symmetric difference; keep it for later but do not include it in the intersection).

The intersection should itself be a gem: name its concepts, give its lattice, mark cloudy regions.

This is the operation behind almost every comparative-analysis task. The lens is what makes it tractable — without a lens, intersection of two large gems is intractable and produces noise. A lens compresses both inputs into the same coordinate system before the meet is taken.

Unite, differ, symmetric-difference

Unite {{gemA}} and {{gemB}} under {{lens}}. Produce a single gem whose extent contains both, resolving conflicts by <keep both | prefer A | prefer B | flag>. Mark every node with its origin. Where the two gems disagree on the same node, twin them (see Twin) rather than choosing.

Differ {{gemA}} from {{gemB}}. Return everything in A that is not in B, with each item annotated by why B lacks it (omission, contradiction, scope mismatch).

Cleave: gem → (gem, gem)

Examine {{gem}} for cleavage planes. Identify the two or three axes along which it naturally wants to split (examples: mechanism/consequence, what-is/what-ought, technical/political, near-term/long-term, controllable/uncontrollable). For each candidate plane, give the predicate that defines each side, then strike the most promising plane: split the gem into two child gems along it. Give each child gem its own name and lattice.

Cleavage is the operation users most often do badly because they pre-decide the axis. The pattern's discipline is to make the model surface candidate planes before committing.

Twin: gem × axis → (gem, gem)

Twin {{gem}} across the axis of <axis>. Produce two coherent versions of the gem that share a composition surface — same content, mirrored interpretation. Make each side internally consistent and as strong as possible (steelman both). Identify the twin plane: what exactly are they reflecting across? Note where the bonds continue across the plane (shared structure) and where they stop (genuine disagreement).

Twin is the right operation for any decision where the rhetorical move "argue both sides" is too crude. Real twins share atoms across the boundary; they are not separate stones glued together.

Crystallize: scaffold × material → gem

Crystallize material into the following scaffold. For each slot, draw from the material to produce content that satisfies the slot's local grammar and is consistent with the populated neighbors. Where the material is insufficient for a slot, mark the slot under-saturated rather than fabricating. When done, walk the scaffold and report which slots are fully-grown, which are cloudy, which are empty.

Scaffold: <<<paste scaffold with slot names and per-slot constraints>>>

Material: <<<paste corpus or gem>>>

This is the pattern behind "filling out the meat on the bones." The crucial discipline is the under-saturation flag: an honest crystallization reports where the bones are visible, rather than papering them over.

Nucleate: seed × context → gem

Nucleate from this seed. The seed is <seed: a phrase, an aphorism, an example, a single fact>. The context is the saturated solution {{context}}. Grow outward from the seed: what concepts does it imply, what evidence does the context offer, what is the smallest coherent gem that contains the seed and its immediate neighbors? Stop when growth slows; do not force.

Nucleation is the right operation for the moment when a user has something — an intuition, a phrase, a worked example — and wants the model to grow a structure around it rather than start from a blank prompt.

Anneal, recrystallize, polish

Anneal {{gem}}. Re-read it slowly. Identify points of strain: places where the structure works against itself, where transitions force, where the cut fights the cleavage. Relieve them with the smallest local edits that reduce strain; do not re-cut. Report what strain was relieved.

Recrystallize {{gem}}. The chemistry is right but the cut is wrong. Discard the current structure entirely; from the same content, propose two or three new lattices and pick the one with fewest forced transitions. Regrow the gem in the new lattice.

Polish {{gem}}. Surface only: phrasing, rhythm, sentence length, transition words. Do not change structure or add content.

Rotate, traverse, inspect, grade

Rotate {{gem}} so that the optic axis runs along <new privileged dimension>. Re-render so that the new axis reads as a single voice; the perpendicular dimensions become subordinate.

Traverse {{lattice}} from <start concept> to <end concept>, moving by generalization (drop attributes), specialization (add attributes), or sibling-shift (swap one attribute). Show each step.

Inspect {{gem}} for inclusions. For each inclusion, identify its origin (training-data fragment, user-provided quotation, embedded assumption, hallucinated source, stylistic borrowing), its region (where in the gem), and its kind (cosmetic, structural, provenance-bearing). Do not remove them; surface them.

Grade {{gem}} for clarity. Use the tiered scale: flawless, internally flawless, very slightly included, slightly included, included. Calibrate the baseline to the material — a gem about contested empirics expects more inclusions than a gem about a definition. State the baseline, then the grade.

Three worked compositions

The point of the algebra is composition. Three short workflows show how operations chain.

Composition 1: From a Slack thread to a decision memo. A long, conflict-laden Slack export needs to become a one-page memo for a director.

gem    = distill(slack_export)
planes = cleave(gem)                      # discover candidate seams
(stakes, mechanics) = strike(gem, plane="what-is-at-stake / how-it-works")
twinned = twin(stakes, axis="cost-bearer")    # who pays under each option
intersection = intersect(twinned.left, twinned.right, lens="shared-constraints")
scaffold = decision_memo_scaffold        # context · options · tradeoffs · recommendation
memo = crystallize(scaffold, material = (mechanics, twinned, intersection))
final = polish(anneal(memo))
report = inspect(final)                  # surface remaining inclusions

The user never asks the model to "write a memo." They ask the model to perform a sequence of operations whose final product is a memo, and they audit each intermediate gem.

Composition 2: Synthesizing two literatures through a single lens. The user has read corpus A on attention mechanisms in neuroscience and corpus B on attention in transformer architectures, and wants to know what they actually share.

gemA = distill(corpus_neuroscience)
gemB = distill(corpus_ml)
lens_mechanism = lens(get = "what is the proposed mechanism of selectivity",
                      put = "edits to the mechanism description propagate as ...")
faceted_A = refract(lens_mechanism, gemA)   # spectral split of mechanisms
faceted_B = refract(lens_mechanism, gemB)
shared = intersect(gemA, gemB, lens = lens_mechanism)
contrast = differ(gemA, gemB)               # what the brain side has that ML lacks
contrast' = differ(gemB, gemA)
synthesis = unite(shared, twin(contrast, contrast', axis="biological-vs-engineered"))
graded = grade(synthesis)                   # honest about cloudiness

The lens is the move that makes the comparison non-trivial. Without lens_mechanism, intersecting two large literatures returns banalities ("both involve selectivity"). With it, the intersection is forced into a shared coordinate system and the contrast becomes legible.

Composition 3: Growing an essay from an aphorism. The user has the line "the chat box is the wrong shape" and wants a 1500-word essay.

seed   = "the chat box is the wrong shape"
context = saturate(personal_notes ∪ recent_reading ∪ working_examples)
embryo = nucleate(seed, context)            # smallest coherent gem containing the seed
faceted = refract(lens="why-now / what-it-replaces / what-it-enables / where-it-fails", embryo)
scaffold = essay_scaffold(opening · three_arguments · counter · close)
draft = crystallize(scaffold, material = faceted)
twinned_close = twin(draft.close, axis="hopeful-vs-cautious")
final = polish(anneal(rotate(draft, optic_axis = "the user as lapidary")))

The seed nucleates a small gem; refraction produces the spectrum of angles that fill an essay scaffold; rotation chooses the voice. The user composes operations, the model performs them, the workspace accumulates intermediate gems any of which can be reused.

---

Where the crystal cracks

A metaphor is a tool, and like every tool it has a domain of use beyond which it deforms the work. Three places this one strains, named honestly so the user knows when to reach for something else.

The lattice presumes a settled order of generality. Real research often happens in regions where the lattice does not yet exist — where nobody knows which concepts are super-concepts of which, or whether two purported concepts are even commensurable. Formal Concept Analysis builds the lattice from a context, but it requires the context to be specifiable: objects, attributes, an incidence relation. In genuinely exploratory work, the user is constructing the context as they go, and the framework's lattice operations have to be deferred until enough material exists. In the early, fluid phase, Deleuze's rhizome is the better image than the crystal — any-point-to-any-point connection, no privileged axes, and not or. A practical interface should expose both modes and let the user notice when crystallization is ready to begin.

Refraction implies a stable medium. A real lens has a well-defined refractive index; you can predict what the bending will do. A persona lens or a constraint lens applied to an LLM does not have this stability — the same lens applied to two similar gems can produce surprisingly different refractions because the underlying medium (the model) is itself shifting in response to context. The framework's lens laws (get-put, put-get) are aspirational; in practice, a lens applied to an LLM violates them in subtle ways. The honest move is to treat lens behavior as approximately rather than exactly law-abiding, and to inspect for inclusions afterward.

Faceting privileges legibility over surplus. A cabochon cut is dome-smooth, unfaceted, made for translucent stones whose value is the play of light beneath the surface rather than its sharp return. Some materials — poetry, mood, undecidable ethical questions, the inside of someone's grief — are cabochon material, and faceting them shatters what they were for. The crystalline framework is excellent for analytical and constructive work and bad for material whose value is its untransparency. Not everything wants to be cut. A power user knows when to put the loupe down.

A final caution. Wittgenstein noticed that the crystalline purity of logic was a requirement we had imposed on the world, not a property we had found in it. The same is true here. We are not claiming that thought, knowledge, or LLM output is really crystalline. We are claiming that treating it as if it were gives us primitives we can compose, names we can share, and operations we can teach — which is what a medium is. The chat box pretends the interaction has no shape. The crystal admits a shape and lets the user choose the cut.

That is the whole proposal. The vocabulary is small enough to memorize. The operations compose. The aesthetic is not decoration; it is what makes the framework holdable in working memory, the way Alexander's pattern names were holdable, the way good APIs are holdable. A user who internalizes "distill, refract, cleave, twin, crystallize, anneal" interacts with a model differently than one who only knows "ask, follow up, ask again." The former is doing lapidary work. The latter is talking to a box.

The light is already there. The lattice is already there. The cut is the part the human brings.

---

Frame-shift detection

If mid-flow the work's shape changes — the user starts growing into a substrate they're building, or starts engaging with terrain they didn't make — surface the shift and offer to switch frames: /myc for substrate work, /nav for terrain work. Don't silently re-frame.