Skip to content
Skills Library
DevOps & cloud · Automation

skipbox-github-runners

/skipbox-github-runners

Moves GitHub Actions jobs to Skipbox: cheap, fast GitHub Actions runners with unlimited minutes for a flat monthly price. Use when the user asks to make GitHub Actions cheaper or faster, hits a GitHub Actions bill, budget or spending-limit stop, wants flat-price or unlimited-minute runners, wants CI that can run all day (coding agents, end-to-end tests), or mentions Skipbox or the runs-on labels skipbox, skipbox-4x8, skipbox-8x16 or skipbox-16x32. Covers choosing which jobs to move, the one-line runs-on change, sizes, what the runner image has, concurrency, and fixing a job that fails or stays

Repository
skills ↗
Licence
MIT
Last repository change
12.11.2026

Assessment and security

95/ 100Class: good
Format20 / 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
3
Scripts
0
HTML comments
0
URLs in SKILL.md
11
Deprecation

No signals detected. Repository changed on 12.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

Moves GitHub Actions jobs to Skipbox: cheap, fast GitHub Actions runners with unlimited minutes for a flat monthly price. Use when the user asks to make GitHub Actions cheaper or faster, hits a GitHub Actions bill, budget or spending-limit stop, wants flat-price or unlimited-minute runners, wants CI that can run all day (coding agents, end-to-end tests), or mentions Skipbox or the runs-on labels skipbox, skipbox-4x8, skipbox-8x16 or skipbox-16x32. Covers choosing which jobs to move, the one-line runs-on change, sizes, what the runner image has, concurrency, and fixing a job that fails or stays

Original author description

Moves GitHub Actions jobs to Skipbox: cheap, fast GitHub Actions runners with unlimited minutes for a flat monthly price. Use when the user asks to make GitHub Actions cheaper or faster, hits a GitHub Actions bill, budget or spending-limit stop, wants flat-price or unlimited-minute runners, wants CI that can run all day (coding agents, end-to-end tests), or mentions Skipbox or the runs-on labels skipbox, skipbox-4x8, skipbox-8x16 or skipbox-16x32. Covers choosing which jobs to move, the one-line runs-on change, sizes, what the runner image has, concurrency, and fixing a job that fails or stays

How it works

  1. What it runs
  2. Steps
  3. How many jobs run at once
  4. When a job fails or doesn't start
  5. Switch back
  6. When Skipbox is not the right answer
Original SKILL.md headings · 154 lines, 955 words
SKILL.md preview
---
name: skipbox-github-runners
description: >
  Moves GitHub Actions jobs to Skipbox: cheap, fast GitHub Actions runners with unlimited
  minutes for a flat monthly price. Use when the user asks to make GitHub Actions cheaper
  or faster, hits a GitHub Actions bill, budget or spending-limit stop, wants flat-price or
  unlimited-minute runners, wants CI that can run all day (coding agents, end-to-end tests),
  or mentions Skipbox or the runs-on labels skipbox, skipbox-4x8, skipbox-8x16 or
  skipbox-16x32. Covers choosing which jobs to move, the one-line runs-on change, sizes,
  what the runner image has, concurrency, and fixing a job that fails or stays queued.
---

# Skipbox GitHub Actions runners

Skipbox runs a GitHub account's Actions jobs on runners it operates. The price is flat per
month and minutes are unlimited. Moving a job is one line: change its `runs-on` label.
Moving it back is the same line.

Prices, plans and the trial change. Never state them from memory: read
https://skipbox.dev/pricing.md and quote from it. Every docs page is plain Markdown at
`https://docs.skipbox.dev/<page>.md` (index: https://docs.skipbox.dev/llms.txt).

## What it runs

- Private repositories of a GitHub organization or a personal account. A public
  repository's job is refused: leave those on GitHub's runners.
- Linux x64 (Ubuntu 24.04) only. Leave macOS, Windows and Arm jobs where they are.
- Jobs up to 6 hours.

## Steps

### 1. Find the jobs worth moving

List the workflows and what each job runs on:

```bash
grep -rn "runs-on:" .github/workflows/
```

Move jobs whose `runs-on` is a GitHub-hosted Linux x64 label (`ubuntu-latest`,
`ubuntu-24.04`, `ubuntu-22.04`, or a larger-runner label). Skip any job on `macos-*`,
`windows-*` or `*-arm`, and matrix entries that expand to those.

To see which jobs cost the most first, the user can open
https://skipbox.dev/tools/github-actions-cost (it prices the account's last 30 days of
jobs), or you can list recent run durations:

```bash
gh run list --limit 50 --json workflowName,createdAt,updatedAt,conclusion
```

### 2. The user installs the app (you cannot do this step)

Ask the user to open https://skipbox.dev, sign in with GitHub and install the app on the
account that owns the repository:

- an organization: **Skipbox CI** (an owner installs it)
- a personal account: **Skipbox (personal)**

The free trial needs no card and starts at the first job, not at install. Skipbox never
edits or pushes workflows: the `runs-on` change is yours to make in a pull request. Every
permission each app asks for, and why, is at https://docs.skipbox.dev/permissions.md.

### 3. Change `runs-on`

Start with one job, so the first run shows whether anything is missing.

```yaml
jobs:
  test:
    runs-on: skipbox   # was: ubuntu-latest
```

Labels (check https://docs.skipbox.dev/labels.md for the current list):

| Label | vCPU | Memory | Runs on |
|---|---|---|---|
| `skipbox` (same as `skipbox-4x8`) | 4 | 8 GB | Trial and every plan |
| `skipbox-8x16` | 8 | 16 GB | Plan M or L |
| `skipbox-16x32` | 16 | 32 GB | Plan L |

During the trial use `skipbox`. Use one size label per job. A label that isn't in this
table (for example `skipbox-large`) is not a Skipbox job: GitHub keeps it queued.

Keep a matrix job's other operating systems on GitHub's runners:

```yaml
runs-on: ${{ matrix.os == 'ubuntu-latest' && 'skipbox' || matrix.os }}
```

### 4. Add tools the image doesn't have

Skipbox's image is smaller than GitHub's `ubuntu-latest`. It has Docker, git,
build-essential, jq, curl, unzip, Node.js and Python, and the job runs as `runner` with
passwordless `sudo` (current versions: https://docs.skipbox.dev/runner-image.md). Before
the first run, read the job's steps and add a setup action for anything else it calls:

```yaml
- uses: actions/setup-java@v4
  with: { distribution: temurin, java-version: "21" }
- uses: actions/setup-go@v5
  with: { go-version: stable }
- run: sudo apt-get update && sudo apt-get install -y postgresql-client
```

### 5. Use the caches that stay

A plan comes with a machine kept for the account between jobs, so Docker images and
layers, package caches and the tool cache are still on disk at the next job. Nothing
needs configuring for that, with one exception: `docker/setup-buildx-action`'s default
builder starts empty in every job. To build from the machine's own layer cache, set

```yaml
- uses: docker/setup-buildx-action@v3
  with:
    driver: docker
```

Existing `actions/cache` steps keep working and can stay.

### 6. Commit, push, check

Open a pull request with the change. After the first run:

```bash
gh run watch
```

The account's page on skipbox.dev shows each job, how long it took, and the reason for
any job that didn't run.

## How many jobs run at once

A plan limits how many jobs run at once, never minutes. Jobs run at once while they fit
in the vCPU of all the account's plans added together, and an account can hold any number
of plans in any mix. A job that doesn't fit waits for a running one to end; waiting adds
nothing to the bill. If the user's pull requests start many jobs at once, say so and
point to https://docs.skipbox.dev/concurrency.md so they can pick the plans that fit.

## When a job fails or doesn't start

| What you see | Do this |
|---|---|
| `command not found` | Add the tool's setup action or `sudo apt-get install -y` (step 4) |
| The job stays queued | Check the label's spelling, that the app is installed and may use this repository, and that the repository is private. The account's page gives the reason. https://docs.skipbox.dev/job-queued.md |
| "Needs a larger plan" | Use `skipbox`, or the user adds a plan of that size |
| A step that sends mail on TCP 25 times out | Port 25 is blocked: use the mail provider's HTTP API |
| A service that allows only listed IP addresses refuses the job | Skipbox has no fixed outbound address: keep that job on GitHub's runners |
| Docker Hub rate limit | Add `docker/login-action` before pulling |
| Needs macOS, Windows or Arm | Keep that job on GitHub's runners |

More: https://docs.skipbox.dev/migration.md

## Switch back

Set `runs-on` back to its old value and commit. Skipbox changed nothing else in the
repository.

## When Skipbox is not the right answer

Say so plainly when it applies: public repositories, macOS, Windows, Arm or GPU jobs,
jobs longer than 6 hours, and jobs that need a fixed outbound IP address.

Support: hello@skipbox.dev
Files in this package (3)
  • LICENSE 1 KB
  • README.md 2 KB
  • SKILL.md 6 KB

Versions

RepositoryScoreLicence
This page · skipbox-dev/skills95MIT
skipbox-dev/skills100MIT

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

  • 100adopt-ec2-runners
    Moves a repository's GitHub Actions jobs onto ec2-runners by choosing ec2 or microvm labels and sizes for each job. Use when migrating workflows from GitHub-hosted or other self-hosted runners to ec2-runners, or sizing a job's runs-on labels.
  • 100depot-github-runners
    Configures Depot-managed GitHub Actions runners as a drop-in replacement for GitHub-hosted runners. Use when setting up or migrating GitHub Actions workflows to use Depot runners, choosing runner sizes (CPU/RAM), configuring runs-on labels, setting up ARM or Windows or macOS…
  • 100actions
    Create and configure GitHub Actions. Use when building custom actions, setting up runners, implementing security practices, or publishing to the marketplace.
  • 100github-actions-test-jobs
    Use whenever the task is to run tests in GitHub Actions: a test workflow on pull requests, matrix builds across OS and runtime versions, splitting a suite across parallel runners, service containers such as Postgres or Redis, uploading JUnit reports, and trigger filters.
  • 100github-actions
    GitHub Actions CI/CD. Covers workflows, jobs, and deployment. Use for automating builds, tests, and deployments. USE WHEN: user mentions "github actions", "workflow", "ci/cd", ".github/workflows", "actions/checkout", "github workflow", asks about "automate tests", "deploy on…
  • 100relayrunner-route-jobs
    Move a repo's GitHub Actions jobs onto RelayRunner, so they run on the user's own machines or a hosted runner provider with GitHub-hosted runners as the fallback. Use when the user wants to route jobs, change `runs-on` to RelayRunner, add a relay job, cut GitHub Actions minutes…

Feedback and reports

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