The framing I want to push back on is the one that treats a lightweight developer environment as a purely technical optimisation. Smaller images, faster cold starts, less memory — these are presented as wins on a latency chart, and the carbon consequences are mentioned, if at all, as a footnote.
I think that is backwards, and I think the technical argument gets stronger once you make the environmental one explicit. Because the same decision — do less work, on less hardware, for less time — turns out to be the same decision in both frames.
The arithmetic nobody does
Consider a typical engineering organisation. Say two hundred engineers, each pushing twenty commits a day, each commit triggering a pipeline of twenty minutes on a metered runner.
That is two hundred times twenty times twenty minutes: roughly thirteen thousand runner hours per day, or around forty thousand per month, of continuously running machines whose entire purpose is to produce a boolean.
Now, a very large share of those jobs are the same job. Linting the same repository. Running the same unit tests. Building the same image. The pipeline is a factory that manufactures a green or a red, and it is manufacturing an enormous volume of the exact same green.
Move the fast checks to the developer's machine — checks that are fast, deterministic, and need no shared state — and you can remove the majority of that forty thousand hours. Not by cancelling work, but by doing it where the person who needs the answer already is.
The compute saving is real and it is large. But the carbon consequence is the same forty thousand hours, just not spent in a data centre. The laptop was already on. The developer's laptop is already using its power budget for the work they were doing anyway. You are not moving a marginal cost to a zero cost; you are moving a cost from new computation to already-committed computation.
Containers make the trade explicit
This is where the container count stops being a trivia point and starts being the actual decision.
A CI runner that pulls a 900 MB image to run a linter has done roughly two orders of magnitude more I/O than the linter needed. That I/O is not free at the disk, and it is not free in the time it takes before your job can start, and it is not free in the registry bandwidth it consumed. A 90 MB image for the same job is a different system, not a smaller one.
The same arithmetic applies to the developer's machine. I measured the mock service rewrite directly: four containers at 250 MB and 7.9% idle CPU, against one process at 50 MB and 0.0% idle CPU.
Both were running on the same laptop, at the same time, doing the same work. The 1.8 GB and 22 MB figures I used to quote were from a different experiment and are not comparable — which is, in fairness, exactly why published measurements should say which experiment they came from. These ones do.
The laptop version is the one that gets used. The team that ran a mock on a shared server queued for it. The team that ran a 50 MB process on every laptop just ran it. Same features, completely different total footprint, and the total footprint is the thing that determines how much infrastructure you need at all.
The uncomfortable corollary
If the energy cost of developer tooling tracks the amount of redundant compute, then the industry's default of running everything remotely is the expensive choice, and it is expensive on both axes at once.
This is not a new observation. But it is usually stated in a way that sounds like a sacrifice — 'you have to give up the shared environment to be greener'. That framing is wrong. The local-first path gives you better latency, better debuggability, lower cloud spend and lower total energy. There is no trade-off to make. The trade-off was already being made, silently, by not moving the work.
What I actually do about it
I keep a simple rule for any tooling decision: prefer the option that does not require new computation over the option that requires a smaller amount of new computation.
It shows up concretely:
- No dependencies. Every dependency is a package to install, audit and keep out of the advisories. Zero is not asceticism; it is a decision about who audits it.
- One process instead of four. Four runtimes cost four times the memory and four times the startup, for the same mocks.
- Idle means idle. 0.0% against 7.9%. A mock that answers a request and then stops computing is not a battery drain.
- The footprint is a build gate. The build fails above 100 MB, 5 seconds of startup or 1% idle CPU. A number in a README is a claim; a number in a test is a constraint.
- The gate runs locally, offline, with no runner. The laptop was already on.
None of this is virtue signalling. It is that the local option is nearly always the better engineering option, and once you notice that, the environmental argument turns out to be a consequence rather than a constraint.
The thing I would like to see
A build system where the default is local, deterministic, and offline, and remote execution is the exception you reach for deliberately rather than the substrate everything runs on.
We have spent a decade moving compute into the data centre and treating that as neutral. It was never neutral — it was a decision about where the energy came from and who paid for it, made at a scale where nobody had to justify it.
The interesting part of the next decade is the tooling that makes the local option good enough that the remote option has to earn its place.
I have been building in that direction for a while now — CI Kit and api-mock-services are both attempts at it. If you are building in the same direction, I would genuinely like to read what you are doing.