step-interactive-execution
Prepare and run a user-confirmed interactive execution or test session for a source file, executable, script, demo, or directory. This skill must be invoked manually: use it only when the user explicitly invokes step-interactive-execution by name or clearly asks for this exact manual workflow. Read the target first without pausing, then switch to a strict step-by-step loop where the agent prints the exact CLI command to run next, waits for confirmation such as "continue", executes only that approved command, and reports the result before proposing the next step.
Best use case
step-interactive-execution is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Prepare and run a user-confirmed interactive execution or test session for a source file, executable, script, demo, or directory. This skill must be invoked manually: use it only when the user explicitly invokes step-interactive-execution by name or clearly asks for this exact manual workflow. Read the target first without pausing, then switch to a strict step-by-step loop where the agent prints the exact CLI command to run next, waits for confirmation such as "continue", executes only that approved command, and reports the result before proposing the next step.
Teams using step-interactive-execution should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/step-interactive-execution/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How step-interactive-execution Compares
| Feature / Agent | step-interactive-execution | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Prepare and run a user-confirmed interactive execution or test session for a source file, executable, script, demo, or directory. This skill must be invoked manually: use it only when the user explicitly invokes step-interactive-execution by name or clearly asks for this exact manual workflow. Read the target first without pausing, then switch to a strict step-by-step loop where the agent prints the exact CLI command to run next, waits for confirmation such as "continue", executes only that approved command, and reports the result before proposing the next step.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Step Interactive Execution This skill must be invoked explicitly by name. Do not apply it implicitly from context alone. Run the session in two phases: unattended preparation first, then confirmed execution. ## Preparation Phase Inspect the target before asking the user to approve any command. - Identify whether the target is a source file, executable, script, or directory. - Read the smallest useful set of nearby materials: local README files, runner scripts, tests, inputs, wrappers, config, and obvious entrypoints. - Use read-only inspection commands freely during this phase. - Do not pause for approval during preparation. - Do not start the real test flow or other side-effecting commands during preparation unless the user explicitly asks. At the end of preparation, summarize only the operational facts needed for the next step: - what the target appears to do - how it is likely meant to be exercised - visible prerequisites or environment constraints - the most likely next command to run ## Target-Specific Reading Heuristics ### Source File - Read the file itself first. - Read nearby callers, entrypoints, tests, or wrappers that define how the file is exercised. - If it is a runnable script, inspect its usage surface before executing it. ### Executable Or CLI - Prefer local docs, wrapper scripts, and checked-in examples first. - Use `--help` or equivalent only when it is cheap and safe. - Avoid commands that may mutate state just to discover usage. ### Directory - Read the local operator guidance first. - For demo or tutorial directories, inspect the runner, input fixtures, expected outputs, cleanup behavior, and any verification helpers. - Distinguish convenience wrappers from the underlying manual command flow. ## Confirmed Execution Loop After preparation, handle real execution one step at a time. 1. Derive the single next command that should run. 2. Print that exact command before executing it. 3. Wait for the user's approval signal. 4. Execute only the approved command. 5. Report the result briefly. 6. Propose the next command and wait again. Treat this loop as the default contract for the session. ## Command Presentation Rules - Use the exact command that is about to run, not a paraphrase. - Present the command in a fenced `bash` block. - Prefer one command per approval step. - If the user explicitly asks to batch several commands behind one confirmation, print the full batch together and wait once. - Never execute additional side-effecting commands that were not shown to the user first. - Preparatory inspection commands do not need user confirmation and do not need to be shown as pending execution. Use this response shape when requesting approval: ```text CLI command to execute next: ``` ```bash <exact command> ``` ```text Send `continue` when you want me to run it. ``` After approval, use this response shape: ```text Executed: ``` ```bash <exact command> ``` ```text <brief result summary> ``` ## Failure Handling - If a command fails, report the failure before proposing anything else. - Do not hide retries, cleanup, or fallback actions behind the same approval. - If recovery needs another command, show that command and wait for approval. - Do not jump to code changes or fixes unless the user explicitly changes the task. ## Boundaries - Treat this skill as read-and-run by default. - Do not modify code during the preparation phase. - Do not widen scope beyond the user's target unless surrounding files are needed to understand or execute the target safely. - If a safer or more accurate command becomes necessary, show the revised command and wait again. ## Examples - "Use step-interactive-execution on `scripts/demo/foo`." - "Use step-interactive-execution for this binary and walk me through the test." - "Use step-interactive-execution on `src/app/main.py`; read it first, then wait before each command."
Related Skills
do-interactive-test
Prepare for and run user-driven interactive testing of a directory the user points to. Use when the user wants the agent to read what is already there first, be prepared, follow step-by-step test instructions, or honor a constrained edit boundary during testing. Handle generic directories, demo/tutorial directories, and OpenSpec change directories differently; for OpenSpec change directories, use openspec CLI commands to gather context instead of assuming a file layout inside the directory. During interactive testing, do not automatically modify the system under test; report issues first, let the developer decide whether to log them or proceed to a fix, and only modify demo-specific code when a fix is explicitly requested. Do not create extra logs unless the developer asks for issue logging or step logging.
pixi-make-offline-channel
Use when the user wants to create a self-hosted, offline-installable Conda channel (mirror) containing a specific subset of packages using Pixi.
pixi-make-cu-build-env
Guides the agent to setup a new or existing Pixi environment for compiling C++ and CUDA code. It ensures the correct compilers, toolkits, and CMake configurations are in place for a robust user-space build.
pixi-install-nvidia
Use when the user says "use pixi to install <some nvidia tool>" (or similar) and wants NVIDIA/CUDA/GPU packages installed via Pixi (no sudo/apt), e.g., CUDA toolkit pieces, cuDNN/NCCL, PyTorch CUDA builds, RAPIDS.
pei-docker-usage
Helper for PeiDocker (`pei-docker-cli`). Trigger ONLY when the user explicitly requests PeiDocker usage OR when working within a PeiDocker-generated project (indicated by `user_config.yml`).
conan-basic-usage
Basic operations for the Conan C++ package manager. Use when the user explicitly asks to 'use conan' for tasks like creating projects, installing dependencies, or building packages, or asks for 'how to' guidance on Conan setup.
explore-dnn-model
Manual invocation only; use only when the user explicitly requests `explore-dnn-model` by name. Explore how to run a given DNN model checkpoint in the current Python environment by locating weights + upstream source code, resolving dependencies with user confirmation, running reproducible experiments under `tmp/`, and producing reports about I/O contracts, timing, and profiling.
openspec-ext-revise-by-decision
Manual invocation only; use only when the user explicitly requests `openspec-ext-revise-by-decision` by exact name. Revise OpenSpec change artifacts from a review or decision document that contains questions plus `DECISION` blocks, applying chosen decisions from a review file such as `openspec/changes/<change>/review/review-*.md` back into proposal, design, specs, and tasks.
openspec-ext-review-plan
Review an OpenSpec change (or a single OpenSpec change artifact file) for completeness, coherence, and alignment with existing system design; capture actionable feedback plus open questions; write a review report under the change directory (review/review-YYYYMMDD-HHMMSS.md).
openspec-ext-respond-to-review
Read an OpenSpec review report critically, evaluate the reviewer's proposals and findings against the current change artifacts and repository context, and write developer-owned final decisions/responses back into the review document. Use when the user explicitly mentions `openspec` or points to a path under `openspec/` while asking to examine a review report carefully, decide open questions, respond to findings, fill `DECISION` blocks, respond to an OpenSpec review file, or record final answers in an OpenSpec review document without yet revising the proposal, design, specs, or tasks.
openspec-ext-hack-through-test
Manual invocation only. OpenSpec-specific hack-through-testing workflow targeting production-level end-to-end paths using real data and real user workflows — not CI smoke/unit/integration tests. Three subskills: `propose` to create an OpenSpec change with HTT-ready test cases (automatic scripts and interactive guides) by invoking `openspec-propose` or `openspec-ff-change`, `revise` to update an existing OpenSpec change so its artifacts support hack-through-testing-driven implementation and testing, and `run` to exercise an implemented OpenSpec change through the full hack-through-testing loop (in-place by default, or in a disposable snapshot worktree when requested). Use when the user explicitly asks for `openspec-ext-hack-through-test`, points to `openspec/changes/...` while asking to propose, revise, run, exercise, or prepare work under hack-through-testing principles, or wants OpenSpec work shaped for fast blocker discovery through patch-forward testing.
openspec-ext-explain
Create or update OpenSpec change explanation docs that capture developer-facing questions and answers under `openspec/changes/.../explain/`. Use when the user explicitly mentions `openspec` or points to a path under `openspec/` while asking to create, update, document, or maintain a Q&A, FAQ, explain note, or question-and-answer doc for an OpenSpec change based on user questions, implementation notes, review questions, or current chat context.