What is code-execution?

The Code Execution skill enables Claude to run Python code locally with direct access to filesystem, git, and code analysis APIs. It is specifically engineered to optimize performance and reduce token consumption by 90-99% during bulk operations, making it an essential tool for managing large-scale software projects and complex multi-step workflows without exhausting context windows.

When should I use code-execution?

code-execution is useful in the following scenarios: • Bulk Code Refactoring: Perform identifier renaming or structural code transformations across dozens or hundreds of files simultaneously with minimal token overhead. • Automated Codebase Auditing: Analyze project-wide dependencies and code complexity by processing metadata locally instead of uploading entire source files to the LLM. • Streamlined Git Management: Automate routine version control tasks such as status checks, staging, and committing changes directly through programmatic Python scripts. • Efficient File System Operations: Execute complex batch file movements, copies, or search-and-replace tasks that would otherwise be too slow or expensive via standard chat interfaces.

name	code-execution
description	Execute Python code locally with marketplace API access for 90%+ token savings on bulk operations. Activates when user requests bulk operations (10+ files), complex multi-step workflows, iterative processing, or mentions efficiency/performance.

Code Execution

Execute Python locally with API access. 90-99% token savings for bulk operations.

When to Use

Bulk operations (10+ files)
Complex multi-step workflows
Iterative processing across many files
User mentions efficiency/performance

How to Use

Use direct Python imports in Claude Code:

from execution_runtime import fs, code, transform, git

# Code analysis (metadata only!)
functions = code.find_functions('app.py', pattern='handle_.*')

# File operations
code_block = fs.copy_lines('source.py', 10, 20)
fs.paste_code('target.py', 50, code_block)

# Bulk transformations
result = transform.rename_identifier('.', 'oldName', 'newName', '**/*.py')

# Git operations
git.git_add(['.'])
git.git_commit('feat: refactor code')

If not installed: Run ~/.claude/plugins/marketplaces/mhattingpete-claude-skills/execution-runtime/setup.sh

Available APIs

Filesystem (fs): copy_lines, paste_code, search_replace, batch_copy
Code Analysis (code): find_functions, find_classes, analyze_dependencies - returns METADATA only!
Transformations (transform): rename_identifier, remove_debug_statements, batch_refactor
Git (git): git_status, git_add, git_commit, git_push

Pattern

Analyze locally (metadata only, not source)
Process locally (all operations in execution)
Return summary (not data!)

Examples

Bulk refactor (50 files):

from execution_runtime import transform
result = transform.rename_identifier('.', 'oldName', 'newName', '**/*.py')
# Returns: {'files_modified': 50, 'total_replacements': 247}

Extract functions:

from execution_runtime import code, fs

functions = code.find_functions('app.py', pattern='.*_util$')  # Metadata only!
for func in functions:
    code_block = fs.copy_lines('app.py', func['start_line'], func['end_line'])
    fs.paste_code('utils.py', -1, code_block)

result = {'functions_moved': len(functions)}

Code audit (100 files):

from execution_runtime import code
from pathlib import Path

files = list(Path('.').glob('**/*.py'))
issues = []

for file in files:
    deps = code.analyze_dependencies(str(file))  # Metadata only!
    if deps.get('complexity', 0) > 15:
        issues.append({'file': str(file), 'complexity': deps['complexity']})

result = {'files_audited': len(files), 'high_complexity': len(issues)}

Best Practices

✅ Return summaries, not data ✅ Use code_analysis (returns metadata, not source) ✅ Batch operations ✅ Handle errors, return error count

❌ Don't return all code to context ❌ Don't read full source when you need metadata ❌ Don't process files one by one

Token Savings

Files	Traditional	Execution	Savings
10	5K tokens	500	90%
50	25K tokens	600	97.6%
100	150K tokens	1K	99.3%

code-execution

When & Why to Use This Skill

Use Cases