Understanding the R/I/A1/A2/E/B Skill Structure: A Complete Guide to RIA++

The R/I/A1/A2/E/B structure is a six-component schema that transforms raw source material into executable, traceable AI skills by separating reference, interpretation, examples, triggers, execution steps, and boundaries.

The kangarooking/cangjie-skill repository implements this framework as part of its RIA++ pipeline, converting unstructured knowledge (books, podcasts, transcripts) into agent-callable tools. Understanding this structure is essential for anyone building reproducible AI-assisted workflows or knowledge bases.

---

Overview of the Six Components

Each skill in the cangjie-skill ecosystem follows a rigorous six-part layout defined in templates/SKILL.md.template. Here is the breakdown:

Component	Full Name	Purpose
R	Reference	Original text quotation from the source
I	Interpretation	Author's rephrasing in plain language
A1	Case (案例)	Concrete example from the source material
A2	Trigger Scenario	Future-oriented activation context
E	Execution	Step-by-step actionable instructions
B	Boundary	Explicit limits and blind spots

This schema ensures that every skill is grounded (R), understandable (I), demonstrated (A1), context-aware (A2), actionable (E), and safe (B).

---

Deep Dive: What Each Component Does

R – Reference (Original Text)

The Reference section contains direct quotations from the source material. According to templates/SKILL.md.template, this is formatted as:

## R (Reference)

> {{reference_text}}

This component serves as the immutable anchor that ties the skill back to its origin. In methodology/04-stage2-ria-plus.md, the authors emphasize that R prevents hallucination by forcing explicit source attribution. Without R, a skill becomes untraceable opinion rather than grounded knowledge.

I – Interpretation (Rewritten Concept)

The Interpretation section translates the original text into concise, model-friendly language:

## I (Interpretation)

{{interpretation}}

Unlike R, which preserves the source verbatim, I distills the core concept into a form that LLMs can readily parse and apply. This step is critical for clarity—raw quotations often contain noise, embedded examples, or rhetorical flourishes that obscure the underlying principle.

A1 – Case (Original Example)

The Case component (labeled 案例 in the template) provides a concrete instantiation from the source:

## A1 (案例)

{{case}}

A1 demonstrates the concept in its original context, helping both humans and models recognize valid applications. For example, a skill about the Pareto Principle might cite a specific business scenario from Richard Koch's book rather than a generic restatement.

A2 – Trigger Scenario (Future Activation)

Where A1 looks backward, A2 looks forward:

## A2 (Trigger Scenario)

{{trigger_scenario}}

This component answers: When should an agent invoke this skill? It converts static knowledge into a procedural cue, enabling AI systems to recognize appropriate activation moments. Without A2, skills sit idle; with it, they become contextually responsive.

E – Execution (Actionable Steps)

The Execution section transforms understanding into action:

## E (Execution)

{{< Execution content here >}}

E provides step-by-step instructions that a user or autonomous agent can follow. This is where the skill becomes callable—E effectively defines the function body that an AI assistant would execute. The cangjie-skill pipeline treats E as the operational core that bridges knowledge and implementation.

B – Boundary (Limits and Blind Spots)

The Boundary component explicitly defines what the skill does not cover:

## B (Boundary)

{{< Boundary content here >}}

B is essential for safety and reliability. By cataloging edge cases, inapplicable scenarios, and potential misuses, B prevents over-generalization. As noted in the RIA++ methodology, this component addresses the "unknown unknowns" that plague naive knowledge extraction systems.

---

Why This Structure Is Necessary

The six-component design in kangarooking/cangjie-skill solves five critical problems in AI skill engineering:

1. Traceability – R ensures every claim can be verified against source material.

2. Clarity – I eliminates ambiguity by forcing explicit rephrasing.

3. Contextual grounding – A1 and A2 together cover past demonstrations and future triggers, enabling robust activation.

4. Actionability – E converts passive knowledge into executable procedures.

5. Safety – B creates guardrails that prevent misuse and constrain scope.

As implemented in the RIA++ pipeline (methodology/04-stage2-ria-plus.md), these components work sequentially: R and I establish what the concept is, A1 and A2 establish when it applies, E defines how to use it, and B clarifies where not to apply it.

---

Practical Example: Populating a Skill

Here is a complete skill following the R/I/A1/A2/E/B structure, based on the template in templates/SKILL.md.template:

# Pareto Principle Skill

## R (Reference)

> "The 80/20 rule states that roughly 80% of effects come from 20% of causes."
> — *The 80/20 Principle*, Richard Koch

## I (Interpretation)

A minority of inputs typically generates a majority of outcomes; focus on high-leverage activities.

## A1 (案例)

A software team discovers that 20% of bugs cause 80% of crashes. Fixing these priority bugs yields disproportionate stability improvements.

## A2 (Trigger Scenario)

When allocating limited resources (time, money, attention), ask: "Which small subset drives most of the value?"

## E (Execution)

1. List all items under consideration (tasks, customers, features, bugs).
2. Quantify each item's contribution to the desired outcome.
3. Rank items by contribution percentage.
4. Select the top 20% for immediate focus.
5. Deprioritize or eliminate the remaining 80%.

## B (Boundary)

- Does not apply when contributions are uniformly distributed (no 80/20 split exists).
- Not suitable for decisions where equity or fairness outweighs efficiency.
- Requires measurable outcomes; subjective or unquantifiable domains limit applicability.

This structure makes the skill immediately usable by AI agents: they can cite R for authority, parse I for comprehension, match current context against A2, execute E, and respect B for safety.

---

Key Files for Implementation

File	Purpose	Location
README.md	Pipeline overview and RIA++ introduction	Repository root
SKILL.md	Master specification for skill execution	Repository root
methodology/04-stage2-ria-plus.md	Detailed methodology for each component	methodology/
templates/SKILL.md.template	Authoring boilerplate with R/I/A1/A2/E/B placeholders	templates/

---

Summary

• The R/I/A1/A2/E/B structure is the foundational schema of the cangjie-skill RIA++ pipeline.
• R grounds skills in verifiable source material.
• I transforms sources into model-compatible interpretations.
• A1 provides concrete examples from original contexts.
• A2 defines future activation triggers for contextual invocation.
• E delivers executable step-by-step instructions.
• B establishes safety boundaries and limits.

This six-part design produces traceable, interpretable, actionable, and safe AI skills suitable for integration with Claude Code, Cursor, OpenClaw, and other agent frameworks.

---

Frequently Asked Questions

What happens if I skip the Boundary (B) component?

Skipping B creates silent failure modes. Without explicit limits, agents may apply skills in inappropriate contexts—wasting resources or producing harmful outputs. The cangjie-skill methodology treats B as mandatory precisely because undetected overreach is more dangerous than acknowledged ignorance.

Can I add extra sections beyond E and B?

The template enforces R/I/A1/A2/E/B as the minimum viable structure. Additional sections are permitted but should not split the semantic role of existing components. For example, extended commentary belongs under I, not as a new "Notes" section that fragments interpretation.

How does A2 differ from A1?

A1 looks backward at historical examples from the source material. A2 looks forward at future situations where the skill should activate. Together they create bidirectional grounding: A1 proves the concept worked, A2 predicts when it will work again.

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