---
name: move-to-checklane
description: Move GitHub Actions jobs onto Checklane's runners. Lists every job a repository ran with the runner it asked for and how long it took, says which jobs can move and which stay (macOS, Windows, arm64, GPU, special self-hosted machines), picks a Checklane size for each, changes runs-on in one pull request, and compares the moved jobs after a few days. Use when someone wants to try Checklane, says "move our CI to Checklane", "switch runs-on to checklane", or asks which of their jobs would run there.
---

# Move to Checklane

Checklane runs GitHub Actions jobs on its own bare-metal servers, a fresh Linux x64 machine per job, billed by the second. A job moves by changing its `runs-on` label and moves back by changing it again. Nothing else in the workflow changes: actions, secrets, `services:` containers and caches work as on GitHub's runners, because the job still runs GitHub's own runner software.

Your job is to move what moves cleanly, leave the rest where it is, say why for each job, and show afterwards how the moved jobs did. Don't oversell: if a job is better where it is, say so.

## 1. Check the GitHub App is installed

Jobs only start on Checklane once the Checklane GitHub App is installed on the account that owns the repository and the organization has a card or credit. Without it, a job asking for `checklane` waits in GitHub's queue and never starts.

```bash
gh api user/installations --jq '.installations[] | select(.app_slug == "checklane") | .account.login'
```

This only works with a personal token: signed in to `gh` through another GitHub App, it lists that app's installations and never shows Checklane. It also can't see whether the installation covers this repository, or whether there's a card. So when the owner isn't listed, or the check can't tell, ask the user: they can see it in the Checklane dashboard. If it isn't installed, send them to https://checklane.sh and stop.

## 2. List the jobs

Run the script next to this file. It needs `gh` signed in with read access, and `jq`.

```bash
bash <skill-dir>/inventory.sh OWNER/REPO --days 30
```

It reads GitHub's record of each job, so matrix legs and labels set by expressions show as they ran. Each row has the job, its workflow file, how many runs, its p50 and p90 time (of successful runs), its minutes, the labels it last ran on, a verdict and a suggested size. Under the table it says how many vCPUs one run would start at once, and lists the workflows it read no runs of: deploys, releases and manual workflows often run too rarely to show up, and you account for each of them by reading the file.

It prints the dates its runs cover. On a busy repository GitHub lists only the last 1000 runs, which may be days, not the month asked for. It writes everything to `.checklane-move/` in the current directory; add that to `.git/info/exclude` so it never gets committed.

Verdicts:

- **moves**: a Linux x64 runner (GitHub's `ubuntu-*`, a larger GitHub runner, or another provider's Linux x64 label).
- **moves (check Ubuntu 24.04)**: it asks for `ubuntu-20.04` or `ubuntu-22.04`. Checklane's machines are Ubuntu 24.04. Most jobs don't care; a job that installs a distro-specific package or a pinned toolchain might. Read its steps before moving it.
- **stays (macOS / Windows / arm64 / GPU)**: Checklane runs Linux x64 only. Leave these alone.
- **ask (reusable workflow)**: the job comes from a workflow it calls (its name is `caller / job`). Its `runs-on` is in the called workflow, maybe in another repository and pinned to a commit. Change it there, or leave it.
- **ask (self-hosted)**: a team's own machine. It may hold hardware, network access or credentials a fresh machine doesn't have. Ask the user before moving it.
- **ask (unknown label)** or **(no labels)**: read the workflow and ask.
- **on Checklane**: already moved.

## 3. Read the workflows

For each job that moves, open its workflow and check:

- **Required checks, first.** Read them before anything else: `gh api repos/OWNER/REPO/rulesets` (then each ruleset by id) and `gh api repos/OWNER/REPO/branches/BRANCH/protection`. A job's check name often comes from its matrix values, as in `build (ubuntu-latest)`.
- **How `runs-on` is written.** A plain label is one line to change. A list (`[self-hosted, linux, big]`) becomes the one Checklane label. A label from a variable or input (`${{ inputs.runner }}`) changes where it's set; say where.
- **Matrices.** Never change the matrix's values: they name the checks (renaming a required one blocks every merge) and steps read them (`if: matrix.os == 'ubuntu-latest'`). Map the label in `runs-on` instead, so only the Linux leg moves:

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

- **Generated workflows.** A file that says it's generated ("DO NOT EDIT", a `.lock.yml`, a header naming a tool) is rebuilt from its source. Change the source and rebuild, or leave it.
- **Network allowlists.** A job that reaches a database, registry or cloud account that only lets in GitHub's IP ranges or a fixed IP will be refused from Checklane's machines. Look for deploys, `aws`/`gcloud`/`az` steps and private registries, and ask the user whether anything allowlists IPs. OIDC (`id-token: write`) itself works.
- **Things the machine must already have.** Jobs that assume a tool only GitHub's image has (rare: most come from setup actions or apt) may need a setup step. Checklane's machines have Git, Docker with Buildx and Compose, the GitHub CLI, `jq`, `yq`, the usual build tools, Node, Python, Go and Java 17 and 21 in the tool cache, Maven, Gradle, and the Android SDK with the emulator but no system images.
- **Workflow linters.** If the repository runs actionlint, its config (`.github/actionlint.yaml`) needs the Checklane labels under `self-hosted-runner: labels:`, or it fails on them.
- **Jobs for agents.** `copilot-setup-steps.yml` sets up the machine GitHub's Copilot coding agent works on. Leave it unless the user asks.
- **Caches.** Checklane's machines set `ImageOS=ubuntu24`, as GitHub's Ubuntu 24.04 runners do, so cache keys built from it still match.

## 4. Pick sizes

The script suggests as many vCPUs as the job has today, rounded up to a Checklane size. GitHub's standard Linux runner has 2 vCPUs on private repositories and 4 on public ones.

| Label | vCPUs | Memory |
|---|---|---|
| `checklane-2vcpu` | 2 | 8 GB |
| `checklane` or `checklane-4vcpu` | 4 | 16 GB |
| `checklane-8vcpu` | 8 | 32 GB |
| `checklane-16vcpu` | 16 | 64 GB |

The script already picks `checklane-2vcpu` for a job under 90 seconds on 4 vCPUs or fewer: that's mostly checkout and setup. Adjust from there:

- A long job that the team waits on is worth trying one size up. It's billed by the vCPU-minute, so a job that finishes in half the time on twice the vCPUs costs the same. A job isn't waited on when something slower runs beside it: if a Windows leg takes 6 minutes and stays on GitHub, a bigger machine for the 3-minute Linux leg changes nothing.
- One size for every leg of a matrix keeps the YAML simple. Size legs apart only when it's worth an expression.
- A job that ran out of memory before needs at least the memory it had.
- The plan caps the biggest machine: 4 vCPUs on Pay as you go, 16 on Pro and Team. A job asking for more runs on the biggest the plan allows. The plan also caps how many vCPUs run at once (6, 16 and 64); past that, jobs wait. The script's "one run would start up to N vCPUs" line says when a single push goes past it.

Build a table for the user: job, what it runs on today, the Checklane label, and why. Include the jobs that stay and why, including ones the script said move but you decided against. Let them change it before you edit.

## Before you move anything, say what it costs

- **Public repositories.** GitHub's standard runners are free on public repositories. Moving them means paying for something that's free today. Say so, and ask whether the user is after speed. On a public repository, a pull request from a fork also runs on Checklane and is billed to the organization: suggest GitHub's setting that asks for approval before running workflows from outside contributors (Settings → Actions → General).
- **Small, rare jobs.** A seven-second scheduled job gains nothing from moving. Leave such jobs where they are unless the user wants everything in one place.

## 5. Change runs-on

Make one pull request per repository that changes only `runs-on` (and the actionlint config if there is one). Add a short comment above a changed line only where the reason isn't obvious, such as a matrix where only Linux moved. Follow the repository's pull request template and contribution rules. The description lists:

- each job that moved, from what to what;
- each job that stayed, and why;
- that going back is the same line changed back.

The pull request's own checks run on Checklane, so the user sees how those jobs do before merging. That covers jobs triggered by `pull_request` that the change's files don't filter out. Jobs that run on push, on a schedule, by hand or on issues run on Checklane only after the merge: name them, so the user watches their first runs. Nothing changes on the default branch until it's merged. Commit and open it only when the user says so.

## 6. Compare

A few days after the merge, with ten runs or more of each moved job, compare the same jobs before and after: their p50 and p90 from GitHub's job records (the `make-ci-more-efficient` skill's `measure.sh` reads them), on first attempts only. Report each job's time before and after, and anything that failed on Checklane and not before, with the run link. If a job did worse, say so, and suggest a size up or moving it back.
