Przejdź do treści
Biblioteka skilli
Programowanie · Testowanie

live-loop

/live-loop

Buduje pętlę testów na żywo dla aplikacji desktopowych: uruchamia, zbiera sygnały, wstrzykuje błędy i sprząta procesy.

Repozytorium
skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
29.10.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 29.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Buduje pętlę testów na żywo dla aplikacji desktopowych: uruchamia, zbiera sygnały, wstrzykuje błędy i sprząta procesy.

Oryginalny opis (EN)

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.

Jak działa

  1. Hard principles
  2. Runner contract
  3. Build order
  4. Challenge the loop
  5. Re-check the loop code
  6. Done means
  7. Reference implementation
Sekcje z nagłówków SKILL.md, w oryginale · 112 linii, 884 słów
Podgląd SKILL.md
---
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.

Wersje

W bazie nie ma innych skilli o nazwie live-loop.

Migawka bazy z 13.11.2026 · wersja paczki 1e94231915a6 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90diagnose-loop
    Prowadzi pętlę diagnozy trudnych błędów, w której pierwszym etapem jest szybka, deterministyczna pętla sygnału binarnego.
  • 100iterate-post-launch
    Zamyka pętlę informacji zwrotnej po starcie aplikacji: czyta sygnały z produkcji, szereguje najważniejsze problemy, naprawia je i weryfikuje na żywo, a potem powtarza cykl.
  • 100setup-issue-loop
    Instaluje issue-loop w repozytorium, zbiera i sprawdza konfigurację, testuje tracker i uruchamia test współbieżności wątków.
  • 100electron-desktop
    Wspiera tworzenie aplikacji desktopowych w Electron dla Windows, macOS i Linux, w tym funkcje natywne systemu i pakowanie aplikacji webowych.
  • 100phase-build
    Buduje jedną fazę wydania według specyfikacji: plan na interaktywnej tablicy (endpointy, komponenty, zasoby), korekty użytkownika i budowa węzeł po węźle z postępem na żywo.
  • 98diagnosing-bugs
    Prowadzi sześciofazową pętlę diagnozy trudnych błędów i regresji wydajności: od powtarzalnej reprodukcji po test regresyjny przed poprawką.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.