Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add mhattingpete/claude-skills-marketplace --skill code-execution -a claude-code
Open on GitHub

What 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 oldName to newName in every file matching **/*.py, then return a change summary.
  • Find functions matching handle_.* in app.py, move the selected ones to utils.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-code

2Manually: put the files in place

~/.claude/skills/code-execution/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/code-execution/

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

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set15

The whole set →
dashboard-creator dashboard-creator builds a single-page HTML dashboard with KPI cards, charts, progress bars and data tables. Handy when you need to show metrics without a frontend framework. CX Codex +1 337installs timeline-creator timeline-creator turns a project's tasks and dates into an interactive HTML timeline with Gantt bars, phases and milestones. Handy when a plan has to live in one file. CX Codex +1 337installs code-refactor code-refactor is a Claude Code skill for bulk code changes across files: renaming variables and functions, replacing deprecated patterns, and updating API calls. It automatically selects a mode that saves up to 90% of tokens for 10+ files. CX Codex +1 304installs feature-planning The feature-planning skill turns feature requests and complex changes into ordered implementation plans with concrete tasks. Use it before coding when the scope needs structure. CX Codex +1 297installs conversation-analyzer conversation-analyzer analyzes your local Claude Code session logs to detect recurring errors, repetitive prompts, and workflow bottlenecks. CX Codex +1 249installs technical-doc-creator technical-doc-creator builds HTML documentation for APIs and systems with code samples, architecture diagrams, syntax highlighting, and workflow steps. CX Codex +1 221installs ensemble-solving ensemble-solving spawns three parallel subagents to explore diverse solutions, scores each approach against weighted criteria, and returns the best outcome with trade-offs. CX Codex +1 218installs project-bootstrapper project-bootstrapper — a skill for Claude Code, Cursor, Codex and other platforms that scaffolds a new project or levels up an existing one: directories, linter configs, tests, Git hooks, CI/CD and documentation. CX Codex +1 212installs

Project sponsors

Companies that keep this analytics open