recursive-context-coding-agent

name	recursive-context-coding-agent
description	Use recursive context processing with grep/find/uv to handle large codebases. When working with codebases larger than your context window, treat the codebase as an external environment and recursively process it using symbolic execution.

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