Skip to content
Skills Library
Programming · Automation

execute

/execute

Run code or scripts deterministically with captured output. Use when running tests, executing build commands, invoking tools, or performing read-only operations that produce results.

Licence
Apache-2.0
Last repository change
30.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
6
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 30.08.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Run code or scripts deterministically with captured output. Use when running tests, executing build commands, invoking tools, or performing read-only operations that produce results.

Arguments

/execute [code] [language] [timeout]
Original author description

Run code or scripts deterministically with captured output. Use when running tests, executing build commands, invoking tools, or performing read-only operations that produce results.

How it works

  1. Intent
  2. Inputs
  3. Procedure
  4. Output Contract
  5. Examples
  6. Verification
  7. Safety Constraints
  8. Composition Patterns
Original SKILL.md headings · 247 lines, 841 words
SKILL.md preview
---
name: execute
description: Run code or scripts deterministically with captured output. Use when running tests, executing build commands, invoking tools, or performing read-only operations that produce results.
argument-hint: "[code] [language] [timeout]"
disable-model-invocation: false
user-invocable: true
allowed-tools: Read, Bash
context: fork
agent: general-purpose
layer: EXECUTE
---

## Intent

Execute code or commands in a controlled manner, capturing output for verification. Unlike `mutate`, this capability is for operations that don't permanently change state (tests, queries, builds, analysis tools).

**Success criteria:**
- Code/command executed successfully
- Output captured completely
- Exit code recorded
- Errors properly surfaced

**Compatible schemas:**
- `schemas/output_schema.yaml`

## Inputs

| Parameter | Required | Type | Description |
|-----------|----------|------|-------------|
| `code` | Yes | string | Code or command to execute |
| `language` | No | string | Programming language or shell (bash, python, ruby, etc.) |
| `timeout` | No | string | Maximum execution time (default: "60s") |
| `environment` | No | object | Environment variables to set |

## Procedure

1) **Validate execution request**: Ensure code is safe to run
   - Check for mutation operations (if found, suggest `mutate` instead)
   - Verify timeout is reasonable
   - Confirm execution environment

2) **Prepare environment**: Set up execution context
   - Set required environment variables
   - Ensure dependencies are available
   - Create isolated context if needed

3) **Execute code**: Run the code/command
   - Capture stdout and stderr
   - Record start time
   - Monitor for timeout

4) **Capture results**: Collect execution output
   - Record exit code
   - Capture complete stdout
   - Capture complete stderr
   - Note execution duration

5) **Analyze output**: Interpret results
   - Identify success/failure from exit code
   - Extract key information from output
   - Note warnings or anomalies

6) **Return results**: Structure output for consumption
   - Include all captured data
   - Provide execution summary
   - Reference evidence for assertions

## Output Contract

Return a structured object:

```yaml
result:
  success: boolean  # Exit code == 0
  exit_code: integer  # Process exit code
  stdout: string  # Standard output
  stderr: string  # Standard error
  duration: string  # Execution time
execution:
  command: string  # What was executed
  language: string  # Execution environment
  started_at: string  # ISO timestamp
  completed_at: string  # ISO timestamp
analysis:
  summary: string  # One-line result summary
  warnings: array[string]  # Notable warnings
  errors: array[string]  # Extracted error messages
evidence_anchors: ["command:output"]
```

### Field Definitions

| Field | Type | Description |
|-------|------|-------------|
| `result.success` | boolean | Whether execution succeeded |
| `result.exit_code` | integer | Process exit code |
| `result.stdout` | string | Standard output |
| `result.stderr` | string | Standard error |
| `result.duration` | string | How long execution took |
| `execution` | object | Execution metadata |
| `analysis` | object | Interpreted results |

## Examples

### Example 1: Run Tests

**Input:**
```yaml
code: "npm test -- --grep 'UserService'"
language: "bash"
timeout: "120s"
```

**Output:**
```yaml
result:
  success: true
  exit_code: 0
  stdout: |
    > project@1.0.0 test
    > jest --grep 'UserService'

    PASS src/services/__tests__/UserService.test.ts
      UserService
        ✓ creates user with valid data (45ms)
        ✓ validates email format (12ms)
        ✓ hashes password on save (23ms)

    Test Suites: 1 passed, 1 total
    Tests:       3 passed, 3 total
  stderr: ""
  duration: "2.3s"
execution:
  command: "npm test -- --grep 'UserService'"
  language: "bash"
  started_at: "2024-01-15T10:30:00Z"
  completed_at: "2024-01-15T10:30:02Z"
analysis:
  summary: "3 tests passed in UserService"
  warnings: []
  errors: []
evidence_anchors:
  - "command:npm test:output"
```

### Example 2: Execute Query

**Input:**
```yaml
code: "SELECT COUNT(*) as user_count FROM users WHERE created_at > '2024-01-01'"
language: "sql"
environment:
  DATABASE_URL: "${DATABASE_URL}"
```

**Output:**
```yaml
result:
  success: true
  exit_code: 0
  stdout: |
    user_count
    ----------
    15423
    (1 row)
  stderr: ""
  duration: "0.15s"
execution:
  command: "psql -c \"SELECT COUNT(*)...\""
  language: "sql"
  started_at: "2024-01-15T10:35:00Z"
  completed_at: "2024-01-15T10:35:00Z"
analysis:
  summary: "Query returned 15423 users created in 2024"
  warnings: []
  errors: []
evidence_anchors:
  - "command:psql:query_result"
```

### Example 3: Execution Failure

**Input:**
```yaml
code: "python -c 'import nonexistent_module'"
language: "bash"
```

**Output:**
```yaml
result:
  success: false
  exit_code: 1
  stdout: ""
  stderr: |
    Traceback (most recent call last):
      File "<string>", line 1, in <module>
    ModuleNotFoundError: No module named 'nonexistent_module'
  duration: "0.05s"
execution:
  command: "python -c 'import nonexistent_module'"
  language: "bash"
  started_at: "2024-01-15T10:40:00Z"
  completed_at: "2024-01-15T10:40:00Z"
analysis:
  summary: "Import failed: module 'nonexistent_module' not found"
  warnings: []
  errors:
    - "ModuleNotFoundError: No module named 'nonexistent_module'"
evidence_anchors:
  - "command:python:error"
```

## Verification

- [ ] Exit code is captured
- [ ] Stdout and stderr are both recorded
- [ ] Duration is reasonable
- [ ] Analysis summary matches output
- [ ] No mutations occurred

**Verification tools:** Bash (to verify command execution environment)

## Safety Constraints

- `mutation`: false
- `requires_checkpoint`: false
- `requires_approval`: true
- `risk`: medium

**Capability-specific rules:**
- Verify code does not mutate persistent state
- Enforce timeout limits
- Capture all output for audit trail
- Do not execute code that requires elevated privileges without approval
- Prefer `mutate` for state-changing operations

## Composition Patterns

**Commonly follows:**
- `plan` - Execute planned actions
- `generate` - Execute generated code
- `transform` - Execute transformation scripts

**Commonly precedes:**
- `verify` - Verify execution results
- `detect` - Detect patterns in output
- `audit` - Record execution for audit

**Anti-patterns:**
- Never use execute for persistent state changes (use `mutate`)
- Avoid execute without timeout limits
- Never execute untrusted code without sandboxing

**Workflow references:**
- See `reference/workflow_catalog.yaml#debug_code_change` for execute in testing
- See `reference/workflow_catalog.yaml#digital_twin_sync_loop` for execute in sync loops
Files in this package (6)
  • SKILL.md 7 KB
  • reference/event_schema.yaml 4 KB
  • reference/transform_mapping_rawlog_to_observation.yaml 2 KB
  • reference/workflow_catalog.yaml 56 KB
  • reference/world_state_schema.yaml 11 KB
  • schemas/output_schema.yaml 1 KB

Versions

RepositoryScoreLicence
This page · synaptiai/agent-capability-standard100Apache-2.0
insideout-ai/make-it-work100MIT
yaleh/quay100MIT
jkaloger/lazyspec100MIT
shakestzd/htmlgraph100MIT
shakestzd/htmlgraph100MIT
shakestzd/htmlgraph100MIT
crbnos/carbon100AGPL-3.0
alirezarezvani/claude-skills100MIT

Database snapshot: 13.11.2026 · package version bb96e11fe3dd (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100running-e2e-tests
    Execute end-to-end tests covering full user workflows across frontend and backend. Use when performing specialized testing. Trigger with phrases like "run end-to-end tests", "test user flows", or "execute E2E suite".
  • 100running-e2e-tests
    Execute end-to-end tests covering full user workflows across frontend and backend. Use when performing specialized testing. Trigger with phrases like "run end-to-end tests", "test user flows", or "execute E2E suite".
  • 82verify
    Prove a claim of done, fixed, or passing before you make it. Run the commands and read their output. Read this skill before you say that work is done, fixed, or tested. Read it also after a small change. Use it before a commit or a PR. Use it also when the user asks to write or…
  • 100uv-python-execution
    How to run Python scripts, tests, evaluations, and tools using uv run and uvx in this repository. Use whenever executing Python code or test suites during repository and extension development.
  • 100running-integration-tests
    Execute integration tests validating component interactions and system integration. Use when performing specialized testing. Trigger with phrases like "run integration tests", "test integration", or "validate component interactions".
  • 100arn-code-execute-task
    This skill should be used when the user says "execute task N", "run task N", "implement task N", "re-run task N", "retry task N", "run single task", or wants to execute a single specific task from the task list with optional review. This is for ONE task only — for executing the…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.