`ljg-explain-concept`: The Claude Code skill that compiles a word into insight

Inside a prompt system that fan-outs across eight lenses, then compresses everything into one epiphany, one formula, and one org-mode note.

9 min read • View on GitHub • More from lijigang

A single concept card is fed into an engraving press surrounded by eight optical lenses, then exits as three compact artifacts: a formula, a sentence, and an ASCII topology sheet. It explains the repo's central claim that conceptual breadth is valuable only when it can be compressed into something reusable. — The skill turns one term into many perspectives, then squeezes the result into a note you can save.

Claude Code skill: 8-dimensional concept anatomist. Deconstructs any concept into epiphany.

lijigang, Author · ljg-explain-concept README

Key Takeaways

`ljg-explain-concept` treats explanation as a compression problem, not a verbosity problem.
The eight lenses matter because they force the model to resolve tension before it settles on a note.
`org-mode` and basic ASCII make the output portable enough to drop straight into a local knowledge base.
The repo's real product is a reusable artifact that survives after the conversation ends.

Most explanation tools try to add more detail. ljg-explain-concept does the opposite. It takes a single word, forces it through eight conflicting lenses, and then strips the result down to a formula, a sentence, and an ASCII topology. That is why the repo reads less like a prompt and more like a conceptual compiler.

A concept becomes a specimen

The skill assumes the target is not a topic to summarize but an object to inspect. The input is one concept, and the output is meant to live in a local note file, not in chat. In that sense, the repo is tuned for capture, not conversation.

That framing matters. The article the skill produces is not an essay. It is an artifact you can reopen, search, and reuse later. The whole design pushes the model toward a saved object, not a one-off answer.

The eight lenses that make the model argue with itself

A pipeline diagram that shows one concept fanning out across eight lenses and then collapsing into three finished outputs.

Eight lenses orbit a single word like instruments in a calibration rig. Each lens represents a different mode of inquiry, showing how the skill creates productive tension before synthesis. — The lenses are not there to broaden the answer. They are there to make shallow certainty harder.

This is the trick: the lenses are not there to broaden the answer. They are there to make shallow certainty hard. History, language, mathematics, phenomenology, aesthetics, and existential framing pull in different directions, so the model has to synthesize instead of coast.

Compression is the invention

A press squeezes a messy bundle of notes into three finished slips of paper, one formula, one sentence, one ASCII map. It explains why compression is the actual invention, not the multi-lens expansion. — The repo's real novelty is not the analysis burst. It is the squeeze that makes the result portable.

The interesting move comes after expansion. Instead of stopping at a rich pile of observations, the skill compresses them into three dense outputs: a formula, a Feynman-style sentence, and an ASCII topology map. That is the repo's invention. It treats compression as a creative act, not a cleanup step.

The destination is an org-mode file in ~/Documents/notes/. That matters because the output lands in a format built for outline thinking, quick scanning, and later reuse. The note is supposed to look like something you would actually keep.

* entropy
:PROPERTIES:
:TYPE: concept-anatomy
:END:
- One formula: ...
- One sentence: ...
- One ASCII topology:
  + concept
  |-- history
  |-- language
  `-- form

Why org-mode and ASCII are not incidental

The file format is part of the philosophy. org-mode turns the result into a living note instead of a screenshot. Basic ASCII topology keeps the shape readable anywhere, which is a quiet but serious compatibility decision.

Axis	Generic 'Explain X' prompt	`ljg-explain-concept`
Input shape	A broad question that invites a broad answer	One concept pushed through a staged analysis pipeline
Reasoning style	Usually one-pass and linear	Eight lenses create tension before synthesis
Output shape	A long explanation	A formula, a sentence, an ASCII topology, and an org note
Storage	Chat transcript	Local note in `~/Documents/notes/`
Best use	Quick clarification	Deep capture for PKM and later reuse
Failure mode	Verbose but shallow	Can feel over-designed if you only want a definition

On the left, a generic prompt spills into a fog of loose paragraphs. On the right, a strict pipeline leaves behind a tight note, showing the difference between more words and more structure. — The contrast is not between right and wrong. It is between open-ended explanation and disciplined capture.

This is why the repo feels more like a pipeline than a prompt. It asks the model to do the hard part twice, first by expanding the field and then by collapsing it into an object you can keep. That is a very different bargain from ordinary prompting.

Who built it, and why the ecosystem matters

Li Jiguang's broader Claude Code skill set makes the pattern feel less like a one-off trick and more like a product family. ljg-explain-concept is the compact version of that thinking. It is a workflow you install, not a paragraph you copy.