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. 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.
Perché i giri degli agenti fanno della CI il collo di bottiglia
Dall'articolo di Anthropic su come ha scalato la test impact analysis: "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):
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), 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, 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). 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).
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 chesetup-*ha installato. Resta anche il checkout, con iltarget/di Cargo e, per i progetti turbo 2, la.turboalla 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-onsuskipbox.
| 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
jobs:
checks:
runs-on: skipbox # was ubuntu-latest
- Accedi a Skipbox con GitHub.
- Installa la GitHub App di Skipbox e scegli i repository.
- Cambia
runs-one 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.
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 16 novembre 2026