I’m a solo engineer building Aisle Store, a software project that is still in stealth, with help from coding agents. I also work on Kenyan Poker. As agents opened and updated more branches, I noticed our GitHub Actions usage climbing. Earlier, Maestro and mobile automation had already taught me how quickly builds and device tests can add runner time.

My first instinct was to ask whether I needed more machines. The more useful question turned out to be: why is this small change running so much work?

The 24-minute check

A scheduler-only change was taking about 24 minutes to verify locally. That looked like a hardware problem, but it was really a routing problem. A broad path rule selected 65 checks, while still missing the scheduler tests that mattered for the change.

After tightening the selection rules and adding regression coverage for the routing itself, the targeted scheduler checks ran in 9.61 seconds, without booting a virtual machine. That is one measured, narrow case. It says nothing about the runtime of a full suite, browser tests, database integration, or a different change.

The lesson: a long run can mean “we need more compute,” but it can also mean “we are doing the wrong work.” I now want the verifier to show its plan before it starts: which base and commit it resolved, which checks it selected, and why.

What I considered

I looked at a few ways to reduce hosted CI spend:

  • Keep using GitHub-hosted runners. They are easy to operate and scale well. But parallel jobs still add up by their individual runner time, even when the wall-clock wait is short.
  • Self-host runners. This keeps the familiar GitHub workflow, but the owner takes on uptime, updates, isolation, and capacity. A laptop can serve a modest queue; it does not become a cloud runner fleet because it has free disk space.
  • Rent a VPS or a fleet. That buys capacity without buying hardware, but idle time, setup, teardown, and maintenance belong in the calculation.
  • Try a managed runner provider such as Blacksmith. It may suit compatible workloads, but I would verify current eligibility and compare real job durations before relying on advertised savings.
  • Run focused checks locally before publishing. For a solo engineer working with agents, this can avoid repeating broad checks on every intermediate update, provided the process is explicit and tied to the exact commit being considered.

I did not try to recreate GitHub’s runner fleet on my Mac. The objective is a lean local gate for the changes that can be checked reliably here, with deeper or infrastructure-dependent checks handled separately where they are still needed.

What the local gate does

The verifier plans checks against the proposed integration of a candidate branch with the current default branch. It reports the exact inputs and selected checks, runs them, and produces evidence tied to those inputs. A change from a remote coding agent can be handed off as a Git bundle, so the local verifier can check committed code without giving the agent a repository write credential.

For routine changes, the selector runs relevant fast checks. Unknown, broad, or high-risk changes take a deeper route. A result becomes stale if the commit or base changes, so the coordinator rechecks it before publishing or merging. Independent review and release requirements remain separate from test results.

This distinction matters: a local receipt is useful evidence, but it cannot make GitHub enforce a rule if the repository’s settings cannot enforce it. Access to publishing and merging still matters.

What I learned

  1. Measure job time, not just workflow counts. One workflow can launch several jobs, and their runner minutes accumulate.
  2. Inspect the selected plan. A broad selector can waste time and still miss the test you intended to run.
  3. Test the selector. Add cases proving both which checks run and which are deliberately skipped. Keep a conservative fallback for unfamiliar changes.
  4. Tie results to exact commits. A result from an older head or base should not approve newer code.
  5. Keep routine checks small and deeper checks available. The goal is a proportionate gate, not a green badge at any cost.
  6. Measure savings instead of assuming them. The faster scheduler check is real; a reduction in the final hosted bill has not yet been verified.

For a one-person engineering setup, the best CI strategy may be less about matching a large company’s infrastructure and more about making the smallest reliable check happen at the right point in the workflow. The time I saved came from fixing selection, not adding a machine.

This article was written with AI assistance and reviewed by me for factual accuracy. DEV’s AI-assisted content guidance asks authors to disclose that assistance. DEV AI disclosure guidance.

References: GitHub Actions billing · GitHub-hosted runners · Blacksmith pricing