New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Code Execution Fallback and Path Anchoring

by HKUDS in HKUDS/OpenSpace

Fallback ladder for failed sandboxed code runs, plus the habit of fixing the working directory first so generated files land in the right place.

MITAuto-check passedAgent Workflows

Install Code Execution Fallback and Path Anchoring

skills CLI
$ npx skills add HKUDS/OpenSpace --skill code-execution-fallback -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install HKUDS/OpenSpace code-execution-fallback --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/HKUDS/OpenSpace.git skills-src && mkdir -p .claude/skills && cp -r skills-src/benchmarks/gdpval/skills/code-execution-fallback .claude/skills/code-execution-fallback && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
code-execution-fallback
GitHub stars
7.7k
Token cost
~1.1k tokens
SKILL.md length
273 words
Files
2
Skills in repo
199
Repo updated
First seen
Licence
MIT

At a glance

Fallback ladder for failed sandboxed code runs, plus the habit of fixing the working directory first so generated files land in the right place.

  • Works in 3 steps: Workspace Path Anchoring → Execution Fallback Ladder → Explicit Path Management
  • A sandboxed code execution tool keeps failing with import or timeout errors
  • SKILL.md covers Core Techniques, Decision Tree, Common Failure Scenarios &… and Example: Robust File Generation, plus 2 more sections
  • Calls python and python3

What it does

The first technique is workspace anchoring: at the start of a task the agent records its working directory, using `os.getcwd()` in Python or `pwd` in a shell, and then writes files with absolute or explicitly relative paths. This stops output from ending up in odd places when the agent switches between tools.

When `execute_code_sandbox` fails, the skill escalates in three levels. Level 1 retries with simpler code, fewer dependencies and explicit error handling. Level 2 runs the same script through `run_shell` in a quoted heredoc with imports inline. Level 3 passes multi-step work that needs error recovery to `shell_agent`. A decision tree and a table pair failures with remedies, for example installing a missing package through the shell for `ModuleNotFoundError` and using `shell_agent` with progress tracking for timeouts.

When your agent uses it

  • A sandboxed code execution tool keeps failing with import or timeout errors
  • Generating CSV or Excel output that has to land in the right folder
  • Working in an agent runtime that offers both a code sandbox and a shell tool

Example prompts

  • “My sandbox run keeps timing out, so retry it through the shell with a heredoc.”
  • “Build the Excel report from the CSV and write it into the workspace folder, not a temp directory.”
  • “The script hit ModuleNotFoundError for pandas, so install it first and rerun.”

Requirements

  • An agent runtime with `execute_code_sandbox`, `run_shell` and `shell_agent` tools

Workflow steps

3 steps, taken from the step headings in SKILL.md.

  1. Workspace Path Anchoring
  2. Execution Fallback Ladder
  3. Explicit Path Management

What it can do on your machine

Read from SKILL.md and the folder at commit 3827781. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • python
    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Code Execution Fallback and Path Anchoring loads about 1.1k tokens when it runs. Until then it costs about 27 tokens; SKILL.md has 273 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~27
When it runs · the whole SKILL.md, loaded when a task matches
~1.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from HKUDS/OpenSpace at commit 3827781, republished under its MIT licence (© HKUDS). 273 words, ~1,099 tokens.

Download SKILL.mdSave it as .claude/skills/code-execution-fallback/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
code-execution-fallback
description
Handle code execution failures with fallback strategies and anchored workspace paths

Code Execution Fallback & Workspace Anchoring

This skill provides a robust pattern for executing code when the primary method fails, combined with proper workspace path management to prevent file location errors.

Core Techniques

1. Workspace Path Anchoring

Always establish and verify your working directory at the start of any task:

python
# At the beginning of any code execution
import os
workspace_path = os.getcwd()
print(f"Working directory: {workspace_path}")
bash
# In shell scripts
pwd
echo "Current directory: $(pwd)"

Why: Prevents files from being written to unexpected locations when agents switch between tools.

2. Execution Fallback Ladder

When execute_code_sandbox fails, follow this escalation pattern:

Level 1: Retry with Simpler Code
  • Simplify the code structure
  • Remove complex dependencies
  • Add explicit error handling
Level 2: Use run_shell with Heredoc

When sandbox execution repeatedly fails, switch to shell execution:

bash
python3 << 'EOF'
import os
import pandas as pd

# Your code here
data = {"col1": [1, 2, 3], "col2": ["a", "b", "c"]}
df = pd.DataFrame(data)
df.to_csv("output.csv", index=False)
print("File written successfully")
EOF

Key points:

  • Use << 'EOF' (quoted) to prevent variable expansion
  • Include all imports and dependencies inline
  • Add explicit success/failure messages
Level 3: Delegate to shell_agent

For complex multi-step tasks with error recovery needs:

Task: Create a data processing pipeline that reads CSV, transforms data, and outputs Excel
Requirements:
- Handle missing values
- Apply transformations
- Write to ./output/ directory
- Retry on transient errors
3. Explicit Path Management

Always use absolute or explicitly relative paths:

python
# BAD - relies on implicit working directory
df.to_csv("output/data.csv")

# GOOD - explicit path anchoring
import os
base_path = os.getcwd()
output_dir = os.path.join(base_path, "output")
os.makedirs(output_dir, exist_ok=True)
df.to_csv(os.path.join(output_dir, "data.csv"))
bash
# BAD
cd some_dir && python script.py

# GOOD
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$SCRIPT_DIR"
python script.py

Decision Tree

execute_code_sandbox fails?
├── Yes, with syntax/import errors → Fix code, retry Level 1
├── Yes, with timeout/resource errors → Use Level 2 (run_shell heredoc)
├── Yes, with unknown/unclear errors → Use Level 3 (shell_agent)
└── No, success → Verify output file exists at expected path

Common Failure Scenarios & Solutions

Error TypeLikely CauseRecommended Fallback
ModuleNotFoundErrorMissing packagesrun_shell with pip install first
TimeoutLong-running operationshell_agent with progress tracking
PermissionErrorWrong directoryVerify workspace path, use explicit paths
Unknown errorSandbox limitationsrun_shell or shell_agent

Example: Robust File Generation

python
# Step 1: Anchor workspace
import os
workspace = os.getcwd()
print(f"Workspace: {workspace}")

# Step 2: Create output directory explicitly
output_path = os.path.join(workspace, "deliverables")
os.makedirs(output_path, exist_ok=True)

# Step 3: Generate content with error handling
try:
    # Your generation logic here
    with open(os.path.join(output_path, "report.txt"), "w") as f:
        f.write("Content here")
    print(f"Success: File written to {output_path}")
except Exception as e:
    print(f"Error: {e}")
    # Signal to escalate to run_shell or shell_agent
    raise

Anti-Patterns to Avoid

  • ❌ Assuming current directory without verification
  • ❌ Using relative paths like ../output/file.txt without context
  • ❌ Repeatedly retrying failed execute_code_sandbox without changing approach
  • ❌ Not checking if output files exist after generation
  • ❌ Mixing implicit and explicit path styles in same task

Verification Checklist

After any code execution:

  • Confirm working directory was verified at start
  • Confirm output files exist at expected paths
  • Confirm file contents are non-empty and valid
  • If execution failed, escalate to next fallback level within 2 retries

© HKUDS, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file in benchmarks/gdpval/skills/code-execution-fallback of HKUDS/OpenSpace.

  • SKILL.md
  • .skill_id

Open the folder on GitHubat commit 3827781

Compare with similar skills

Code Execution Fallback and Path Anchoring next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Code Execution Fallback and Path Anchoring compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Code Execution Fallback and Path Anchoring this skillHKUDS/OpenSpace7.7k—~1.1kAutomated safety check: PassMIT
Ue Live DebuggingJasonMa0012/MooaToon749—~2.9kAutomated safety check: NotesCustom licence
Python Script Runnercongchuanling-dot/Cohort199—~577Automated safety check: NotesMIT
Smart File Writerforyourhealth111-pixel/Vibe-Skills3.6k—~2.6kAutomated safety check: PassApache-2.0
Batch Filesgithub/awesome-copilot40k1 repos~4.3kAutomated safety check: PassMIT
MCP DeveloperJeffallan/claude-skills12k—~1.5kAutomated safety check: PassMIT

Similar skills

  • Ue Live Debugging

    JasonMa0012/MooaToon

    A skill your agent uses when debugging UE C++ crashes, runtime bugs, or unexpected behavior with Rider MCP available.

    749 GitHub stars~2.9k tokensUpdated 19 days ago
    DevelopmentAuto-check: notes

  • Python Script Runner

    congchuanling-dot/Cohort

    Runs a Python script with checks first: confirms the interpreter version, compiles it for syntax errors, verifies imports, then explains any traceback in plain language.

    199 GitHub stars~577 tokensUpdated 1 mo ago
    DevelopmentAuto-check: notes

  • Smart File Writer

    foryourhealth111-pixel/Vibe-Skills

    Diagnoses why a file write failed (permissions, disk space, path length, locks, read-only mounts) before retrying, instead of repeating the same call blindly.

    3.6k GitHub stars~2.6k tokensUpdated 1 mo ago
    DevelopmentAuto-check passed

  • Batch Files

    github/awesome-copilot

    Official

    Expert-level Windows batch file (.bat/.cmd) skill for writing, debugging, and maintaining CMD scripts.

    40k GitHub starsUsed in 1 repo~4.3k tokens
    DevelopmentAuto-check passed

  • MCP Developer

    Jeffallan/claude-skills

    Builds and debugs MCP servers and clients in TypeScript or Python, from tool and resource definitions to transport setup and inspector-based protocol checks.

    12k GitHub stars~1.5k tokensUpdated 4 days ago
    Agent WorkflowsAuto-check passed

  • MCP Debugger

    debugmcp/mcp-debugger

    A skill your agent uses when investigating a bug, failing test, or unexpected runtime behavior and the mcp-debugger MCP server is available — drives real step-through debuggers (breakpoints, stack…

    171 GitHub stars~3.8k tokensUpdated yesterday
    DevelopmentAuto-check passed

More from HKUDS/OpenSpace

All 199 skills in this repo

  • Audio Track Production Workflow

    HKUDS/OpenSpace

    Walks through producing a master audio track plus stems in Python, from checking a reference file and timing sections by BPM to effects, a zip archive and final verification.

    7.7k GitHub stars~2.9k tokensUpdated 1 mo ago
    Auto-check passed

  • Cascade Failure Recovery

    HKUDS/OpenSpace

    Handle cascading data retrieval tool failures by falling back to embedded knowledge generation

    7.7k GitHub stars~765 tokensUpdated 1 mo ago
    Auto-check passed

  • Sandbox Code Execution Fallback

    HKUDS/OpenSpace

    Gives an agent a workaround when its code-execution sandbox keeps failing: save the Python script to a file and run it through the shell instead.

    7.7k GitHub stars~588 tokensUpdated 1 mo ago
    Auto-check passed

  • Code Execution Fallback

    HKUDS/OpenSpace

    A recovery routine for agents whose sandboxed code runner keeps failing: save the Python script to disk, then run it through the shell and read the output.

    7.7k GitHub stars~652 tokensUpdated 1 mo ago
    Auto-check passed

  • Code Execution Fallback E81068

    HKUDS/OpenSpace

    Fallback workflow for executing Python code when executecodesandbox fails repeatedly

    7.7k GitHub stars~1.1k tokensUpdated 1 mo ago
    Auto-check passed

  • Context Anchored Fallback Report

    HKUDS/OpenSpace

    Generate documents with writefile when retrieval tools fail, with explicit guardrails against task context drift

    7.7k GitHub stars~2.6k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Code Execution Fallback and Path Anchoring

What does Code Execution Fallback and Path Anchoring do?

Fallback ladder for failed sandboxed code runs, plus the habit of fixing the working directory first so generated files land in the right place. getcwd()` in Python or `pwd` in a shell, and then writes files with absolute or explicitly relative paths. This stops output from ending up in odd places when the agent switches between tools.

When should I use Code Execution Fallback and Path Anchoring?

Code Execution Fallback and Path Anchoring fits situations like: A sandboxed code execution tool keeps failing with import or timeout errors; generating CSV or Excel output that has to land in the right folder; working in an agent runtime that offers both a code sandbox and a shell tool.

How do I install Code Execution Fallback and Path Anchoring in Claude Code?

Run `npx skills add HKUDS/OpenSpace --skill code-execution-fallback -a claude-code`. Or copy the skill folder (benchmarks/gdpval/skills/code-execution-fallback in HKUDS/OpenSpace) into .claude/skills/code-execution-fallback in your project. Claude Code loads it when a task matches its description.

How do I install Code Execution Fallback and Path Anchoring in Codex?

Run `npx skills add HKUDS/OpenSpace --skill code-execution-fallback -a codex`. Or copy the skill folder (benchmarks/gdpval/skills/code-execution-fallback in HKUDS/OpenSpace) into .agents/skills/code-execution-fallback in your project. Codex loads it when a task matches its description.

Can I use Code Execution Fallback and Path Anchoring in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add HKUDS/OpenSpace --skill code-execution-fallback -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/code-execution-fallback, .gemini/skills/code-execution-fallback, .github/skills/code-execution-fallback and .opencode/skills/code-execution-fallback in your project.

What does Code Execution Fallback and Path Anchoring need to run?

Going by SKILL.md and its folder, Code Execution Fallback and Path Anchoring needs the command-line tools its instructions call (python and python3). Our summary lists: An agent runtime with `execute_code_sandbox`, `run_shell` and `shell_agent` tools.

Does Code Execution Fallback and Path Anchoring access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Code Execution Fallback and Path Anchoring safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Code Execution Fallback and Path Anchoring use?

Code Execution Fallback and Path Anchoring is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Code Execution Fallback and Path Anchoring use?

About 1.1k tokens (SKILL.md is roughly 4.4k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Code Execution Fallback and Path Anchoring?

Skills that share tags, products or a category with Code Execution Fallback and Path Anchoring: Ue Live Debugging (JasonMa0012/MooaToon, 749 stars), Python Script Runner (congchuanling-dot/Cohort, 199 stars), Smart File Writer (foryourhealth111-pixel/Vibe-Skills, 3.6k stars) and Batch Files (github/awesome-copilot, 40k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Code Execution Fallback and Path Anchoring?

HKUDS (a GitHub organization) maintains it in HKUDS/OpenSpace, which has 7,743 GitHub stars. The repository holds 199 skills in this directory. The repository was last updated on August 12, 2026.

Source: HKUDS/OpenSpace on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.