Come lavoriamo con GitLab: l’IA prende in carico i ticket, corregge i bug e apre le merge request
Un’IA sa correggere un bug. Ma se due macchine individuano lo stesso difetto, chi se ne occupa? E chi decide se la correzione può entrare nel ramo principale?
Questo è il flusso che usiamo in produzione. Ogni attività nasce come issue di GitLab. L’IA sul computer di ciascun collega controlla periodicamente le attività assegnate, applica la correzione, la rivede e apre una merge request (MR). L’IA di chi fa la revisione può svolgere un controllo indipendente; a decidere il merge è una persona.
Il flusso a colpo d’occhio
Le linee continue indicano il percorso principale; quelle tratteggiate i riscontri, i cicli e i percorsi secondari. I colori distinguono cinque fasi: 🟡 nascita dell’attività → 🔵 centro di raccolta → 🟣 esecuzione da parte dell’IA → 🩵 revisione incrociata dell’IA → ⚪ revisione umana.

Le persone descrivono il problema, verificano il risultato e decidono il merge. Nel mezzo, gli agenti locali interrogano la coda, prendono in carico le issue, analizzano, correggono e rispondono.
Gli stati di un’attività
Usiamo le etichette GitLab come macchina a stati.

Il parametro labels di PUT /projects/:id/issues/:iid sostituisce l’intero insieme: occorre includere anche le etichette da mantenere. Le issue in lavorazione o in revisione hanno inoltre ai-doing-〈agent-id〉 o ai-reviewing-〈agent-id〉. Si vede così chi sta lavorando a cosa e se un agente è già occupato. ai-doing e ai-reviewing servono per le viste aggregate.
Cinque scelte progettuali
1. La issue è l’unica unità di lavoro
Avvisi, scansioni di sicurezza, controlli di qualità e richieste a voce diventano issue. Prima di aprirle chiariamo con l’IA locale i passaggi per riprodurre il problema, il comportamento atteso, il codice interessato e i criteri di accettazione. L’IA scrive cinque sezioni (problema, riproduzione, comportamento atteso, indizi e criteri di accettazione) e crea la issue tramite API:
curl -X POST -H "PRIVATE-TOKEN: $TOKEN" \
"https://<你的GitLab>/api/v4/projects/<项目ID>/issues" \
-d "title=修复 XX 问题" \
-d "labels=ai-task" \
-d "assignee_ids[]=<同事用户ID>" \
-d "description=<按上述模板>"
L’agente che la prende in carico non deve indovinare una soluzione da una frase: trova gli indizi e sa come verificare il risultato. Se il problema è già chiaro, apriamo direttamente la issue.
2. Identificare l’agente che prende in carico il lavoro
Le issue GitLab non dispongono di un blocco atomico. Due agenti possono prendere la stessa issue. In fase di configurazione assegniamo a ciascuno un’identità univoca <utente-GitLab>-<nome-breve-macchina>, ad esempio zhangsan-mbp, che l’agente registra in un’etichetta quando prende in carico il lavoro:
# 1) 占用检查:任一非空即不领新任务
curl ".../issues?labels=ai-doing-<agent-id>&state=opened"
curl ".../issues?labels=ai-reviewing-<agent-id>&state=opened"
# 2) 领取:打上带身份的 doing 标签
curl -X PUT ".../projects/<id>/issues/<iid>" -d "labels=ai-task,ai-doing,ai-doing-<agent-id>"
# 3) 回读确认无其他 agent 的 doing 标签;撞车则撤回自己的标签跳过本轮
Un agente può avere una sola attività aperta: se sta lavorando o aspetta una revisione, non ne prende altre. Il limite vale per agente e macchina, non per persona. Chi ha due computer può avere due identità e un’attività per ciascuna. Controllare prima e rileggere dopo riduce le collisioni, ma non rende atomica la sequenza di lettura e scrittura.
3. Nessuna MR senza autorevisione
Consegnare significa risolvere il problema senza crearne altri. Prima di aprire la MR l’agente rivede il proprio diff: logica, casi limite e gestione degli errori; copertura dei percorsi critici e superamento dell’intera suite; sicurezza (iniezioni, errori di autorizzazione, SSRF, deserializzazione); convenzioni del progetto; verifica puntuale dei criteri di accettazione.
La modifica introduce un problema nuovo? Esaminare ogni blocco del diff per capire se altera il comportamento esistente. Eseguire tutti i test, ripetere i passaggi di riproduzione e controllare i percorsi di chiamata correlati. Limitare il diff alla correzione; per i refactoring estranei aprire un’altra MR.
Correggere i problemi emersi prima di consegnare e riportare la conclusione nella issue. Senza traccia dell’autorevisione, la consegna non è completa.
4. Affidare una verifica indipendente all’IA di chi revisiona
L’autorevisione può trascurare ipotesi fatte durante l’implementazione. L’agente di chi revisiona interroga le issue con labels=ai-reviewing e controlla le MR associate cercando regressioni, effetti collaterali e problemi di sicurezza o prestazioni. Non dà per buona l’autorevisione: ogni dubbio diventa una discussione nella MR. L’agente autore corregge, risponde, riunisce le modifiche in un solo commit e ripete il push.
L’IA verifica correttezza, sicurezza, convenzioni e assenza di nuovi problemi; le scelte di prodotto e architettura spettano alle persone. La revisione incrociata non occupa il posto riservato all’attività dell’agente. Se non arriva risposta, subentra una persona perché un’IA non blocchi l’altra.
Nella pratica siamo passati dalla lettura riga per riga del diff alla consultazione dei risultati indipendenti, seguita da controlli a campione e decisione finale. Le revisioni richiedono molto meno tempo.
5. Aprire la MR insieme al push del ramo
Le opzioni di push di GitLab permettono di inviare il ramo e aprire la MR in un’unica operazione, autenticandosi con la chiave SSH locale:
git push origin ai/fix-42-xxx \
-o merge_request.create \
-o merge_request.target=<默认分支> \
-o merge_request.title="fix: ..." \
-o merge_request.description="Closes #42"
All’IA basta un token di lettura e scrittura delle issue limitato al repository centrale. Modifiche al codice, push e MR usano i permessi SSH della persona; non serve un altro token per il repository del codice. Se la issue è in A e il codice in B, usare Closes <group>/<repo-A>#42. Il merge nel ramo predefinito di B chiude la issue in A.
Sei problemi incontrati sul campo
La issue non si chiudeva dopo il merge. Closes #N ha effetto solo quando la modifica raggiunge il ramo predefinito del progetto. Se è master ma la MR punta al ramo d’integrazione develop, la issue si chiude quando la modifica arriva in master: non è un guasto del flusso.
Le etichette sparivano. labels sostituisce l’intero insieme. Al cambio di stato includere anche quelle che devono restare.
La cronologia si riempiva di piccoli commit. L’IA aggiungeva un commit per ogni giro di commenti. Usare reset --soft e amend per ricondurre le revisioni a un solo commit, quindi ripetere il push con push --force-with-lease.
Si accumulavano worktree orfani. Directory isolate e rami locali sopravvivevano alla chiusura. Usare .worktrees/<agent-id>-<numero-issue>-<nome-breve-repo>/; alla chiusura eseguire git worktree remove ed eliminare il ramo già integrato.
Un agente prendeva due attività. In un solo giro aveva raccolto due incarichi. Il controllo di occupazione e il limite di una sola attività devono essere regole vincolanti, non accordi verbali.
La shell non interattiva non vedeva il token. Il processo pianificato non trovava la variabile definita nella configurazione della shell. Eseguire il comando in modalità interattiva (per esempio con zsh -ic) oppure caricare esplicitamente la configurazione.
Lista di controllo per entrare nel gruppo di lavoro
• GitLab: abilitare le issue e usare una versione con opzioni di push, come le versioni recenti.
• Etichette: ai-task (disponibile), ai-doing (in corso/blocco), ai-reviewing (MR in revisione), oltre alle categorie del progetto.
• Un token di progetto condiviso: ambito api, ruolo Maintainer, da usare solo per leggere, aggiornare e commentare le issue. Controllare la scadenza e rinnovarlo.
• Una chiave SSH a persona con permessi di push sui repository coinvolti. La MR si apre con questa chiave, senza token.
• Un agente locale a persona: ZCode, Claude Code o simili. Salvare le regole nelle istruzioni persistenti (AGENTS.md / CLAUDE.md).
• Revisione automatica: autorevisione obbligatoria prima della MR e conclusione nella issue. Revisione incrociata consigliata: l’agente di chi revisiona interroga ai-reviewing.
• Rami protetti: vietare il push diretto su develop e master. L’IA deve passare da una MR; il controllo umano fa parte del processo.
• Una guida iniziale: creare da un modello una issue di avvio e assegnarla al nuovo collega. Il suo agente la legge, verifica la configurazione e memorizza le regole.
Inseriamo la guida direttamente in quella prima issue. Alla prima interrogazione l’agente trova il proprio manuale: controlla token, interrogazioni, permessi di push e ramo predefinito, salva le regole e risponde nella issue. Da quel momento la presa in carico è automatica.
Cosa non deleghiamo all’IA
• Grandi refactoring: valutazione dell’impatto e scelte architetturali spettano alle persone.
• Requisiti ambigui: chiedere chiarimenti nella issue, senza improvvisare correzioni. Se il requisito resta oscuro, riprendere l’attività e ridefinirla.
• Attività con credenziali o operazioni a pagamento: non assegnarle e non inserire quei dettagli nella issue.
• Filtrare anche le fonti: meglio poche issue precise che tante vaghe. La qualità raggiungibile dalla correzione dipende già da come viene scritta la issue.
Cosa è cambiato
La differenza principale non è la velocità. Il lavoro non dipende più da qualcuno che se ne ricordi e lo inoltri: l’avviso diventa una issue, la issue raggiunge l’assegnatario, l’IA la gestisce e una persona decide. I rami protetti impediscono a qualunque IA, compresa la propria, di cambiare il ramo principale senza revisione. Le etichette identificative mantengono leggibile il lavoro simultaneo tra più persone e macchine.
Per provare, seguite un piccolo bug reale lungo tutto il percorso: apertura → presa in carico → correzione → MR → merge → chiusura automatica. Aggiungete poi gli avvisi di monitoraggio e le scansioni come fonti di attività. Ci interessa sapere quali difficoltà incontrerete.