Guida ai prompt · verificata il 15 novembre 2026

Prompt Antigravity: 15 modelli per programmare

Dai ad Antigravity un obiettivo delimitato, il contesto necessario e una prova del risultato. Copia i modelli, sostituisci i segnaposto e mantieni ogni modifica verificabile.

Sono modelli editoriali, non prompt di sistema Google e non garantiscono una risposta specifica. Per il comportamento attuale usa la documentazione ufficiale.

Cosa rende efficace un prompt Antigravity

I prompt Antigravity funzionano quando trasformano un’intenzione generica in un’attività osservabile. «Migliora l’app» non ha un confine. «Trova perché il totale della fattura viene arrotondato due volte, modifica solo il calcolo, aggiungi un test di regressione e mostra il diff» definisce obiettivo, ambito e punto di stop. Il principio vale per il desktop, Antigravity CLI e i workflow che usano più strumenti.

Questa pagina riguarda il design dei prompt e gli esempi riutilizzabili. La guida Antigravity Workflows tratta processi ripetibili, permessi e checkpoint; la guida Antigravity CLI tratta installazione e comandi. Separare gli argomenti evita che un prompt diventi una richiesta nascosta di cambiare configurazione o moduli estranei.

Considera ogni risposta una proposta finché non controlli file, comandi e prove citati. Un prompt breve con un test di accettazione visibile è più utile di un testo lungo che descrive ogni funzione possibile. Metti le regole stabili nel repository o in impostazioni revisionate e usa il prompt attivo per la decisione corrente.

Un risultatoDescrivi l’artefatto, la correzione, la spiegazione o la decisione attesa alla fine del turno.
Contesto verificabileIndica repository, file, errore, comando di test o fonte che l’agente può ispezionare davvero.
Prova visibileChiedi diff, risultato del test, percorso del file o riproduzione controllabile da una persona.

Il quadro del prompt in quattro parti

Un prompt Antigravity affidabile può essere diviso in obiettivo, contesto, vincoli e prova. In una domanda semplice non servono etichette esplicite, ma la struttura è utile quando entrano in gioco codice, credenziali, strumenti esterni o molti file. Se la risposta fallisce, mostra quale blocco manca.

L’obiettivo deve avere verbo e oggetto: diagnosticare un parser, aggiungere una rotta, confrontare API, spiegare un test o rivedere un diff. Il contesto dice dove si trova il lavoro e cosa è già noto. I vincoli indicano cosa non cambiare, quali comandi sono ammessi e se l’agente può scrivere. La prova è il controllo finale: test mirato, HTML renderizzato o incertezza dichiarata.

Rendi realistico il criterio di accettazione. «Zero bug» non è misurabile in un solo turno. Un test preciso, una risposta che passa da 404 a 200 o una riga attesa in una tabella sono verificabili. Se l’agente non può eseguire un comando, deve dirlo e fornire il comando esatto da eseguire manualmente.

1

Obiettivo

Parti dal risultato minimo utile: identificare, pianificare, modificare, spiegare, testare o rivedere.

2

Contesto

Nomina cartella, file, framework, errore, comportamento atteso e riferimento affidabile.

3

Vincoli

Definisci percorsi modificabili, azioni vietate, dipendenze, limiti di sicurezza e stop.

4

Prova

Specifica comando, diff, screenshot, output o domanda aperta che dimostri il risultato.

Prompt per pianificare e capire un progetto

Usa un prompt di pianificazione prima di una modifica ampia o dentro un repository sconosciuto. Chiedi di ispezionare l’albero reale e citare i percorsi usati. Un buon piano è una mappa, non una riscrittura ipotetica: indica i file minimi, i rischi e il controllo che confermerà la scelta.

Fai elencare le incognite. Se esistono più comandi di build, percorsi di autenticazione o sorgenti di traduzione, l’agente deve mostrare le alternative e dire quale ha verificato. Così un README presunto o un framework indovinato non diventa la base di tutte le modifiche successive.

Rivedi il piano e invia un nuovo prompt per eseguire solo la parte approvata. Separare ispezione e scrittura lascia un checkpoint e rende visibile l’aumento di ambito.

01. Mappare il repository

Ispeziona questo repository senza modificare file. Identifica framework, ingresso, build, test, configurazione e i tre file che controllano [comportamento]. Cita ogni percorso e ciò che non hai verificato.

Perché aiuta: Porta fatti e percorsi prima dell’implementazione.

02. Trasformare una richiesta in piano

Crea un piano in cinque passi per [obiettivo]. Limita le modifiche a [percorsi consentiti]. Per ogni passo indica risultato e controllo. Segnala ipotesi, dipendenze e punto di ripristino. Non scrivere file.

Perché aiuta: La sequenza è leggibile e delimitata.

03. Trovare il proprietario

Segui come [input o rotta] diventa [output osservato]. Parti dall’ingresso pubblico, attraversa funzione o template fino alla fonte di verità e restituisci un grafo breve con il file responsabile.

Perché aiuta: Il fix resta nel modulo che possiede il comportamento.

15 modelli pratici di prompt Antigravity

Questi prompt Antigravity sono volutamente brevi. Sostituisci i valori tra parentesi, togli i passaggi inutili e aggiungi un comando o un output atteso. Coprono comprensione del progetto, implementazione, debug, test, review e documentazione.

1

Mappa del repository

Ispeziona l’albero e riassumi runtime, ingresso, build, test e deploy.

Prima di un codice sconosciuto.
2

Separare i requisiti

Riscrivi questa richiesta come obbligatorio, fuori ambito, domande e controlli: [richiesta].

Quando il ticket mescola obiettivi.
3

Design minimo

Proponi il design più piccolo per [obiettivo]. Confronta due opzioni e costi prima di scegliere.

Prima di aggiungere un’astrazione.
4

Implementazione mirata

Implementa [comportamento] in [percorsi]. Conserva API e stile. Mostra i file e fermati dopo il test mirato.

Per una patch limitata.
5

Refactoring sicuro

Trova duplicazioni in [modulo]. Suggerisci refactoring, elenca il comportamento invariato e modifica solo dopo l’approvazione.

Quando la pulizia può cambiare il comportamento.
6

Riprodurre un bug

Riproduci [errore] con l’input minimo. Registra comando, output e primo valore errato prima del fix.

Quando manca una riproduzione affidabile.
7

Eseguire il debug di una regressione

Confronta il percorso fallito con l’ultimo comportamento corretto. Prova una causa e porta le prove.

Per il debug del lavoro Antigravity.
8

Test di regressione

Aggiungi un test per [bug]. Deve fallire prima del fix e passare dopo, senza fixture estranee.

Per rendere durevole la correzione.
9

Triage dei test

Esegui il test più vicino a [modifica]. Separa errore del prodotto, del test, dell’ambiente e della dipendenza.

Quando un test rosso ha più cause.
10

Code review

Rivedi questo diff per correttezza, sicurezza, compatibilità e test mancanti. Ordina i rilievi con percorsi e righe.

Prima di accettare codice generato.
11

Checklist di migrazione

Pianifica la migrazione da [vecchio] a [nuovo]. Includi dati, compatibilità, rollback e query di verifica.

Per modifiche con stato.
12

Aggiornare la documentazione

Leggi l’implementazione e aggiorna solo la documentazione errata. Cita il comportamento e mantieni esempi eseguibili.

Dopo una modifica.
13

Sonda delle prestazioni

Misura [operazione] con un campione ripetibile. Indica baseline, collo di bottiglia e miglioramento a basso rischio.

Prima di ottimizzare.
14

Review del rilascio

Controlla versione, changelog, build, test, link e rollback. Elenca blocchi con prove.

Prima di pubblicare.
15

Spiegare il risultato

Spiega cosa è cambiato, perché, come è stato verificato e cosa resta incerto in cinque punti con percorsi.

Per una consegna verificabile.

Esempi di prompt per programmare e fare debug

Un prompt di programmazione deve proteggere il comportamento esistente prima di chiedere quello nuovo. Nomina i file modificabili, l’API o il markup stabile e il test che percorre il caso. Se compare un secondo problema, chiedi di registrarlo come seguito invece di correggerlo di nascosto nella stessa patch.

Per il debug, chiedi prima una riproduzione. Inserisci input, comando, risposta, output atteso e ambiente. Poi chiedi un’ipotesi e un controllo stretto. In questo modo eviti una lista di fix speculativi e puoi rifiutare una patch che cambia codice estraneo.

Quando serve un blocco di codice, tienilo piccolo e indica dove inserirlo. Chiedi diff e risultato del test; anche i file considerati ma non modificati aiutano a documentare l’ambito.

04. Implementare con stop

In [file], aggiungi [comportamento]. Mantieni firma e messaggi di errore. Aggiungi il test mirato, esegui [comando], mostra il diff e fermati prima del commit.

Perché aiuta: Evita che la patch diventi un refactoring non richiesto.

05. Debug con prove

Riproduci questo fallimento: [comando/input e output]. Ispeziona il codice, formula un’ipotesi ed esegui un controllo che possa confutarla. Poi proponi patch e test.

Perché aiuta: Rende il ragionamento falsificabile.

06. Rivedere codice generato

Rivedi il diff come manutentore. Controlla casi limite, sicurezza, accessibilità, localizzazione e test. Restituisci prima i rilievi e non modificare file.

Perché aiuta: Offre una revisione indipendente prima dell’accettazione.

07. Riparare un tentativo fallito

Il tentativo precedente è fallito con [errore]. Leggi file attuali e output, conserva i cambiamenti utili, correggi solo la differenza, esegui [controllo] e segnala l’incertezza.

Perché aiuta: Non ripete una patch vecchia senza capirla.

Prompt per CLI, file, media e subagent

I prompt Antigravity CLI hanno una questione in più: una sessione può contenere testo su più righe, riferimenti a file o media incollati. Per tasti e invio attuali usa la documentazione ufficiale. Nel prompt chiarisci se il file è contesto in sola lettura, destinazione modificabile o esempio da non copiare.

Un riferimento a un file non autorizza a scansionare tutto il computer. Indica la cartella o il file minimo. Per uno screenshot o un log, spiega cosa deve dimostrare e cosa ignorare. Non incollare mai segreti, cookie, chiavi private o dati di produzione.

I subagent sono utili per controlli indipendenti. Dai a ciascuno una domanda, chiedi un breve rapporto con prove e lascia al compito principale la decisione in caso di contraddizioni. Non fondere automaticamente modifiche opposte.

Input su più righeUsa il metodo documentato dal CLI e rendi visibile il limite del compito prima dell’invio.
Riferimenti ai fileIndica percorsi esatti e separa contesto, file modificabile ed esempio intoccabile.
Contesto mediaSpiega cosa devono provare screenshot o log e oscura i dati privati prima di condividerli.
SubagentAssegna una domanda indipendente a ogni subagent e richiedi un rapporto con prove.
Vista editoriale di un input da terminale e di un risultato per spiegare i limiti del CLI Antigravity
Media già presente nel sito usato come riferimento per input e revisione; non è uno screenshot attuale del prodotto.

Verifica, permessi e limiti del prompt

Un prompt è completo quando una persona può decidere se il risultato è accettabile. Chiedi il controllo esatto, il suo output e l’ambiente. Un test verde può non vedere un link rotto, una lingua sbagliata o un permesso pericoloso: scegli prove proporzionate al rischio.

Mantieni i permessi stretti mentre impari il flusso. Spiegare un comando shell non significa eseguirlo o leggere fuori dal workspace. Chiedi approvazione per scritture, rete, credenziali, migrazioni e release. Se manca l’accesso, l’agente deve fermarsi e spiegare quale prova manca.

Anche i prompt lunghi hanno limiti. Log ripetuti e documentazione copiata nascondono il criterio di accettazione. Riassumi le regole stabili in un file revisionato, collega una fonte affidabile e mantieni il prompt sulla decisione corrente. Se fallisce, riscrivi il blocco mancante invece di aggiungere prosa.

  • Controlla il livello giusto. Quando il cambiamento attraversa più livelli, combina test unitari con rotta, HTML, permessi o output visibile.
  • Rendi esplicite le scritture. Nomina i percorsi consentiti e chiedi un diff; il prompt non è un’autorizzazione globale.
  • Proteggi i dati privati. Oscura segreti e dati personali in prompt, log, screenshot e artefatti.
  • Fermati senza prove. Chiedi di segnalare ciò che non è stato ispezionato invece di riempire il vuoto con supposizioni.
  • Registra il recupero. Conserva errore, tentativo e nuovo controllo per ripartire dai fatti nel turno successivo.
Illustrazione editoriale di permessi e verifica intorno a un prompt Antigravity
Illustrazione delle impostazioni per il confine tra permessi e verifica descritto nell’articolo.

FAQ sui prompt Antigravity

Quali sono i migliori prompt Antigravity?

Un buon prompt indica risultato, contesto verificabile, limiti per file e azioni e prove. Parti dai modelli per mappa, implementazione, debug, test e review.

Come inizio un prompt di programmazione?

Indica obiettivo, repository o file, comportamento attuale e atteso, vincoli e test. Chiedi prima un piano se codice o rischio non sono chiari.

Come scrivo prompt per fare debug di Antigravity?

Inserisci riproduzione minima, output osservato e atteso e ambiente. Chiedi ipotesi e controllo prima della patch.

Un prompt può modificare più file?

Sì, se elenchi percorsi consentiti e motivo. Chiedi diff per file e conserva ogni espansione come attività successiva.

Cosa includo nei prompt Antigravity CLI?

Segui la guida ufficiale per testo multilinea, file e media. Specifica contesto e destinazioni e non includere segreti.

Perché il prompt produce una risposta vaga?

Spesso mancano obiettivo, contesto o criterio di accettazione. Riscrivi con output concreto, percorsi o errore e un breve rapporto di prove.

Devo ripetere le istruzioni permanenti?

Metti le regole stabili in documentazione o impostazioni revisionate e ripeti solo il limite utile al compito corrente.

Questi modelli sono ufficiali?

No. Sono esempi editoriali. Per comportamento, controlli CLI e integrazioni vale la documentazione ufficiale Antigravity.

Fonti consultate