live-loop
/live-loop
Build an agent-runnable live-test runner (feedback loop) for desktop or hybrid apps: spawn, capture, watch markers, inject faults, stress, tree-kill. Use when /skill:diagnose Phase 1 needs a live signal or a bug shows only in a real window.
- Author
- protokol11 ↗
- Repository
- skills ↗
- Licence
- MIT
- Last repository change
- 29.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 29.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Build an agent-runnable live-test runner (feedback loop) for desktop or hybrid apps: spawn, capture, watch markers, inject faults, stress, tree-kill. Use when /skill:diagnose Phase 1 needs a live signal or a bug shows only in a real window.
Original author description
Build an agent-runnable live-test runner (feedback loop) for desktop or hybrid apps: spawn, capture, watch markers, inject faults, stress, tree-kill. Use when /skill:diagnose Phase 1 needs a live signal or a bug shows only in a real window.
How it works
- Hard principles
- Runner contract
- Build order
- Challenge the loop
- Re-check the loop code
- Done means
- Reference implementation
SKILL.md preview
--- name: live-loop description: "Build an agent-runnable live-test runner (feedback loop) for desktop or hybrid apps: spawn, capture, watch markers, inject faults, stress, tree-kill. Use when /skill:diagnose Phase 1 needs a live signal or a bug shows only in a real window." disable-model-invocation: true --- # Live Loop A live loop is one command that runs the real app, captures everything, decides pass or fail, and cleans up. Build it before diagnosing any live-only bug. Parent discipline: `/skill:diagnose`, Phase 1. Its words, verbatim: > "This is the skill. Everything else is mechanical." > "If you have a fast, deterministic, agent-runnable pass/fail signal for the bug, you will find the cause." > "Spend disproportionate effort here. Be aggressive. Be creative. Refuse to give up." > "A 30-second flaky loop is barely better than no loop. A 2-second deterministic loop is a debugging superpower." ## Hard principles ### Scope and signal 1. **Scope lock before building.** State what the loop runs, what it never touches, and how to check success. Wait for GO. 2. **Define markers before running.** List the log lines that mean pass, fail, and progress. The loop live-filters them. No marker list, no run. ### Truth 1. **A negative result is a result.** If the bug does not reproduce, say so. Label every inference from absence as inference. Do not claim a root cause you did not observe. 2. **The agent does not self-certify.** Present logs, counts, and durations. The author or a verification gate decides what they mean. ### Capture 1. **One command, unattended.** The agent runs the loop end to end without human input. No manual windows, no clicks by hand. 2. **Capture everything, raw.** Write stdout and stderr of every layer to one timestamped log file. Never trust a death you did not record. ### Kill and forensics 1. **Know the process forest before killing.** Wrappers spawn children, so measure which pid owns the window and the output. Assume your first tree model is wrong. 2. **Tree-kill, always.** Kill the whole forest from the root. `child.kill()` on a wrapper orphans the real process. 3. **Forensics must survive the kill.** Give every spawned process its own uniquely named log file. A respawn must not overwrite the log left by the dead process. ### Signal and time 1. **Time-box every run.** Set a duration cap and an optional early-stop regex. The loop never hangs forever. 2. **Non-intrusive stress first, real input last.** Start with programmatic moves and resizes. Real mouse input is a last resort and hijacks the cursor. 3. **Fault injection beats waiting.** Do not wait for a rare crash. Kill the process externally at a chosen second to exercise respawn and recovery on demand. ## Runner contract Core options: | Option | Effect | |---|---| | `--duration N` | Kill the app N seconds in. | | `--until <regex>` | Stop early when a log line matches. | | `--keep-going` | Continue to `--duration` after `--until` matches. | Stress and fault options: | Option | Effect | |---|---| | `--label S` | Tag the log filename. | | `--stress <mode>` | Run a stressor alongside the app. | | `--kill-<target>-at N` | Externally kill a chosen process N seconds in. | Exit code: `0` when the run completed and any `--until` marker matched. Nonzero otherwise. ## Build order 1. Read `/skill:diagnose` end to end, and restate its Phase 1 before writing code. 2. Map the launch chain and verify it with a live probe: command, wrappers, children, window owners. 3. Write the minimal runner: spawn, tee output to a timestamped log, tree-kill on timeout. 4. Add the marker filter and `--until`. 5. Add fault injection and stressors, one lever at a time. 6. Smoke-test the loop itself: marker matched, clean kill, logs complete. ## Challenge the loop After the loop works, run `/skill:prototype` against the loop design itself. The question is: "Where am I wrong? What am I not seeing?" Attack at least: 1. Does the kill really kill? Check for orphan processes after the run. 2. Can the marker regex match a line that never comes from the real event? 3. Can the loop miss a fast death between polls? 4. Does the stressor reach the real input path, or a look-alike? 5. What did the original bug report include that the loop cannot produce? Keep the probe throwaway. Record the answer, then delete or absorb it. ## Re-check the loop code The runner is code, so review it as code: 1. Run a principle review on the runner and stressors. 2. Convert findings with `/skill:to-violations` into a fix spec: file, line range, acceptance criteria, one verification command per violation. 3. Fix, then re-run the loop against the original scenario. ## Done means Run hygiene: - [ ] One command runs the whole loop unattended. - [ ] A full log lands on disk for every run. - [ ] No orphan processes after the run (`tasklist` or equivalent). - [ ] Forensics of a killed process survived its respawn. Honesty: - [ ] Markers fired, or the report states their absence. - [ ] Every claim in the report cites a log file and a line. - [ ] The report labels inferences as inferences. ## Reference implementation Built 2026-09-15 for a Tauri host, Godot renderer, and TS sidecar: a headless runner script plus two fault-injection stress scripts in the project's `.scratch/`, wired to watch markers and kill the tree on failure. The soak-test pattern (run → watch markers → inject fault → verify the report cites logs) is what this section documents.
Versions
The database has no other skills named live-loop.
Database snapshot: 13.11.2026 · package version 1e94231915a6 (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
- 90diagnose-loop
Disciplined bug-diagnosis loop where Phase 1 — building a fast, deterministic, binary-signal feedback loop — IS the skill; the rest of the phases mechanically consume that signal. Use whenever the user reports a hard bug, a flaky test, a performance regression, or says they've… - 100iterate-post-launch
Close the feedback loop on a live app: read production signals, rank the top issues, fix, verify live, repeat. Use when "post-launch polish", "fix the top production issues", "iterate on feedback", or "what should I fix next after launch?". - 100setup-issue-loop
Install issue-loop into a target repository, collect and validate its config, check the tracker, intake, runner, and app-control skill, hand off the two automations, and run the thread-safety test. Use for first install or any config change. - 100electron-desktop
Desktop application development with Electron for Windows, macOS, and Linux. Use when building cross-platform desktop apps, implementing native OS features, or packaging web apps for desktop. - 100phase-build
Build one release phase against the specs — plan it on an interactive board (endpoints, components, resources, with what already exists read from the codebase), let the user adjust, then build node by node while the board shows live progress. Use when the user wants to build a… - 98diagnosing-bugs
Six-phase diagnosis loop for hard bugs and performance regressions. Phase 1: build a tight, deterministic, fast feedback loop that goes red on the exact bug. Phase 2: reproduce and minimise to smallest red scenario. Phase 3: generate 3-5 ranked falsifiable hypotheses. Phase 4:…