code-execution — Claude Code skill: what it does, how to install
The code-execution skill runs Python locally for bulk file work, code analysis, transformations, and Git tasks. It fits large or multi-step workflows.
Apache-2.0 294 installs ★ 697 updated 2026-07-25
npx skills add mhattingpete/claude-skills-marketplace --skill code-execution -a claude-codeWhat code-execution does
The skill runs Python on the local machine and exposes APIs for filesystem work, code inspection, transformations, and Git. It is intended for bulk jobs across 10+ files, iterative processing, and multi-step workflows. Code analysis returns metadata, while the final result is a summary rather than file contents.
Its APIs include fs for copying lines and search-replace, code for finding functions, classes, and dependencies, transform for identifier changes and refactors, and git for status, staging, commits, and pushes. An agent can inspect app.py, move selected functions to utils.py, or rename an identifier across Python files.
When the runtime is not installed, run ~/.claude/plugins/marketplaces/mhattingpete-claude-skills/execution-runtime/setup.sh first. The skill returns metadata and summaries, so full source is kept out of the agent context.
What it helps with
- process 10+ files in one operation
- rename an identifier across Python files
- find functions by pattern and move them
- inspect dependencies and code complexity
- stage changes and create a Git commit
Example prompts for the agent
- Rename
oldNametonewNamein every file matching**/*.py, then return a change summary. - Find functions matching
handle_.*inapp.py, move the selected ones toutils.py, and report the result. - Inspect dependencies in all Python files and list files with complexity above 15.
How to install code-execution
1Skills CLI (Vercel)
npx skills add mhattingpete/claude-skills-marketplace --skill code-execution -a claude-code2Manually: put the files in place
~/.claude/skills/code-execution/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/code-execution/
1Skills CLI (Vercel)
npx skills add mhattingpete/claude-skills-marketplace --skill code-execution -a codex2Manually: put the files in place
.agents/skills/code-execution/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add mhattingpete/claude-skills-marketplace --skill code-execution -a cursor2Manually: put the files in place
.cursor/skills/code-execution/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install mhattingpete/claude-skills-marketplace code-operations-plugin/skills/code-execution2Manually: put the files in place
.github/skills/code-execution/SKILL.md1Skills CLI (Vercel)
npx skills add mhattingpete/claude-skills-marketplace --skill code-execution -a gemini-cli2Platform CLI
gemini skills install https://github.com/mhattingpete/claude-skills-marketplace --path code-operations-plugin/skills/code-executionManually: put the files in place
.devin/skills/code-execution/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add mhattingpete/claude-skills-marketplace --skill code-execution -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about code-execution
How do I install code-execution in Claude Code?
Run npx skills add mhattingpete/claude-skills-marketplace --skill code-execution -a claude-code. Then check ~/.claude/skills/code-execution/SKILL.md.
What does code-execution do?
It runs Python locally and exposes APIs for file operations, code metadata, bulk transformations, and Git. Results come back as summaries instead of full file contents.
What is required for code-execution to work?
The local execution runtime must be installed. If it is missing, run ~/.claude/plugins/marketplaces/mhattingpete-claude-skills/execution-runtime/setup.sh.
Source text
SKILL.md · Apache-2.0
---
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:
```python
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
1. **Analyze locally** (metadata only, not source)
2. **Process locally** (all operations in execution)
3. **Return summary** (not data!)
## Examples
**Bulk refactor (50 files):**
```python
from execution_runtime import transform
result = transform.rename_identifier('.', 'oldName', 'newName', '**/*.py')
# Returns: {'files_modified': 50, 'total_replacements': 247}
```
**Extract functions:**
```python
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):**
```python
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% |
© mhattingpete · Apache-2.0 · mhattingpete/claude-skills-marketplace