# CI per agenti di coding IA: quando l'agente aspetta 20 minuti GitHub Actions a ogni giro

> Il giro di un agente di coding IA è push, attesa della CI, lettura dell'errore, correzione, nuovo push, quindi una pipeline da 20 minuti costa 100 minuti in cinque correzioni. Accorcia l'attesa in quest'ordine: controlli che l'agente esegue prima del push, esecuzioni superate annullate, controlli veloci per primi, solo i test interessati, e una macchina che conserva le cache tra un job e l'altro. Skipbox esegue quei job sulla tua macchina da $39 al mese, minuti illimitati.

Il giro di un agente di coding IA è push, attesa della CI, lettura dell'errore, correzione, nuovo push. Una pipeline da 20 minuti per cinque correzioni sono 100 minuti di attesa, e gli agenti fanno più push delle persone: il volume di job di CI di Anthropic è cresciuto di 25 volte in sei mesi. Accorcia l'attesa in quest'ordine. Fai eseguire all'agente lint, controlli dei tipi e test unitari interessati prima del push. Annulla le esecuzioni più vecchie di una pull request quando arriva un nuovo push. Metti i controlli veloci in un job tutto loro, così un errore torna in un minuto o due. Esegui solo i test interessati dalla modifica. Poi taglia la preparazione che ogni job ripete su una VM nuova: su una macchina che conserva i layer Docker, le cache dei pacchetti e gli output delle build tra un job e l'altro, il job di CI di astro è passato da 528 s su GitHub a 30 s su Skipbox.

Skipbox esegue i tuoi job sulla macchina del tuo account, che conserva quello stato tra un job e l'altro. Cambi una riga, `runs-on: skipbox`, a un prezzo fisso di $39 al mese con minuti illimitati: un agente che fa venti push in un pomeriggio non aggiunge niente alla fattura, e un budget di GitHub non ferma mai i suoi job.

- La CI di astro: 528 s su GitHub, 30 s su Skipbox, con gli output delle build conservati dall'ultimo job
- Minuti illimitati: ogni push dell'agente, ogni correzione dopo una review e ogni riesecuzione sono dentro il prezzo fisso
- Layer Docker, cache dei pacchetti e tool restano sulla tua macchina, quindi ogni giro salta la reinstallazione

**GitHub Actions a prezzo fisso, minuti illimitati** Skipbox esegue i tuoi job di GitHub Actions su una macchina dedicata tutta tua: $39 al mese, per quanti minuti tu esegua. I layer Docker e le cache delle dipendenze restano tra un job e l'altro, così il job successivo parte subito.

Un runner da 4 vCPU, 20.000 minuti al mese: GitHub $222 → Skipbox $39. Risparmi $183 ogni mese.

Per passare basta una riga: `runs-on: skipbox`.

[Inizia la prova gratuita di 7 giorni](https://app.skipbox.dev/sign-in?ref=g-ci-for-ai-coding-agents-it)

## Perché i giri degli agenti fanno della CI il collo di bottiglia

Dall'[articolo di Anthropic su come ha scalato la test impact analysis](https://claude.com/resources/articles/agentic-coding-is-straining-ci-heres-how-we-scaled-test-impact-analysis-at-anthropic): "Our CI job volume increased 25x over 6 months." I due motivi che dà: Claude "prefers smaller, more granular PRs", e gli agenti "push overnight and on weekends". Una persona raggruppa le correzioni; un agente fa push di ognuna e aspetta. Ogni minuto della pipeline si paga una volta per giro.

## 1. Prendi prima del push quello che puoi

L'esecuzione di CI più veloce è quella che non fallisce. Dai all'agente gli stessi comandi di lint, controllo dei tipi e test unitari che esegue la CI, e fagli eseguire sui file che ha cambiato prima di ogni push. Così un refuso costa secondi sulla sua macchina, non un giro da 20 minuti.

## 2. Annulla le esecuzioni che un nuovo push sostituisce

Un agente che fa push di una correzione mentre l'ultima esecuzione è ancora in corso lascia due esecuzioni sulla stessa pull request. Annulla la più vecchia ([concurrency](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency)):

```yaml
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true
```

`github.head_ref` esiste solo sulle pull request, quindi ogni push su `main` ha il suo gruppo e non viene mai annullato.

## 3. Riporta prima i controlli veloci

Metti lint e controlli dei tipi in un job tutto loro, senza `needs:` davanti, e le suite lente in altri. L'agente legge il primo errore appena arriva, invece che dopo il job E2E.

## 4. Esegui solo quello che la modifica tocca

La risposta di Anthropic alle 25 volte è stata un servizio di test impact analysis che "determines which tests run on each change". Quasi tutti i repository possono iniziare più in piccolo: `turbo run test --affected` in un Turborepo ([la guida alla CI di Turborepo](https://turborepo.dev/docs/crafting-your-repository/constructing-ci)), filtri sui percorsi per i workflow che contano solo per una cartella, e un'esecuzione completa su `main` dopo il merge per prendere quello che la selezione ha perso.

## 5. Smetti di ricostruire lo stesso stato a ogni giro

Sui runner ospitati da GitHub ogni job parte su una VM nuova: la toolchain si configura di nuovo, la cache delle dipendenze si scarica e si scompatta, i layer Docker si scaricano o si ricostruiscono, e la build parte da zero. Su cento giri di un agente al giorno, quella preparazione è gran parte dell'attesa. Un runner che conserva il disco tra un job e l'altro ha già tutto lì.

Dalle [nostre esecuzioni di progetti reali](https://skipbox.dev/it/guides/rust-cache-slow-rust-ci), con i workflow invariati:

| Progetto | GitHub (repository pubblico, 4 vCPU, 16 GB) | Macchina Skipbox (4 vCPU) |
|---|---|---|
| astro (pnpm, Turborepo) | 528 s | **30 s** |
| tauri (Rust) | 246 s | **53 s** |
| ripgrep (Rust) | 200 s | **40 s** |

## 6. Pianifica i job simultanei, non solo i minuti

Diversi agenti che fanno push di una pull request con una matrice ciascuno arrivano al limite di concorrenza di GitHub per i runner standard: 20 job insieme su GitHub Free, 40 su Pro, 60 su Team, 500 su Enterprise ([limiti](https://docs.github.com/en/actions/reference/limits)). Oltre, i job vanno in coda. Con una fattura al minuto ognuno di quei job costa anche; un limite di spesa che finisce li ferma con "The job was not started because recent account payments have failed or your spending limit needs to be increased" ([cosa fare](https://skipbox.dev/it/guides/github-actions-spending-limit-job-not-started)).

## Cosa fa Skipbox per la CI degli agenti

Ogni piano include la macchina del tuo account, che resta tra un job e l'altro:

- **Lo stato resta.** Immagini, layer e cache di build di Docker; `~/.npm`, lo store di pnpm, `~/.cache`, le cache di Go, Gradle, Maven e Cargo; i tool che `setup-*` ha installato. Resta anche il checkout, con il `target/` di Cargo e, per i progetti turbo 2, la `.turbo` alla radice, così la build successiva riparte da dove si era fermata la precedente.
- **I minuti sono illimitati**, e un budget o un limite di spesa di GitHub non ferma mai un job di Skipbox.
- **I job simultanei sono le vCPU dei piani.** I job girano insieme finché stanno nelle vCPU dei piani dell'account; gli altri aspettano il loro turno, e la pagina dell'account mostra quanti aspettano e per quanto. Un S esegue un job a 4 vCPU alla volta; i piani si sommano in qualsiasi combinazione.
- **Anche il job dell'agente può girare lì:** imposta il suo `runs-on` su `skipbox`.

| Etichetta | Macchina | Piano |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 al mese |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 al mese |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 al mese |

A 20.000 minuti al mese su 4 vCPU, GitHub fattura $222; Skipbox S costa $39. A 30.000 minuti, $342.

## Basta una riga

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

1. Accedi a Skipbox con GitHub.
2. Installa la GitHub App di Skipbox e scegli i repository.
3. Cambia `runs-on` e fai push.

## Sicurezza

- La macchina è solo del tuo account. Nessun job di altre aziende gira su di essa.
- Dopo ogni job vengono cancellati le credenziali, i processi e i container del runner, e anche le credenziali git e i file non tracciati di un checkout conservato. “VM nuova per ogni job” dà invece a ogni job una macchina nuova.
- Il codice di chi non ha accesso in scrittura (come le pull request dai fork) gira su una VM nuova che legge le tue cache ma non le può modificare.

I dettagli sono in [come vengono isolati i job](https://docs.skipbox.dev/it/isolation).

## Provalo sul job che il tuo agente aspetta

La prova è gratuita per 7 giorni o 3000 minuti di job, quello che arriva prima, e non chiede la carta. Sposta il job che il tuo agente aspetta su `runs-on: skipbox`, lascia che l'agente faccia due push e confronta la seconda esecuzione con quella di GitHub.

## Domande frequenti

### Il mio agente di coding apre una PR, aspetta 20 minuti la CI, corregge e aspetta di nuovo. Come rendo la CI abbastanza veloce per i giri di un agente?

Accorcia quello che l'agente aspetta, in quest'ordine. Fagli eseguire lint, controlli dei tipi e i test unitari interessati prima del push, così la CI non è il primo posto in cui salta fuori un refuso. Annulla le esecuzioni più vecchie di una pull request quando arriva un nuovo push (concurrency con cancel-in-progress). Metti i controlli veloci in un job a parte, così l'agente legge un errore in un minuto o due. Esegui solo i test interessati dalla modifica. Poi togli la preparazione che ogni job ripete: su una macchina che conserva i layer Docker, le cache dei pacchetti e gli output delle build tra un job e l'altro, la CI di astro è passata da 528 s su GitHub a 30 s su Skipbox.

### Quanta CI in più causano gli agenti IA?

Anthropic ha scritto che il suo volume di job di CI è cresciuto di 25 volte in 6 mesi, perché Claude preferisce pull request più piccole e granulari e gli agenti fanno push di notte e nel fine settimana. Ognuno di quei push esegue di nuovo tutto il workflow, a meno che il workflow non lo annulli, lo salti o lo restringa.

### Qual è la configurazione di CI migliore per un team in cui la maggior parte delle PR la scrivono agenti IA?

Una che risponde in fretta all'agente e non fattura a ogni push: un job veloce per lint e controlli dei tipi che riporta per primo, le suite lente dopo, le esecuzioni più vecchie di una pull request annullate, solo i test interessati, e runner che conservano le cache tra un job e l'altro. Skipbox dà a ogni account la sua macchina a un prezzo fisso con minuti illimitati; il numero di job che esegue insieme sono le vCPU dei piani dell'account.

### Gli agenti arrivano ai limiti di concorrenza di GitHub?

Possono. I runner standard ospitati da GitHub eseguono al massimo 20 job insieme su GitHub Free, 40 su Pro, 60 su Team e 500 su Enterprise; gli altri vanno in coda. Diversi agenti che fanno push di pull request con una matrice ciascuno ci arrivano presto. Su Skipbox i job girano insieme finché stanno nelle vCPU dei piani dell'account e gli altri aspettano il loro turno, quindi un team con diversi agenti al lavoro insieme tiene diversi piani o uno più grande.

### Il job dell'agente può girare su Skipbox?

Sì. Ogni job Linux sceglie la sua macchina con runs-on, compreso il job che esegue l'action di Claude Code. Impostalo su skipbox e gira sulla stessa macchina della tua CI.

### Quanto costa provarlo?

Niente. La prova dura 7 giorni o 3000 minuti di job, quello che arriva prima, senza carta, fino a 4 job alla volta, ognuno su 4 vCPU. Sposta il job che l'agente aspetta su runs-on: skipbox e cronometra la seconda esecuzione.

Aggiornata il giorno 2026-11-16 · https://skipbox.dev/it/guides/ci-for-ai-coding-agents
