How the RIA-TV++ Pipeline Distills Books into Executable Skills: A Complete Technical Guide

The RIA-TV++ pipeline transforms book content into Claude Code-compatible AI skills through seven structured stages, from Adler analysis to pressure-tested deployment.

The RIA-TV++ methodology, implemented in the open-source kangarooking/cangjie-skill repository, solves a critical gap in AI agent capabilities: converting static knowledge into actionable, verifiable skills. Traditional book summaries remain passive reference material. This pipeline produces SKILL.md files that Claude Code can directly invoke with triggers, execution steps, and boundary conditions.

The Seven-Stage Pipeline Architecture

Each stage adds specific metadata layers, culminating in self-contained skill packs ready for AI agent deployment.

Stage 0: Adler Analysis — Whole-Book Comprehension

The pipeline begins with Mortimer Adler's four-step reading method plus a fifth "Applicability" dimension. This produces BOOK_OVERVIEW.md, a structured summary covering:

• Structural: What the book says
• Interpretive: What it means
• Critical: Whether it's true
• Synoptical: How it compares to other works
• Applicability: How to act on it

The specification lives in [methodology/01-stage0-adler.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/01-stage0-adler.md). This foundation ensures subsequent extraction operates on genuine comprehension rather than surface scanning.

Stage 1: Parallel Extraction — Five Specialized Extractors

Five concurrent extractors pull candidate units from the source text:

Extractor	Target Output
Principle	Core mental models and laws
Framework	Structured methodologies and systems
Case	Concrete examples and applications
Counter-example	Failure modes and exceptions
Glossary	Term definitions with domain context

Prompt definitions for each extractor are maintained in extractors/*.md. Running in parallel prevents the "single-lens" bias that degrades traditional summarization.

Stage 2: Triple Verification — Quality Gates

Each candidate must survive three independent validation checks:

1. Source density: ≥ 2 supporting passages from the original text
2. Transfer test: Ability to answer a novel question not in the training context
3. Non-obviousness: Exclusion of commonsense knowledge that doesn't require book extraction

Failures at any gate return the candidate for reconstruction or discard. This stage is detailed in methodology/03-stage1.5-triple-verify.md.

Stage 3: RIA++ Construction — The Six-Dimension Skill Format

Verified content is structured into RIA++ (Reading, Interpretation, Application++, Execution, Boundary). This format, specified in [methodology/04-stage2-ria-plus.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/04-stage2-ria-plus.md), produces SKILL.md files with this front-matter structure:

Dimension	Field	Purpose
R	source_quote	≤ 150 characters / 100 words, verbatim citation
I	interpretation	5-15 lines, author's own words
A1	past_cases	Historical examples from the book
A2	trigger	Activation condition (bilingual for robust detection)
E	steps	Numbered execution instructions with completion criteria
B	boundaries	Explicit non-application scenarios

The description field — populated from A2 (Future Trigger) — is what Claude Code evaluates at runtime to decide skill activation.

Stage 4: Zettelkasten Linking — Knowledge Graph Construction

Skills aren't isolated. This stage identifies dependencies, contrasts, and composition relationships, producing INDEX.md as a traversable knowledge graph. When skill A requires skill B as prerequisite, or skill C contradicts skill D, these links enable coherent multi-skill reasoning.

See methodology/05-stage3-zettelkasten.md for linking heuristics.

Stage 5: Pressure Testing — Adversarial Validation

Each skill faces automated test prompts designed to expose weaknesses:

• Bait questions: Queries that sound relevant but should not trigger this skill
• Cross-skill confusion: Scenarios where multiple skills might activate incorrectly
• Edge case probing: Boundary-condition inputs

Failures trigger reconstruction of A2, E, or B sections. Generated prompts are stored in test-prompts.json. The testing protocol is defined in [methodology/06-stage4-pressure-test.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/06-stage4-pressure-test.md).

Stage 6: Delivery — Installation and Distribution

Final outputs include:

• DIGEST.md: Reader-facing long-form summary
• Skill pack directory: Collection of verified SKILL.md + test-prompts.json files
• Installation hooks: Ready for Claude Code / Cursor skill directories

Delivery procedures are documented in [methodology/07-stage5-deliver.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/07-stage5-deliver.md).

Practical Implementation: Code Examples

Rendering a Skill from Template

The repository uses Jinja2 templating to generate standardized skill files:

# render_skill.py — Generate a SKILL.md from validated RIA++ content

import pathlib
import jinja2

template_path = pathlib.Path("templates/SKILL.md.template")
skill_template = jinja2.Environment(
    loader=jinja2.FileSystemLoader(template_path.parent)
).get_template(template_path.name)

skill_md = skill_template.render(
    name="reverse-thinking",
    description="""
When the user is stuck choosing between options and keeps circling back,
they often say "I can't decide". Trigger: "need a different perspective".
""".strip(),
    source_book="《穷查理宝典》 查理·芒格",
    source_chapter="第三讲",
    R="倒过来想，总是倒过来想。",
    I="""在决策僵局中，主动寻找反方证据或反向场景，
往往能打破确认偏误，暴露被忽视的约束条件。""",
    A1="""芒格在收购喜诗糖果时，不是论证"为什么买"，
而是穷尽"为什么不买"的理由，最终发现定价假设的漏洞。""",
    A2="""用户表述："(我)选不出来" / "纠结" / "各有利弊"
触发词：different perspective / 换个角度 / 反面考虑""",
    E="""1. 明确当前选项集
2. 强制列出每个选项的三个致命缺陷
3. 评估缺陷是否可接受 vs. 机会成本
4. 决策：继续/修改选项集/放弃决策""",
    B="""不适用：已采集充分反面证据的情况；时间压力下的紧急决策；
需要创造性突破而非批判性分析的场景。""",
    tags=["decision", "mental-model"],
    related_skills=["opportunity-cost", "confirmation-bias"],
)

output_path = pathlib.Path("skills/reverse-thinking/SKILL.md")
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(skill_md, encoding="utf-8")

The template source at templates/SKILL.md.template enforces consistent front-matter YAML plus structured body sections.

Running the Complete Pipeline

# Execute all seven stages for a target book

make pipeline BOOK=lean-startup

# Individual stage execution

make stage0-adler BOOK=lean-startup
make stage1-extract BOOK=lean-startup
make stage2-verify BOOK=lean-startup
make stage3-ria BOOK=lean-startup
make stage4-zettel BOOK=lean-startup
make stage5-pressure BOOK=lean-startup
make stage6-deliver BOOK=lean-startup

Generated Test Prompt Example

{
  "skill": "reverse-thinking",
  "prompt": "I'm torn between two product ideas and can't decide which to pursue. One has bigger TAM, the other has faster iteration cycle.",
  "expected_trigger": "need a different perspective",
  "bait_alternatives": [
    {
      "prompt": "I've decided to build X, help me validate the demand",
      "should_trigger": false,
      "risk": "User already decided; skill should not activate"
    },
    {
      "prompt": "Emergency: server down, which backup region to activate?",
      "should_trigger": false,
      "risk": "Time-critical ops; reverse thinking introduces harmful delay"
    }
  ],
  "cross_skill_confusion": {
    "opportunity-cost": "Distinguish: reverse-thinking explores options internally; opportunity-cost compares options externally"
  }
}

Key Repository Files

File	Purpose	Location
README.en.md	Pipeline overview and design rationale	View
methodology/00-overview.md	Condensed seven-stage reference	View
methodology/04-stage2-ria-plus.md	RIA++ format specification	View
templates/SKILL.md.template	Jinja2 skill generator	View
extractors/*.md	Parallel extractor prompts	View folder

Summary

• RIA-TV++ is a seven-stage pipeline (Adler → Extract → Verify → Construct → Link → Test → Deliver) that transforms books into executable AI skills
• The RIA++ format (Reading, Interpretation, A1/A2 past/future Application, Execution, Boundary) provides the structural backbone for every SKILL.md
• Triple verification and pressure testing ensure skills activate correctly and refuse activation when inappropriate
• A2 (Future Trigger) fields directly control Claude Code runtime behavior through skill description matching
• All specifications, templates, and extractor prompts are open-source in kangarooking/cangjie-skill

Frequently Asked Questions

What makes RIA-TV++ different from standard book summarization?

Standard summarization produces passive reading material. RIA-TV++ produces agent-executable skills with explicit triggers, action steps, and boundaries. The A2/E/B fields specifically enable runtime decision-making rather than reference lookup.

How does the pipeline prevent skill misactivation?

Two defense layers: (1) Triple verification ensures extracted content is non-obvious and well-sourced during construction; (2) Pressure testing generates adversarial prompts including bait questions and cross-skill confusion scenarios, with failures triggering reconstruction of trigger conditions or boundaries.

Can RIA-TV++ process content other than books?

Yes. The pipeline is content-agnostic — any long-form structured material (research papers, documentation, course curricula) can flow through the same stages. The Adler Analysis stage adapts to source type, and extractors can be customized in extractors/*.md.

What Claude Code versions support these skill packs?

The SKILL.md format follows Claude Code's native skill specification. The pipeline targets Claude Code 2.0+ and Cursor 0.40+ with skills/ directory installation. The bilingual A2 triggers improve activation reliability across model versions.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}