How the RIA-TV++ Pipeline Works in kangarooking/cangjie-skill: A 7-Stage Guide

The RIA-TV++ pipeline is a seven-stage linear workflow that transforms raw source material into Claude-compatible, agent-ready skill definitions through parallel extraction, triple verification, and iterative pressure testing.

The RIA-TV++ methodology is the core engine of the cangjie-skill repository, designed to distill books, transcripts, and other textual sources into atomic, executable skills that integrate with Claude's skill ecosystem. This pipeline bridges the gap between passive reading and actionable agent capabilities, producing outputs that are both human-readable and machine-executable.

What RIA-TV++ Stands For

The naming convention reveals the pipeline's architectural philosophy. According to [methodology/00-overview.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/00-overview.md#L7-L11):

• RIA = Framework skeleton (R‑I‑A1‑A2: Rule, Illustration, Application 1, Application 2)
• TV = Triple Verification (the three-layer filtering stage)
• ++ = E (executable steps) + B (boundary constraints) extensions for autonomous agents

This naming reflects the pipeline's evolution from a basic skill extraction tool to a production-ready system for agent-ready skill generation.

Stage 0: Deep Source Analysis (Adler Reading)

The pipeline begins with 整书理解 (whole-book comprehension) using Adler's four-step analytical reading method. This stage produces the foundational BOOK_OVERVIEW.md file that serves as global context for all subsequent extraction.

The goal is structural understanding before granular extraction. The BOOK_OVERVIEW.md contains:

• High-level outline of the source material
• Key concepts and thematic clusters
• A "quality gate" checklist ensuring completeness

Implementation details are documented in [methodology/01-stage0-adler.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/01-stage0-adler.md#L1-L45).

Stage 1: Parallel Candidate Extraction

Five specialized sub-agents operate simultaneously on different chunks of the source material. Each extractor targets distinct skill patterns:

• Principle extractors identify core rules and frameworks
• Technique extractors capture procedural knowledge
• Pattern extractors find reusable templates
• Heuristic extractors surface decision shortcuts
• Anti-pattern extractors document common mistakes

Outputs land in the candidates/ folder as individual markdown files. The parallel architecture ensures comprehensive coverage without sequential bottlenecks. See [extractors/principle-extractor.md](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/principle-extractor.md) for an example implementation.

Stage 1.5: Triple Verification (TV Component)

The TV in RIA-TV++ manifests as a three-layer validation gate that filters raw candidates before skill construction:

Layer	Verification Target	Output
V1 跨域	Cross-domain applicability	Reject domain-specific noise
V2 预测力	Predictive power	Keep high-leverage principles
V3 独特性	Distinctiveness	Eliminate redundant concepts

Accepted units move to verified.md; rejected candidates populate the rejected/ folder with documented rationale. This stage incorporates user feedback on the shortlisted candidates. Full specification in [methodology/03-stage1.5-triple-verify.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/03-stage1.5-triple-verify.md#L1-L71).

Stage 2: RIA++ Skill Construction

Each verified unit is transformed into a formal skill following the canonical SKILL.md schema. The ++ additions expand the classic RIA framework:

• R (Rule): The core principle or pattern
• I (Illustration): Concrete example demonstrating the rule
• A1 (Application 1): Simple, guided exercise
• A2 (Application 2): Complex, independent application
• E (Executable): Step-by-step actions an agent can perform
• B (Boundary): Constraints, preconditions, and failure modes

Resulting files populate the skills/ directory, one SKILL.md per atomic unit. The schema ensures darwin-skill compatibility for downstream evolution. See [methodology/04-stage2-ria-plus.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/04-stage2-ria-plus.md#L1-L80).

Stage 3: Zettelkasten Linking

Skills are woven into a navigable knowledge network using Zettelkasten principles:

• Each SKILL.md receives a related_skills field referencing connected units
• A top-level INDEX.md provides hierarchical navigation
• Bidirectional links enable discovery and traversal

This linking stage transforms isolated skills into a coherent skill graph. Implementation in [methodology/05-stage3-zettelkasten.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/05-stage3-zettelkasten.md#L1-L31).

Stage 4: Pressure Testing

Skills face automated validation through test-prompts.json files that mirror darwin-skill expectations. The testing protocol includes:

1. Blind execution: Skills tested without original context
2. Edge case probing: Boundary condition validation
3. Integration checks: Multi-skill scenario performance

Failure triggers rework: Any skill that fails pressure testing returns to Stage 2 for reconstruction. This iterative loop enforces the pipeline's "可验证" (verifiable) and "可进化" (darwin-compatible) invariants documented in lines 78-84 of the overview file.

Full testing specification in [methodology/06-stage4-pressure-test.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/06-stage4-pressure-test.md#L1-L81).

Stage 5: Delivery

The final stage produces two deliverables:

• DIGEST.md: A human-curated, long-form summary of the entire skill collection
• Installed skills: Passing skills copied to the user's ~/.skills/ directory

This dual output serves both human reviewers and downstream agent systems. The DIGEST.md functions as executive documentation, while the installed skills enable immediate operational use. Details in [methodology/07-stage5-deliver.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/07-stage5-deliver.md#L1-L52).

Complete Pipeline Execution

While the pipeline is orchestrated through markdown methodology files, the following illustrates the operational flow:

# Stage 0: Generate global context

python -m scripts.generate_book_overview.py

# Stage 1: Parallel extraction

python -m extractors.run_parallel_extractors.py

# Stage 1.5: Triple verification

python -m extractors.triple_verify.py

# Stage 2: Skill construction

python -m extractors.build_skills.py

# Stage 3: Zettelkasten linking

python -m extractors.link_skills.py

# Stage 4: Pressure testing (with rework loop)

python -m extractors.pressure_test.py

# Stage 5: Delivery

python -m extractors.deliver.py

The actual pipeline uses the markdown-defined workflows and the canonical [SKILL.md](https://github.com/kangarooking/cangjie-skill/blob/main/SKILL.md) template as the source of truth.

Key Architectural Invariants

The RIA-TV++ pipeline maintains strict quality gates (lines 78-84 of [00-overview.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/00-overview.md)):

• Atomicity: Each skill addresses exactly one conceptual unit
• Verifiability: All skills must pass automated pressure tests
• Evolvability: Skills must be compatible with darwin-skill automatic evolution
• Traceability: Every skill links back to source material coordinates

These invariants ensure that pipeline outputs remain maintainable and composable across long time horizons.

Summary

• The RIA-TV++ pipeline converts raw text into Claude-compatible skills through seven defined stages
• Stage 0 establishes global context via deep Adler-style reading
• Stages 1-1.5 use parallel extraction and triple verification to identify high-quality candidates
• Stage 2 transforms candidates into formal skills with E (executable) and B (boundary) extensions
• Stage 3 links skills into a Zettelkasten network with bidirectional navigation
• Stage 4 enforces quality through pressure testing with automatic rework loops
• Stage 5 delivers both human-readable (DIGEST.md) and machine-installable outputs

Frequently Asked Questions

What makes RIA-TV++ different from standard prompt engineering?

Standard prompt engineering produces ephemeral instructions. RIA-TV++ produces persistent, testable, interlinked skills with explicit boundary conditions and executable steps. The triple verification and pressure testing stages filter out weak candidates before they enter production, while the Zettelkasten linking enables emergent capability combinations that isolated prompts cannot achieve.

How does the rework loop in Stage 4 maintain pipeline velocity?

Failed skills return only to Stage 2 (RIA++ construction), not to the beginning. This preserves the verification investment from Stages 1-1.5. The loop is bounded by iteration limits and failure category logging to prevent infinite cycles—if a skill fails repeatedly, it is flagged for human review rather than automatic retry.

Can the RIA-TV++ pipeline process non-book sources like podcasts or videos?

Yes. The pipeline is source-agnostic—Stage 0's Adler analysis adapts to any material with coherent structure. Podcasts and transcripts require pre-processing to segment speakers and timestamp claims, but the subsequent stages (parallel extraction through delivery) operate identically. The key requirement is that source material supports chunked parallel processing in Stage 1.

What is the relationship between cangjie-skill and darwin-skill?

cangjie-skill produces skills; darwin-skill consumes and evolves them. The RIA-TV++ pipeline explicitly targets darwin-skill compatibility through its test-prompts.json format and evolvability invariants. After Stage 5 delivery, skills can be ingested by darwin-skill systems for automatic mutation, selection, and improvement without human intervention.

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