Przejdź do treści
Biblioteka skilli
Programowanie · Testowanie

maestro-bug-video

/maestro-bug-video

Nagrywa błąd w aplikacji mobilnej przez Maestro i składa z tego wideo, które pokazuje błąd albo naprawę obok wersji wadliwej.

Licencja
MIT
Ostatnia zmiana repozytorium
10.11.2026

Ocena i bezpieczeństwo

100/ 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ść35 / 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
4
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 10.11.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

Nagrywa błąd w aplikacji mobilnej przez Maestro i składa z tego wideo, które pokazuje błąd albo naprawę obok wersji wadliwej.

Oryginalny opis (EN)

Record a mobile app bug with Maestro and turn it into a video people can follow: one run that shows the bug, or the bug build beside the fixed build. Use when: presenting a reproduced bug to a team or reviewer, attaching evidence to a bug report or pull request, or showing that a fix works. Triggers: bug video, before and after video, record the repro, show the bug, show the fix, demo the fix, present the bug.

Jak działa

  1. Preconditions
  2. Workflow
  3. Completion
Sekcje z nagłówków SKILL.md, w oryginale · 98 linii, 953 słów
Podgląd SKILL.md
---
name: maestro-bug-video
description: "Record a mobile app bug with Maestro and turn it into a video people can follow: one run that shows the bug, or the bug build beside the fixed build. Use when: presenting a reproduced bug to a team or reviewer, attaching evidence to a bug report or pull request, or showing that a fix works. Triggers: bug video, before and after video, record the repro, show the bug, show the fix, demo the fix, present the bug."
---

# Maestro Bug Video

Produce an MP4 that a person who has never seen the bug understands without help: a title card that names the bug,
each step in plain language, a caption that states the result, and a held final frame. The video is only evidence
when the run behind it proves the claim, so the Maestro result is part of the deliverable.

Two modes share one workflow:

| Mode      | Shows                                          | Needs                                          |
| --------- | ---------------------------------------------- | ---------------------------------------------- |
| `explain` | One run of the bug build                       | A flow that reproduces the bug                 |
| `compare` | The bug build and the fixed build side by side | The same flow, plus a build containing the fix |

## Preconditions

- A Maestro flow that reproduces the bug: it fails on the bug build at the step that observes the bug, and passes on the
  fixed build. If no such flow exists, write it first; a video of a run that does not observe the bug proves nothing.
- `maestro` on PATH (a project-pinned one through `mise exec --` when the project pins it), `ffmpeg` and `ffprobe`
  with the `drawtext` filter. On Android, also `adb` and Python 3.10 or newer.
- Devices or simulators that can run the bug build and, for `compare`, the fixed build.

## Workflow

Paths such as `scripts/compose-bug-video` are relative to this skill's directory; the scripts are not on `PATH`.

1. **Make the flow readable.** Give every command a plain-language `label:` that says what the user does or sees.
   Read [`references/flow-tips.md`](references/flow-tips.md) before editing the flow; it covers labels, the
   recording variant, and speed.
2. **Prepare the recording variant of the bug run.** Copy the flow, mark the step that observes the bug
   `optional: true`, and relabel it as `Expected: <correct behaviour> – <what happens instead>`. A failing step would
   end the run before the renderer finishes; the optional step still shows ⚠ in the video and in the log.
3. **Install the builds.** Build the bug state from the commit before the fix, not by hand-reverting files, unless the
   fix is a single line you restore immediately. A `git worktree` at the base commit with its own build output keeps
   the two builds apart. Put each build on its own device or reinstall between recordings.
4. **Record one run at a time.** Before each recording, leave the device on its home screen or on the app under
   test: until the flow's first step changes the screen, the video shows whatever the device showed before.
   On an iOS simulator, use Maestro's renderer:

   ```bash
   maestro --device <bug-device> record --local <bug-variant.yaml> before.mp4
   maestro --device <fix-device> record --local <flow.yaml> after.mp4
   ```

   Always pass `--local`: without it Maestro uploads the recording to its cloud for rendering.

   On an Android device or emulator, use [`scripts/record-maestro-run`](scripts/record-maestro-run) instead.
   `maestro record` cuts the end of an Android run: `screenrecord` writes frames only when the screen changes, and
   the renderer stops at the last frame, before the run's final screen. The script records the screen itself, runs
   `maestro test`, holds the last frame until the run really ended, and draws the steps from Maestro's
   `commands.json`:

   ```bash
   scripts/record-maestro-run --device <bug-device> --flow <bug-variant.yaml> --out before.mp4
   scripts/record-maestro-run --device <fix-device> --flow <flow.yaml> --out after.mp4 --maestro "mise exec -- maestro"
   ```

   The video starts at the flow's first step, without Maestro's startup. It exits with Maestro's exit code.
   Recording has no time limit where the device's `screenrecord` allows it, as on Android 17; older versions stop
   recording after 180 seconds.

   A flow that types a secret, such as a test account's password from `${MAESTRO_PASSWORD}`, needs a `label:` on that
   `inputText`: `maestro record` prints the resolved text in its step list, so an unlabelled step shows the secret in
   the video. `record-maestro-run` never shows resolved values, and it keeps Maestro's logs, which record typed text,
   in a temporary directory that it deletes.

   Run recordings sequentially; two Maestro processes started separately compete for the same driver port and both
   runs break. Before starting, check that no earlier run is still alive (`pgrep -fl maestro`) and stop leftovers you
   started.
5. **Confirm the runs prove the claim.** The bug recording must show every setup step passed and the bug step warned
   (✅ and ⚠ from Maestro's renderer; green and amber markers from `record-maestro-run`) with the bug visible on
   screen; the fixed recording must show every step passed. If either differs, the video would mislead: stop and fix
   the flow or the build.
6. **Compose the video** with [`scripts/compose-bug-video`](scripts/compose-bug-video):

   ```bash
   scripts/compose-bug-video explain --video before.mp4 \
     --title "<App> · <Screen>" --subtitle "Bug: <one sentence a user would say>" \
     --steps "<the steps in one line>" --caption "<what the viewer should notice>" --out bug.mp4

   scripts/compose-bug-video compare --before before.mp4 --after after.mp4 \
     --title "<App> · <Screen>" --subtitle "Bug: <one sentence>" \
     --steps "Same steps on both sides: <steps>" \
     --caption "Left: <what goes wrong>.   Right: <what the fix does>." --out before-after.mp4
   ```

   Write the title card and caption for someone outside the team: name the screen and the visible symptom, not the
   code. Banner labels default to "BEFORE · current app" and "AFTER · with the fix" (`--before-label`,
   `--after-label`); `--hold` sets the final-frame pause.
7. **Check the result before handing it over.** Extract the title frame and the last frame
   (`ffmpeg -ss 1 -i out.mp4 -frames:v 1 title.png`, `ffmpeg -sseof -1 -i out.mp4 -frames:v 1 end.png`) and look at
   them: the text must be complete and legible, and the last frame must show the bug, or the bug beside the fix.

## Completion

Report the video path, its length, which builds or commits each side shows, and the Maestro result for each run. The
output stays local; publishing or attaching it is the user's decision.
Pliki w paczce (4)
  • SKILL.md 7 KB
  • references/flow-tips.md 4 KB
  • scripts/compose-bug-video 9 KB
  • scripts/record-maestro-run 15 KB

Wersje

W bazie nie ma innych skilli o nazwie maestro-bug-video.

Migawka bazy z 13.11.2026 · wersja paczki 3dd892cf4be4 (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

  • 100mobile-demo-record
    Uruchamia aplikację mobilną na symulatorze iOS połączonym z lokalnym zapleczem, steruje nią w Maestro i nagrywa czyste nagrania ekranu.
  • 100teach-maestro
    Prowadzi wstępną rozmowę o projekcie z Maestro, by zapisać kontekst w pliku .maestro.md przy pierwszym uruchomieniu.
  • 100record-video
    Nagrywa krótkie wideo strony internetowej w Playwright, żeby pokazać działanie funkcji lub poprawki jako dowód.
  • 100fix-bug
    Odtwarza błąd, znajduje przyczynę, naprawia ją w miejscu i sprawdza poprawkę na tym samym odtworzeniu.
  • 96fix-a-bug
    Zleca agentowi Rush w chmurze odtworzenie błędu, jego naprawę i pull request z testem na podstawie zgłoszenia lub logu.
  • 90bug-repro
    Odtwarza, izoluje i wyjaśnia błąd, regresję lub niestabilny test, zanim powstanie poprawka.

Uwagi i zgłoszenia

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