perfetti.tech

Git a due persone per vibe coder: branch, merge e sopravvivenza

Yuri Perfetti4 min di lettura0 letture
Due matite tracciano due linee che si separano e poi si ricongiungono, come uno scambio ferroviario visto dall'alto

Tempo di lettura: 7 minuti — Livello: principiante/intermedio

La premessa

Finché programmi da solo, Git è la tua macchina del tempo personale: commit, e ogni tanto un ritorno al passato quando l'IA (o tu) combinate un pasticcio. Poi arriva il giorno in cui al progetto si aggiunge una seconda persona — nel mio caso, un collega su un portale che stiamo costruendo insieme — e Git cambia mestiere: da macchina del tempo diventa protocollo di convivenza.

Questo articolo è il set minimo di regole che ci siamo dati, pensato per chi come noi è arrivato al codice dalla porta del vibe coding e non da un percorso da sviluppatore. Niente teoria dei workflow aziendali: solo quello che serve a due persone per non pestarsi i piedi.

Il modello mentale (l'unico pezzo di teoria)

Un repository Git condiviso funziona così: c'è una copia "ufficiale" online (su GitHub), e ognuno lavora su una copia locale sul proprio computer. I problemi nascono tutti da un'unica causa: le copie divergono, perché ognuno modifica la sua. Tutto Git-a-due si riduce a gestire con ordine il momento in cui le copie si riallineano.

Regola 1: main è sacro

Il branch main contiene solo codice che funziona. Mai lavorare direttamente su main. Ogni cosa nuova — una funzionalità, un fix — nasce su un branch dedicato:

git checkout main
git pull                       # parti sempre dall'ultima versione!
git checkout -b feature/nome-parlante

Il branch è il tuo recinto: lì dentro puoi sbagliare, rifare, far generare all'IA dieci versioni di un componente. Nessuno ti vede, niente si rompe per gli altri.

Il beneficio nascosto per chi fa vibe coding: il branch delimita anche il raggio d'azione dell'IA. Se una sessione va male e il codice generato è un vicolo cieco, butti il branch e main non se n'è mai accorto.

Regola 2: commit piccoli, messaggi onesti

Un commit per ogni passo compiuto e funzionante. Il messaggio dice cosa e perché, non "modifiche" o "fix vari":

git commit -m "Aggiunge validazione email nel form contatti"

Il motivo pratico: quando qualcosa si rompe, la lista dei commit è la cronologia dell'indagine. Dieci commit chiari si ispezionano in un minuto; un commit monstre chiamato "aggiornamenti" si ispeziona bestemmiando.

Regola 3: la Pull Request, anche in due

Quando il branch è pronto, non lo fondi tu in main: apri una Pull Request su GitHub e l'altro la guarda. In due può sembrare una cerimonia inutile — vi parlate già su WhatsApp, no? Invece è il momento più prezioso del metodo, per tre motivi:

  1. Quattro occhi sul codice generato. L'IA scrive codice plausibile; il collega nota quello che tu, che l'hai "solo" supervisionato, non vedi più.
  2. Ognuno impara cosa sta facendo l'altro. In un progetto a due il rischio non è il conflitto: è che nascano due progetti paralleli che si ignorano.
  3. Ti costringe a spiegare. Se non sai descrivere la tua PR in tre righe, probabilmente non hai capito fino in fondo cosa ha generato l'IA. (E per un vibe coder questo test vale oro.)

Regola 4: i conflitti non sono incidenti

Prima o poi capita: entrambi avete toccato le stesse righe, e Git al momento della fusione si ferma e chiede a un umano di decidere. Il famigerato conflitto di merge.

Prima cosa da sapere: non hai rotto niente. Git sta solo dicendo "qui ci sono due versioni, scegli". Ti mostra entrambe nel file, tra marcatori <<<<<<< e >>>>>>>; scegli, salvi, commit, finito. E in due, la vera risoluzione dei conflitti spesso è un messaggio: "ho toccato anche io il file X, sentiamoci prima di mergiare".

Seconda cosa: i conflitti si prevengono più che si risolvono, con due abitudini — git pull su main prima di creare ogni branch (parti sempre dal presente, non da una foto di settimana scorsa) e branch corti: più un branch vive giorni, più il mondo intorno gli cambia sotto i piedi.

Regola 5: mettete le regole per iscritto

L'ultima, la meno tecnica, la più importante: le convenzioni valgono solo se sono scritte. Noi abbiamo un file nella root del repo con: come si chiamano i branch, cosa serve per approvare una PR, cosa non va MAI committato (i file .env!, vedi l'articolo sui segreti). Dieci righe.

Bonus non ovvio: quel file lo legge anche l'IA quando lavora nel progetto. Le stesse regole che allineano due umani allineano anche il terzo collega, quello artificiale. Un documento, tre lettori.

In sintesi

pull su main → branch → lavora a commit piccoli → PR → review → merge → ripeti

Il ciclo completo si impara in un pomeriggio e restituisce una cosa che nel vibe coding a due non ha prezzo: la certezza permanente che esiste una versione del progetto che funziona, qualunque esperimento stia succedendo nei recinti. Tutto il resto — rebase, squash, cherry-pick e le altre parole esoteriche — può aspettare. O forse, in due, non arrivare mai.


Questo articolo fa parte della serie "Sviluppare con l'IA" su perfetti.tech — dove racconto quello che costruisco davvero, errori compresi.

Condividi

Hai un problema simile?

Mandami due righe: ti dico se ha senso trasformarlo in uno strumento vero e quanto tempo serve.

Scrivimi

Altri articoli

Commenti

Ancora nessun commento. Scrivi il primo.

Lascia un commento

Nome e commento vengono pubblicati sotto l'articolo. Dettagli nella Privacy Policy.

Questo sito è protetto da reCAPTCHA: si applicano la Privacy Policy e i Termini di servizio di Google.

Tutti gli articoli