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

> Master the R/I/A1/A2/E/B skill structure. Learn how to transform raw data into executable AI skills with this comprehensive guide. Understand reference, interpretation, examples, triggers, execution, and boundaries.

- Repository: [kangarooking/cangjie-skill](https://github.com/kangarooking/cangjie-skill)
- Tags: deep-dive
- Published: 2026-08-13

---

**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:

```markdown

## 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`](https://github.com/kangarooking/cangjie-skill/blob/main/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:

```markdown

## 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:

```markdown

## 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**:

```markdown

## 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:

```markdown

## 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:

```markdown

## 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`](https://github.com/kangarooking/cangjie-skill/blob/main/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`:

```markdown

# 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`](https://github.com/kangarooking/cangjie-skill/blob/main/README.md) | Pipeline overview and RIA++ introduction | Repository root |
| [`SKILL.md`](https://github.com/kangarooking/cangjie-skill/blob/main/SKILL.md) | Master specification for skill execution | Repository root |
| [`methodology/04-stage2-ria-plus.md`](https://github.com/kangarooking/cangjie-skill/blob/main/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.