Lineage Skill turns course material into a source-backed teacher Skill

The gap Lineage Skill targets: summaries you cannot act on

Most course summarizers answer one question: what did the teacher say. Lineage Skill asks a different one: can you do it afterwards. The README frames the project as an apprenticeship, and the Chinese tagline translates roughly to "mentorship, not doing it for you". The intended user is someone who owns a real body of material, a recorded course, a stack of scanned handouts, a set of lecture notes, and wants a persistent assistant that teaches from that material rather than from the open web. It is not aimed at people who want a quick digest of a single article. The README is explicit that the end goal is not permanent dependence on an AI tutor but the ability to solve real problems without prompts, which shapes almost every design decision below.

How the distillation pipeline is laid out

The repository is a Python project with a flat, readable layout: scripts/, references/, agents/, examples/, tests/, plus an install_as_skill.sh at the top level and a SKILL.md that describes the skill itself. The README describes a seven-step flow that the user never has to drive manually: inventory the material, confirm the learning goal, transcribe and parse, extract provenance, distill the teacher's method, design exercises, and run a quality check. Two example files, examples/command-line-flow.txt and examples/generated-skill-structure.txt, document the command flow and the shape of the generated skill. The .env.example splits model access into three independent provider slots: audio transcription, vision analysis and text distillation, each with its own key, base URL and model. That separation is the most interesting architectural choice, because it means a cheap local transcription model and an expensive reasoning model can coexist in one run. The README also states that existing transcripts are reused rather than reprocessed, and that multiple teachers' material is kept separate rather than merged into one blended answer.

Installing Lineage Skill and running a first distillation

The README tells users they do not need to run project scripts or understand the internal file structure, and points to docs/install.md as the installation guide, suggesting you hand that file to your AI assistant. The repository also ships install_as_skill.sh, and requirements.txt pins four dependencies: openai>=1.0.0, python-dotenv>=1.0.0, requests>=2.31.0 and pillow>=10.0.0. If you prefer to set it up yourself, the conventional path is to clone, install the requirements, and copy the environment template.

pip install -r requirements.txt
cp .env.example .env

After copying, fill in only the providers you actually use. The template comments say not to commit .env and to keep tokens, private endpoints and local course paths out of git. The transcription slot defaults to an OpenAI-compatible /audio/transcriptions endpoint at https://api.siliconflow.cn/v1 with the model FunAudioLLM/SenseVoiceSmall. The vision slot expects a chat completions endpoint that supports video understanding, with LINEAGE_VISION_TIMEOUT set to 600. The text slot defaults to https://api.openai.com/v1.

AUDIO_TRANSCRIBE_API_KEY=your-key
AUDIO_TRANSCRIBE_BASE_URL=https://api.siliconflow.cn/v1
AUDIO_TRANSCRIBE_MODEL=FunAudioLLM/SenseVoiceSmall
LINEAGE_TEXT_API_KEY=your-key
LINEAGE_TEXT_BASE_URL=https://api.openai.com/v1
LINEAGE_TEXT_MODEL=gpt5.5

Two optional switches matter. DISTILL_USE_LLM=1 selects LLM distillation, and setting it to 0 falls back to local extractive distillation, which the template describes as an alternative to LLM distillation. DISTILL_CHUNK_SIZE=6000 and DISTILL_CHUNK_OVERLAP=500 control how text is split. MINERU_API_TOKEN enables MinerU or OCR parsing for scanned documents, and the README notes that scanned material and audio require an available service to be processed at all. Once configured, the README's first-use prompt is to ask Lineage to inspect the course material, report what it found and what is missing, then produce and enable a course Skill. The delivery report is supposed to list which videos, documents, chapters and notes were processed, which conclusions are traceable, which items are weak or need human confirmation, and whether the result can fully teach, only guide, or only support lookup.

Where Lineage Skill is the wrong tool

The honest limitation is that Lineage Skill is a pipeline over your material, not an oracle. The README states that if the necessary conditions are missing it will say what is missing and how far it can still go, and that when material is only enough to explain concepts it falls back to lookup or guided learning rather than pretending to be a full tutor. That is a real constraint: a single lecture recording will not produce a course-length apprenticeship. Scanned PDFs and audio depend on external services, so without a MinerU token or a transcription endpoint those inputs simply do not enter the pipeline. The .env.example also reveals a practical trap: the default vision model string is a placeholder-style value that points at your own OpenAI-compatible vision endpoint, and the text default is gpt5.5, so anyone copying the template without editing it will get connection failures rather than a helpful error. Finally, the project is explicit that it does not replace professional qualification in medicine, law, finance or investment, and that you must only process material you have the right to use. If your goal is breadth across the public web rather than depth in one owned corpus, this is the wrong shape of tool.

How it differs from a plain RAG assistant

The obvious alternative is a general retrieval-augmented assistant over the same files: embed the PDFs and videos, then ask questions. The difference in approach is that a RAG assistant optimizes for answering, while Lineage Skill optimizes for producing a durable teaching artifact. Concretely, the README describes an output that includes a learning route ordered by dependency, exercises that deliberately withhold the full answer, per-question feedback after you respond, and a separation between the course Skill and your personal attempts, errors and review schedule, so regenerating the Skill does not delete your history. A RAG setup typically has none of those: no staged practice, no provenance requirement on each conclusion, no distinction between the teacher's original intent, the tool's synthesis, AI inference and your own real-world evidence. The trade-off is cost and setup. A RAG assistant needs an index and a chat loop. Lineage Skill needs three provider slots configured, an optional OCR token, and enough material to justify distillation at all.

Maintenance, upgrade cost and licence terms

The last push to the default branch was on 2026-07-23, which is roughly two months before today. There are no retrieved releases, so installation is from the repository itself rather than from a versioned package. That has two consequences. First, upgrading means pulling the repository and re-reading CHANGELOG.md, which the README links, rather than bumping a pinned version. Second, the dependency surface is small and mostly stable: openai, python-dotenv, requests and pillow, all specified with lower bounds only, so a fresh install can pull newer major versions than the author tested. The project is licensed under Apache License 2.0, which permits commercial and private use and includes an explicit patent grant, but it does require preserving the licence and notice files and states the terms for modified distributions. That is a summary of the licence text, not legal advice; if you plan to redistribute a modified version or ship the generated Skill inside a product, read LICENSE and, where the stakes are high, consult counsel. Note also that the licence covers the code, not the course material you feed it, and the README asks users to respect course copyright and distribution limits.

Editorial conclusion

Adopt Lineage Skill if you already own a body of course material and want an assistant that cites it, quizzes you in stages and keeps your attempts separate from the generated Skill. Do not adopt it if you want a general chatbot over the web, if your material is a single short article, or if you cannot supply an OpenAI-compatible endpoint for transcription, vision or text distillation. Before committing, verify three things: that the provider you intend to use accepts the model names in .env.example, that you have the right to process the course material, and that you are comfortable with original material and personal learning records living outside the generated Skill. The README's own boundary is the clearest signal: when the material is thin, it says it retreats to lookup or guided study rather than pretending to be a complete tutor.

Frequently asked questions

Official sources

1. Issues
2. JuneYaooo/lineage-skill on GitHub
3. License: Apache-2.0
4. README