Understanding the R/I/A1/A2/E/B Skill Structure and Why It’s Essential

The R/I/A1/A2/E/B skill structure is a six-part schema used in the cangjie-skill repository to transform raw source material into agent-callable AI skills, ensuring each skill is grounded in original text (R), clearly interpreted (I), illustrated with concrete examples (A1), triggered by future scenarios (A2), executable via steps (E), and constrained by safety boundaries (B).

The cangjie-skill project implements a rigorous methodology for converting books, transcripts, and documents into reusable AI capabilities. At the core of this system lies the R/I/A1/A2/E/B skill structure, a standardized format defined in the repository's README.md (lines 38-52) and elaborated in methodology/04-stage2-ria-plus.md. This framework ensures that every skill extracted from source material maintains traceability to its origins while remaining actionable for autonomous agents.

Deconstructing the Six Components

Each skill in the cangjie-skill ecosystem is composed of six mandatory sections that form the RIA++ (Reading, Interpretation, Appropriation plus Execution and Boundaries) pipeline.

R (Reference) – Original Text Anchor

The Reference section contains direct quotations from the source material. This provides an immutable anchor that ties the skill back to its origin, ensuring traceability and protecting against hallucination. As specified in templates/SKILL.md.template, this section uses the placeholder {{reference_text}} to capture verbatim excerpts.

I (Interpretation) – Conceptual Rewrite

The Interpretation section provides the author's re-phrasing of the concept in plain, model-friendly language. This translates complex or domain-specific terminology into concise statements that an LLM can readily process and apply. The template defines this via the {{interpretation}} placeholder.

A1 (Original Case Example) – Concrete Evidence

A1 captures a specific instance, story, or scenario taken directly from the source material. This concrete example demonstrates the concept in action, helping the model recognize patterns and validate the skill's applicability against real-world situations. In the template, this corresponds to the {{case}} field (labeled as "案例").

A2 (Future Activation Scenario) – Trigger Context

While A1 looks backward at historical examples, A2 looks forward. This section describes the specific decision points, problem contexts, or environmental cues that should trigger the skill's activation. It transforms static knowledge into a procedural cue, defined in the template as {{trigger_scenario}}.

E (Executable Steps) – Actionable Instructions

The Execution section provides step-by-step instructions that a user or autonomous agent can follow. This component is what distinguishes a cangjie-skill from a simple summary—it provides the exact procedural logic needed to implement the concept, making the skill callable by tools like Claude Code or Cursor.

B (Boundaries / Blind Spots) – Safety Constraints

The Boundary section explicitly lists edge cases, limitations, and contexts where the skill does not apply. This safety mechanism prevents over-generalization and protects against harmful or irrelevant suggestions by clarifying the operational limits of the skill.

Why This Structure Is Necessary for AI Skills

The necessity of the six-part format stems from five critical requirements for robust AI skill engineering:

• Traceability: The R component anchors every skill to a verifiable source, satisfying the "original-text-reference" requirement of the RIA-TV++ pipeline. This ensures that knowledge can be audited and validated against its origins.

• Clarity: The I component distills complex source material into unambiguous phrasing, reducing the risk of model misinterpretation during retrieval-augmented generation.

• Contextual Grounding: Together, A1 and A2 provide bidirectional context—historical proof and future triggers—enabling the model to recognize the precise moment when a skill should be activated.

• Actionability: The E component supplies executable logic, transforming passive knowledge into an active tool that agents can invoke through function calling or workflow automation.

• Safety: The B component acts as a guardrail, explicitly defining negative space (what the skill is not for) to prevent misuse in contexts where the underlying concept would yield incorrect or dangerous results.

Implementation in the Cangjie-Skill Repository

The structure is formally defined in methodology/04-stage2-ria-plus.md, which provides the architectural rationale for each component. Authors implement this structure using templates/SKILL.md.template, which provides the following boilerplate:

# {{skill_name}}

## R (Reference)

> {{reference_text}}

## I (Interpretation)

{{interpretation}}

## A1 (案例)

{{case}}

## A2 (Trigger Scenario)

{{trigger_scenario}}

## E (Execution)

{{execution_steps}}

## B (Boundary)

{{boundary_conditions}}

A completed skill following this schema would look like this:

# Pareto Analysis 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)

Resource allocation should prioritize the vital few inputs that generate disproportionate outputs over the trivial many.

## A1 (案例)

A software team discovered that fixing 20% of reported bugs eliminated 80% of system crashes.

## A2 (Trigger Scenario)

When prioritizing a backlog with limited sprint capacity, or when resource constraints force selective investment decisions.

## E (Execution)

1. Inventory all items (tasks, customers, features).
2. Quantify each item's contribution (revenue, effort, risk).
3. Rank items by impact magnitude.
4. Allocate resources to the top 20% yielding 80% of value.

## B (Boundary)

- Invalid when distributions are uniform (e.g., safety-critical components requiring 100% coverage).
- Not applicable when fairness constraints override efficiency optimization.

Summary

• The R/I/A1/A2/E/B structure is the canonical format for all skills in the cangjie-skill repository, defined in README.md and methodology/04-stage2-ria-plus.md.
• R provides source traceability, I ensures model comprehension, A1/A2 handle context recognition, E enables execution, and B establishes safety limits.
• This six-part schema transforms static text into agent-callable tools that are grounded, interpretable, and safe for autonomous deployment.
• Authors use templates/SKILL.md.template to ensure consistent implementation across all skills extracted from source material.

Frequently Asked Questions

What does the R/I/A1/A2/E/B acronym stand for in cangjie-skill?

The acronym represents Reference (original text), Interpretation (rewrite), A1 (original case/example), A2 (activation trigger), Execution (steps), and Boundary (limits). This structure is formally documented in the repository's methodology/04-stage2-ria-plus.md file.

How does the A2 component differ from A1 in practical use?

A1 provides retrospective evidence—concrete examples from the source material that prove the concept works. A2 provides prospective triggers—future-oriented scenarios that tell an agent when to activate the skill. A1 validates the skill's historical efficacy; A2 determines its deployment context.

Why is the Boundary (B) section critical for AI safety?

The B section prevents domain confusion and over-generalization by explicitly listing where the skill fails or should not be applied. According to the cangjie-skill methodology, this acts as a negative constraint that protects against harmful recommendations when the underlying concept is misapplied to incompatible contexts.

Where can I find the official template for writing R/I/A1/A2/E/B skills?

The official template resides at templates/SKILL.md.template in the repository root. This file contains the markdown boilerplate with Jinja2 placeholders ({{reference_text}}, {{interpretation}}, etc.) that authors populate to create new skills compliant with the RIA++ specification.

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