Recursive Language Model (RLM) Skill

Core Philosophy

“Context is an external resource, not a local variable.”

When this skill is active, you are the Root Node of a Recursive Language Model system. Your job is NOT to read code, but to write programs (plans) that orchestrate sub-agents to read code.

Protocol: The RLM Loop

Phase 1: Choose Your Engine

Decide based on the nature of the data:

Phase 2: Index & Filter (The “Peeking” Phase)

Goal: Identify relevant data without loading it.

1. Native: Use find or grep -l.
2. Strict: Use python3 .../rlm.py peek "query".
   • RLM Pattern: Grepping for import statements, class names, or definitions to build a list of relevant paths.

Phase 3: Parallel Map (The “Sub-Query” Phase)

Goal: Process chunks in parallel using fresh contexts.

1. Divide: Split the work into atomic units.
   • Strict Mode: python3 .../rlm.py chunk --pattern "*.log" -> Returns JSON chunks.
2. Spawn: Use background_task to launch parallel agents.
   • Constraint: Launch at least 3-5 agents in parallel for broad tasks.
   • Prompting: Give each background agent ONE specific chunk or file path.
   • Format: background_task(agent="explore", prompt="Analyze chunk #5 of big.log: {content}...")

Phase 4: Reduce & Synthesize (The “Aggregation” Phase)

Goal: Combine results into a coherent answer.

1. Collect: Read the outputs from background_task (via background_output).
2. Synthesize: Look for patterns, consensus, or specific answers in the aggregated data.
3. Refine: If the answer is incomplete, perform a second RLM recursion on the specific missing pieces.

Critical Instructions

1. NEVER use cat * or read more than 3-5 files into your main context at once.
2. ALWAYS prefer background_task for reading/analyzing file contents when the file count > 1.
3. Use rlm.py for programmatic slicing of large files that grep can’t handle well.
4. Python is your Memory: If you need to track state across 50 files, write a Python script (or use rlm.py) to scan them and output a summary.

Example Workflow: “Find all API endpoints and check for Auth”

Wrong Way (Monolithic):

• read src/api/routes.ts
• read src/api/users.ts
• … (Context fills up, reasoning degrades)

RLM Way (Recursive):

1. Filter: grep -l "@Controller" src/**/*.ts -> Returns 20 files.
2. Map:
   • background_task(prompt="Read src/api/routes.ts. Extract all endpoints and their @Auth decorators.")
   • background_task(prompt="Read src/api/users.ts. Extract all endpoints and their @Auth decorators.")
   • … (Launch all 20)
3. Reduce:
   • Collect all 20 outputs.
   • Compile into a single table.
   • Identify missing auth.

Recovery Mode

If background_task is unavailable or fails:

1. Fall back to Iterative Python Scripting.
2. Write a Python script that loads each file, runs a regex/AST check, and prints the result to stdout.
3. Read the script’s stdout.

What Claude Does vs What You Decide

Skill Boundaries

This skill excels for:

• Codebases with >100 files
• Finding patterns across many files
• Audit tasks (security, auth, logging)
• Large file analysis (logs, data dumps)

This skill is NOT ideal for:

• Small projects (<50 files) → Direct reading faster
• Single file analysis → Overkill
• Tasks requiring file modification → Use different approach

Skill Metadata

name: rlm
category: meta
version: 2.0
author: GUIA
source_expert: Recursive Language Model pattern
difficulty: advanced
mode: cyborg
tags: [rlm, large-codebase, parallel-agents, map-reduce, context-management]
created: 2026-02-03
updated: 2026-02-03