Recursive Context Coding Agent

When to Use This Skill

• Working with codebases larger than your context window
• Tasks requiring dense access to code throughout a large codebase
• Multi-file refactoring or analysis tasks
• When grep/find operations would be more effective than loading everything into context

Core Principles (from MIT RLM Paper)

1. Treat Codebase as External Environment

   • Don't load entire codebase into context window
   • Store codebase as a variable in a REPL environment
   • Use symbolic handles to reference code sections

2. Symbolic Recursion

   • Write code that can invoke itself programmatically
   • Use loops to process slices of the codebase
   • Launch sub-calls for different code sections

3. REPL Environment

   • Use grep, find, and other tools to examine code
   • Execute Python scripts with uv run to process code
   • Store intermediate results symbolically

Workflow

Step 1: Initialize REPL Environment

# Set up the codebase as a variable
CODEBASE=$(pwd)
Step 2: Recursive Analysis
# Use grep to find relevant code
grep -r "pattern" $CODEBASE --include="*.py" --include="*.js" --include="*.ts"

# Use find to explore directory structure
find $CODEBASE -type f -name "*.py" | head -20

Step 3: Symbolic Processing with Python

Use uv to run Python scripts for complex processing

uv run python << 'EOF'
import os
import subprocess

# Process codebase recursively
for root, dirs, files in os.walk('/path/to/codebase'):
    for file in files:
        if file.endswith('.py'):
            filepath = os.path.join(root, file)
            # Process each file
            print(f"Processing: {filepath}")
EOF

Step 4: Recursive Sub-Calls

When you need to focus on a specific section:

Extract the relevant code section
Create a new prompt with just that section
Invoke yourself recursively with the focused context
Aggregate results
Example: Large Codebase Refactoring
Problem: Refactor a 10,000-line codebase

RLM Approach:

Store codebase as CODEBASE variable
Use find to identify all files
Use grep to find patterns to refactor
For each file, create a focused prompt
Process files recursively
Aggregate changes
Commands:

# 1. Find all Python files
FILES=$(find $CODEBASE -name "*.py")

# 2. Process each file recursively
for file in $FILES; do
    # Extract file content
    CONTENT=$(cat $file)
    
    # Create focused prompt
    PROMPT="Refactor this code: $CONTENT"
    
    # Invoke recursively (you would call yourself here)
    # RESULT=$(recursive-call $PROMPT)
    
    # Apply changes
    # echo "$RESULT" > $file
done

Tools to Use

• grep: Search for patterns across the codebase
• find: Navigate and locate files
• uv run: Execute Python scripts for complex processing
• sed/awk: Text processing within files
• git: Track changes and revert if needed

Best Practices

Never load entire codebase into context window
Use symbolic handles for code sections
Process recursively - break down problems into sub-problems
Store intermediate results in variables
Use REPL environment for code execution
Test incrementally - verify changes after each recursive call

Error Handling

If a recursive call fails, try a different code slice
Use git to revert changes if something goes wrong
Log intermediate results for debugging
Limit recursion depth to prevent infinite loops