Skip to content
Skills Library
Programming · Planning

runtime-estimate

/runtime-estimate

Before running a command that may take a while (test suite, build, full index, download, render), tell the user how long it will take and where the estimate comes from; when it finishes, report the real time and add it to the table of measured runtimes. Use before every test suite, build or render, even one you expect to be quick (then say "not measured" and estimate anyway), before any other command that may run longer than 30 seconds, when writing a prompt that has another agent run a suite or long job, and when the user asks "how long will this take". Do not use for commands that finish ins

Repository
skills ↗
Licence
MIT
Last repository change
11.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 11.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Before running a command that may take a while (test suite, build, full index, download, render), tell the user how long it will take and where the estimate comes from; when it finishes, report the real time and add it to the table of measured runtimes. Use before every test suite, build or render, even one you expect to be quick (then say "not measured" and estimate anyway), before any other command that may run longer than 30 seconds, when writing a prompt that has another agent run a suite or long job, and when the user asks "how long will this take". Do not use for commands that finish ins

Triggers from the description

not measuredhow long will this take
Original author description

Before running a command that may take a while (test suite, build, full index, download, render), tell the user how long it will take and where the estimate comes from; when it finishes, report the real time and add it to the table of measured runtimes. Use before every test suite, build or render, even one you expect to be quick (then say "not measured" and estimate anyway), before any other command that may run longer than 30 seconds, when writing a prompt that has another agent run a suite or long job, and when the user asks "how long will this take". Do not use for commands that finish ins

How it works

  1. Before running
  2. When it finishes
  3. Measured runtimes
  4. Gotchas
Original SKILL.md headings · 74 lines, 847 words
SKILL.md preview
---
name: runtime-estimate
description: |
  Before running a command that may take a while (test suite, build, full index,
  download, render), tell the user how long it will take and where the estimate
  comes from; when it finishes, report the real time and add it to the table of
  measured runtimes.
  Use before every test suite, build or render, even one you expect to be quick
  (then say "not measured" and estimate anyway), before any other command that
  may run longer than 30 seconds, when writing a prompt that has another agent run a suite or long job, and when the user asks
  "how long will this take".
  Do not use for commands that finish instantly (git status, reading, a single
  file edit).
---

# Runtime estimate

Why: the same suite can take 35 minutes or 2 hours depending on the machine and
shell. Waiting without knowing wrecks the user's plans for the rest of the day.

## Before running

Write one line in the message before the command:

> **Time:** ~N min (source: table, <date> <machine>/<shell>; range best to worst). Background / foreground.

- Take the estimate **from the table**. If the job is not in the table, say "not
  measured" and give a rough estimate with its reasoning (for example "1 run is
  about 30 s, times 4 is ~2 min"). Do not invent a number; give a range if you
  have nothing.
- Be honest about the range: the same job can take 4x longer in another
  environment (see the suite rows below).
- If it will take more than 2 minutes, run it in the background and give the
  finish time as a clock time ("done around 22:40").
- Compare the estimate with your shell tool's timeout (Claude Code: 2 min by
  default, 10 min at most; some harnesses allow 60 min). If it will exceed it,
  start in the background from the beginning and keep the PID.
- If a long job will cross midnight, say so: tests that use the date can break.

## When it finishes

- Write the real time: "Took: N min (estimated M min)".
- If it is more than 50% off the estimate, say why in one sentence (machine busy,
  different shell, network...).
- Add a new row to the table (append only; do not delete old rows). A new
  measurement of the same job goes under the old one.

## Measured runtimes

Keep your own table here (or in a notes file this skill points to). The rows below
are real measurements from the author's machines, kept as examples of what to
record and of how much environment matters.

| Job | Environment | Time | Date / source |
|---|---|---|---|
| Shell test suite (`sh tests/run.sh`, ~1,430 tests) | Windows 10 desktop, Git Bash | 35 min | 2026-10-11 |
| Same suite, run from another agent harness | Windows 10 desktop, Git Bash | 2 h 14 min | 2026-10-13 |
| Same suite (~1,590 tests) | Windows laptop, Git Bash, Claude Code background task, git worktree | 6 h 22 min | 2026-10-14 |
| Same suite (~1,600 tests), another session busy all day | Windows laptop, Git Bash, background task | 10 h 54 min | 2026-10-15 |
| Same suite (1,550 tests), alone | Windows 10 desktop, Git Bash | 12 h 32 min (estimate 2-8 h, missed) | 2026-10-17 |
| Same suite (~1,490 tests), heavy parallel agent load | Windows 10 desktop, Git Bash | ~25 h | 2026-10-16 |
| Same suite | Linux / WSL | ~32 min | 2026-10-10 |
| Same suite (1,592 tests) | Linux laptop, native shell | 3 min 27 s (estimate 10-20 min) | 2026-10-18 |
| Same suite on CI, three OSes | GitHub Actions | ubuntu 3 min 50 s, macOS 8 min 55 s, Windows 67 min 29 s | 2026-10-25 |
| One isolated test block (revert check) | Git Bash | ~50 s | 2026-10-10 |
| `uv sync` with CUDA torch (~4 GB) | laptop, ~2.6 MB/s | 26 min (estimate 45-60 min) | 2026-10-14 |
| Unreal Engine incremental build (2-4 .cpp files) | laptop | 10-22 s | 2026-10-14 |
| Unreal Engine first Shipping cook (`RunUAT BuildCookRun`, ~8,600 packages) | Windows 11 laptop, RTX 4050 | 2 min (estimate 20-60 min) | 2026-11-01 |
| ffmpeg 60 s 1080p60 x264 medium | laptop | ~42 s | 2026-10-14 |
| First `git push` of a repo, ~1,300 commits, ~220 MB pack | laptop, Git Bash, SSH | 74 s (estimate 2-10 min) | 2026-10-17 |
| Open-source leak audit agent, ~480 commits | laptop, Claude Code | 6 min 22 s (estimate 5-10 min) | 2026-10-24 |
| Image generation, one edit round (Codex built-in image tool) | laptop | 41-52 s (estimate 1-2 min) | 2026-10-22 |

## Gotchas

- **The same suite can differ by 100x across setups.** One shell-heavy suite took
  3.5 minutes on native Linux, about 32 minutes under WSL, and from 35 minutes to
  about 25 hours in Git Bash on Windows. Suite versions differed between runs and
  the cause of the long Windows runs was never isolated. Estimate only from rows
  measured on the same machine and shell.
- **A busy machine is a suspect.** The longest Windows run (~25 h) happened under
  heavy parallel agent load; a run alone took 12.5 h (different commits, so this is
  a suspicion, not a measurement). Before trusting a row, check what else is
  running and whether the laptop is on battery or a power-saving profile.
- **Short jobs get overestimated, long jobs underestimated.** In the table above,
  installs, cooks and pushes beat the estimate by 2x or more, while the long suite
  blew past it. Give a range, not a point.

Versions

The database has no other skills named runtime-estimate.

Database snapshot: 13.11.2026 · package version 10097bff5a6e (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

  • 96running-long-commands
    Runs a command that takes over a minute as a background command with its own log and exit code, plus the watch_run tool, so the session wakes once. Use when starting or planning a build, test suite, benchmark or any run expected to pass a minute.
  • 96measure
    Run the project's full test suite, time it, and record the run in eng-kit (local only). Use when the person asks to measure or benchmark the full suite.
  • 100test-speed
    Finds and fixes a slow test, check, or CI gate while keeping its coverage identical: baselines the wall clock, attributes it to a measured bottleneck, applies one change at a time, and verifies the same counts. Use when the local check or unit suite is slow, when CI takes too…
  • 82task-estimator
    Estimate how long a coding task will take, using the user's own measured history instead of intuition. Use this skill whenever someone asks for an estimate, an ETA, a timeline or a deadline for a feature, bug, refactor, migration, script or investigation — "how long will this…
  • 100doncheli-tea
    Run the full autonomous test suite end-to-end and report results. Activate when user mentions "test end to end", "autonomous testing", "run all tests", "full test run", "E2E tests", "test suite".
  • 100eta
    Estimate how long a piece of Claude Code work will really take — agent time vs the user's time, a range, the biggest risk, and speed-ups. Use when the user asks "how long will this take", wants an ETA or time estimate for a feature or build, or passes a plan file to estimate.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.