Raw capture
Drop everything here with zero friction. Notes, transcripts, snippets, internal standards, practical examples — the burden of categorisation belongs to the agent, not to you.
Methodology
Use the pack authoring methodology when the knowledge is still messy
This methodology is based on the LLM Wiki approach. You capture raw material, an agent compiles it into structured, interlinked knowledge, and you codify only what is verified. The result is a pack built from real expertise rather than manufactured documentation.
The problem with starting from scratch
The fastest way to create a weak pack is to open a blank file and try to write a polished product in one go. You end up manufacturing documentation rather than packaging real knowledge. The result is thin, abstract, and hard for other teams to actually use.
The stronger pattern: capture real source material first, let an agent compile it into structure, then codify only what is verified and reusable.
Where this approach comes from
This pipeline is based on the LLM Wiki methodology — an idea developed by Andrej Karpathy. The core insight is that traditional RAG (uploading files and retrieving chunks at query time) is ephemeral: the model re-derives context from scratch on every query and nothing accumulates.
The LLM Wiki approach inverts this. Instead of querying a static dump, you use an agent to incrementally compile raw material into a persistent, interlinked knowledge graph. Knowledge compounds over time rather than evaporating between sessions.
Four layers
A practical model for turning experience into a sellable pack
Use these layers to move from messy inputs to something another team can actually install.
Knowledge shaping
Point your agent (Claude Code, Cursor, etc.) at .sys/schema.md and ask it to compile the raw folder into the wiki. The agent extracts concepts, entities, and sources, links them together, and maintains an index. You review and correct — the agent writes.
Codification
Review the shaped wiki and promote only the verified, reusable material into the publishable pack source created with `ctx pack create`. This is the human-in-the-loop checkpoint before anything becomes a distributable product.
Productization
Publish a clean version, then manage the marketplace-facing experience: release notes, visibility, ownership, lifecycle, and future versions.
What belongs in a first good pack
- A clear use case or outcome
- Knowledge that is specific enough to be valuable
- A process or standard someone else could actually follow
- Enough structure that validation and versioning make sense
What usually means you are not ready yet
- The material is still mostly raw notes with no clear shape
- You cannot explain who the pack is for
- The pack is trying to solve too many unrelated problems at once
- You have not yet separated reusable knowledge from scratchpad noise