SkillFoxx

strobe CLI

A performance CLI that lets an agent compare branches, find slow spots and confirm a speedup with numbers.

  • 151 ★ on the repository
  • Last commit
CLI

Extended access

Why this level

  • Launches your app and records arbitrary machine processes from outside, which needs OS permissions.
  • The `strobe look` command reads on-screen content.
All reasons and checks

anomalyco/strobeAuthor:Hona

Install

Manual install

bun add -d @hona/strobe && bunx strobe up

Installs the package and the `strobe` skill; run once per machine.

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • Launches your app and records arbitrary machine processes from outside, which needs OS permissions.
  • The `strobe look` command reads on-screen content.

This is third-party code. Review the repository files before installing.

What it does

strobe records a web page, an Electron app, a Bun or Node process or any other process on one timeline and answers with verdicts and handles such as `rec_3f9a` and `exp_9b3b26` that you can drill into. A measurement it cannot defend is refused, and the refusal counts as an answer. The main command for an agent is `strobe bench`: a `*.bench.ts` file describes targets and cases, for example page scrolling, and the command compares a branch with its base in pairs. The other commands answer questions about a recording: `strobe record` captures a process, `strobe query` shows hotspots and the difference between two recordings, `strobe look` describes the screen, `strobe report` builds a result card for a pull request and `strobe open` opens a recording in Perfetto. Drill-down goes to the line of code, native stack, threads, wake-ups, allocations, frames and video memory. `strobe up` installs the `strobe` skill that tells the agent the order of work.

Who it is for. Frontend and desktop developers who ask an agent to speed up an app and want reproducible numbers in a pull request.

Good fit when

  • You need to know whether a branch sped up scrolling and get the answer as paired runs against the base.
  • An installed app is slow and you must see where CPU time goes across threads.
  • A memory leak is suspected and a recording with memory probes should confirm the growth.
  • A pull request needs a before-and-after card with numbers.

Not a fit when

  • You just want a quick eyeball speed estimate without setting up benchmarks.
  • You need a load test of a server: strobe measures pages, apps and machine processes.
  • The OS permissions needed to record processes cannot be granted.

Example request

Did this branch make scrolling faster than origin/main? Run the bench and give me a card for the pull request.

Limitations

Installation goes through the Bun package manager: `bun add -d @hona/strobe`, then `bunx strobe up` once per machine. `strobe status` shows what the machine can measure and which permission is missing. Durations need a unit, for example `10s`, otherwise the command exits with code 2. Deep probes such as `waits` load the target at every context switch, and video capture perturbs timing. The repository declares no license and no support terms.

How to disable. Remove the dev dependency with `bun remove @hona/strobe` and the `strobe` skill folder from the agent skills directory. Recordings and profiles live in the project and in `strobe.json`.

FAQ

How do I install strobe for an agent?

With `bun add -d @hona/strobe && bunx strobe up`, once per machine. The second part installs the `strobe` skill the agent uses to choose commands.

What is `app:desktop`?

A profile in the repository `strobe.json`: how to build and launch the app in a throwaway home so benches never touch your real data.

How do I compare two recordings?

`strobe query rec_3f9a..rec_7c1d hotspots` shows what got slower between the two recordings.

Does strobe work with Firefox?

Yes, with `--engine firefox`: the page is measured from outside, with CPU, GPU, memory and DOM nodes. For heap snapshots use a bench leak run.

How do I open a whole recording?

`strobe open rec_3f9a` opens the recording in Perfetto, where all threads and frames are visible.

Discussion

No questions or reviews yet.

CLI tools

A CLI finds complexity hotspots and keeps static findings apart from measurements, so agents can judge optimisations.

CLIMinimal access65
Official

Vercel CLI for testing coding agents on your framework: runs Claude Code, Codex and others and measures the success rate

CLIExtended access280

hyperfine repeatedly runs commands, compares timing and other metrics and exports measurements for review and automation.

CLIExtended access29.3K
Official

A CLI for performance measurement and regression detection; the repository also holds a plugin with two skills and MCP for Claude Code and Cursor

CLIExtended access394

CLI checks a web page in Chromium: finds every control, uses it and reports what broke. No tests to write and no LLM.

CLIExtended access110

A local debugger for TypeScript agents: run step trees, CI trajectory checks and portable evidence bundles, with no account.

CLIExtended access212

README in short

strobe is built for agents: tasks are phrased as questions such as whether a branch got faster, and answers come as verdicts and recording handles. A benchmark is described in TypeScript and run in base-and-branch pairs.

README badge

Original SKILL.md

---
name: strobe
description: Measure and explain performance of web pages, Electron apps, Bun or Node processes and any process. Use when the user asks whether a change is faster, why something is slow, janky or heavy, where memory goes, what the CPU or GPU is doing, or to write a benchmark.
---

# Strobe

strobe records a target on one timeline and answers with verdicts and handles (`rec_…`, `exp_…`) to drill into. It refuses measurements it cannot defend: a refused run is an answer.

## Reference

### `strobe status`

```text
strobe status [--calibrate]
```

- Environment, validity preflight, recent handles.

### `strobe record`

```text
strobe record <target> [--probes timing|attribution|memory] [--for 10s] [--headless] [--served <dir>]
strobe record https://… --engine firefox [--probes timing|attribution] [--headless] [--for 10s]
strobe record --bench <file.bench.ts>#<case> [--head <variant>]
strobe record pid:<n>|proc:<name> [--probes timing|deep|waits] [--for 10s]
strobe record app:<id> --until-line "<regex>" [--stop-line "<regex>"]
strobe record <target> --video     (or record --bench … --video: a video of the check run; timing perturbed)
```

- `--for` (and every duration) needs its unit: `500ms`, `10s`, `2m`; a bare number exits 2.
- `--bench`: a bench case (clicks, keys) under the attribution probes.
- `pid:<n>|proc:<name>`: any running process from outside: frames from the OS's present events, CPU, threads, IO, GPU, memory.
  - `deep`: native stacks (kernel sampled profile, PDB symbols).
  - `waits`: `deep` plus off-CPU waits (`query <rec> waits`); costs the target at every context switch.
- `--until-line`: a native app from the line it prints when ready (to the next line), not a fixed settle.
- `--engine firefox`: the page in Firefox, from outside: CPU, GPU, memory, DOM nodes, and headed the OS's frames.
  - `--probes attribution`: Firefox's profiler and about:memory (`hotspots`, `layout`, `gc`, `memory`).
  - `--probes memory` refuses: Firefox gives no heap snapshots; use a bench leak run.

### `strobe bench`

```text
strobe bench <file.bench.ts> --head <variant>
    [--base <variant> | --aa | --check | --blocks N] [--filter <cases>] [--target <name>]

Report a problem