Prompt.
Prima capire, poi decidere.

Fammi il punto della situazione su questo progetto.

1. Ricostruisci lo stato da documenti, note, TODO e, se il progetto usa git, da ultimi commit, rami e modifiche non salvate.
2. Confronta ciò che i documenti dicono con ciò che il progetto fa davvero: dove non combaciano?
3. Individua cosa blocca l'avanzamento: decisioni mie, accessi, dati mancanti, parti rotte.
4. Proponi i passi successivi possibili, il più utile per primo, con il perché.

Fai un controllo di salute di questo progetto, come una revisione periodica.

1. Automatismi: cosa dovrebbe partire da solo (operazioni pianificate, backup, integrazione continua, notifiche) e la prova dell'ultima esecuzione. Non avviarli a mano.
2. Errori: log e segnalazioni recenti, errori nuovi o ripetuti.
3. Scadenze: token, certificati, chiavi, domini, abbonamenti.
4. Dipendenze: aggiornamenti di sicurezza disponibili, versioni non più supportate.
5. Crescita: file, rami o dati aumentati senza motivo. Solo da elencare.

Riporta tutto in una tabella: voce, stato, prova, rischio.

Guarda cosa è cambiato di recente in questo progetto e cosa potrebbe essersi rotto.

1. Ricostruisci le modifiche recenti: se il progetto usa git, dall'ultimo punto stabile; altrimenti da date dei file e documenti.
2. Per ogni modifica: cosa fa, quali parti tocca, cosa dipende da quelle parti.
3. Controlla le parti a rischio con prove mirate che non scrivano dati reali.
4. Segnala ciò che è cambiato senza essere documentato.

Dimmi se questo progetto è pronto per essere pubblicato o consegnato.

1. Percorri il percorso principale da capo, come farebbe una persona nuova.
2. Cerca i bloccanti: errori, dati di prova rimasti, segreti esposti, testi provvisori, link rotti, parti incomplete.
3. Controlla che quello che il progetto promette sia vero.
4. Dividi ciò che trovi in tre gruppi: blocca la pubblicazione, da sistemare presto, può aspettare.

Dimmi dove conviene investire tempo su questo progetto.

1. Capisci a cosa serve e chi lo usa, dai documenti e dal progetto stesso.
2. Cerca le occasioni: cose che fanno perdere tempo, parti fragili, attriti per chi lo usa, lavoro manuale ripetuto, idee rimaste a metà nei documenti.
3. Per ognuna stima beneficio e costo, e dì quanto sei sicuro della stima.
4. Ordinale per beneficio rispetto al costo. Al massimo sette.

Cerca i bug di questo progetto fuori dal percorso previsto.

1. Prova i casi limite pertinenti: valori vuoti o enormi, caratteri speciali, zero e negativi, doppio clic, rete assente, sessione scaduta.
2. Cerca gli errori muti: eccezioni ingoiate, operazioni che falliscono senza avvisare.
3. Cerca i dati che si guastano: riferimenti a elementi cancellati, salvataggi a metà, fusi orari, arrotondamenti.

Per ogni bug riprodotto scrivi i passi esatti; quelli non riprodotti vanno in «sospetti», con il motivo.

Controlla se questo progetto fa quello che promette.

1. Ricava le promesse: cosa dicono documenti, pagine, descrizioni e interfaccia che il progetto fa.
2. Per ogni promessa percorri il caso reale con dati realistici, senza toccare dati veri.
3. Classifica: funziona, funziona in parte (cosa manca), non funziona, non verificabile (cosa servirebbe).
4. Segnala anche le funzioni presenti ma non dichiarate da nessuna parte.

Verifica come si comporta questo progetto quando qualcosa va storto.

1. Individua da cosa dipende: servizi esterni, rete, database, file, altri programmi.
2. Per ciascuno: cosa succede se non risponde, risponde tardi o risponde male? L'errore si vede, si recupera, o si perdono dati? Prova solo in locale o ragionando sul codice.
3. Backup e ripristino: esistono, sono recenti, qualcuno ha mai provato a ripristinarli?
4. Operazioni interrotte a metà: lasciano dati incoerenti?

Fai una verifica di sicurezza di questo progetto, con gli occhi di chi cerca di entrare dove non dovrebbe.

1. Mappa: quali dati tiene, chi può leggerli e scriverli, da dove entra l'input.
2. Accessi: ogni operazione controlla chi la chiede sul server? Cambiando un identificativo si vedono i dati di un altro?
3. Segreti: chiavi, token e password nel codice, nella cronologia, nei log, nel codice inviato al browser. Indica dove, senza riportarne il valore.
4. Input e configurazione: iniezioni, caricamento di file, reindirizzamenti aperti, HTTPS, intestazioni, dipendenze vulnerabili.

Per ogni rischio descrivi lo scenario d'attacco in una frase. Non tentare attacchi contro servizi pubblicati o di terzi.

Verifica come questo progetto tratta i dati personali. Non è una consulenza legale: segnala dove servirebbe un parere.

1. Mappa i dati personali: quali raccoglie, anche indirettamente (indirizzi IP, statistiche, cookie, log), da dove, dove li salva, a chi li passa.
2. Confronta con ciò che dichiarano informativa e banner: voci mancanti, promesse non mantenute.
3. Conservazione: per quanto restano i dati, e se c'è un modo per cancellarli.
4. Servizi di terzi: quali ricevono dati, e se sono dichiarati.

Usa questo progetto come chi lo vede per la prima volta e ha fretta. Se non puoi avviarlo, dillo e lavora su schermate e codice.

1. Scrivi chi è l'utente tipo e i suoi tre compiti principali, e da cosa lo deduci. Se li indico io, usa i miei.
2. Porta a termine ogni compito e annota dove il passo successivo non si capisce: comandi senza testo, azioni da cercare scorrendo, passi di troppo.
3. Se un compito scrive dati reali, fermati sul passo prima: annota cosa succederebbe e se si può annullare.
4. Ripeti su telefono e computer, misurando lo schermo (390 e 1280 px) e non a occhio, se l'interfaccia cambia con la larghezza.
5. Provoca almeno un errore per compito, per esempio un campo vuoto o un file sbagliato: il messaggio dice cosa è successo e cosa fare?
6. Cerca trappole: azioni irreversibili senza conferma, lavoro perso, parole tecniche.

Verifica l'accessibilità dell'interfaccia. Tieni separati requisiti WCAG 2.2 AA, buone pratiche e suggerimenti.

1. Contrasto: 4,5:1 per il testo normale, 3:1 per testo grande e componenti. Riporta i valori misurati.
2. Tastiera: tutto si usa senza mouse, con il fuoco visibile.
3. Nomi e annunci: testi alternativi, etichette, messaggi dinamici annunciati.
4. Bersagli: almeno 24×24 px (requisito), 44×44 px per il tocco (buona pratica).

Dove servirebbe una prova con lettore di schermo che non puoi fare, dillo.

Verifica come si comporta questo progetto su schermi e browser diversi.

1. Prova le pagine principali a 320, 390, 768 e 1280 px di larghezza: contenuti tagliati, scorrimento orizzontale, testi illeggibili, comandi troppo piccoli.
2. Telefono in verticale e in orizzontale, con la tastiera aperta sui campi.
3. Browser: se puoi, confronta Safari, Firefox e Chrome; se ne hai uno solo, dillo e segnala le parti del codice a rischio di compatibilità.
4. Testo ingrandito dal sistema e modalità scura, se il progetto le prevede.

Misura le prestazioni di questo progetto: misure, non impressioni.

1. Prima apertura: peso, richieste, tempo prima che si possa usare.
2. Operazioni principali con pochi e con molti dati: dove il tempo cresce più che in proporzione?
3. Server e database: interrogazioni ripetute, dati caricati per intero quando ne serve una parte.

Per ogni misura indica condizioni e attendibilità; per ogni problema l'effetto per chi usa il progetto, il guadagno stimato e il costo.

Capisci quanto consuma e quanto costa questo progetto.

1. Elenca i servizi a pagamento o con limiti gratuiti: hosting, database, API, domini, strumenti.
2. Per ognuno, il consumo attuale rispetto ai limiti, se riesci a vederlo; altrimenti dichiara che non è verificato.
3. Cerca gli sprechi: chiamate ripetute, dati conservati senza motivo, risorse attive e inutilizzate.
4. Stima cosa succede se l'uso raddoppia.

Valuta se i test di questo progetto proteggono davvero.

1. Lanciali e riporta l'esito con il codice di uscita. Segnala quelli saltati o disattivati.
2. Controlla che provino il progetto vero, con dati realistici.
3. Per i cinque test più importanti descrivi un guasto plausibile che non li farebbe fallire. Se vuoi dimostrarlo, fallo solo in una copia isolata e poi eliminala; non toccare le modifiche non salvate.
4. Elenca le funzioni importanti senza test, in ordine di danno.

Capisci quali parti di questo progetto rendono difficili le modifiche.

1. Trova i punti critici: file o funzioni molto lunghi, logica duplicata, nomi che ingannano, codice morto, parti senza test.
2. Dipendenze: librerie abbandonate, versioni vecchie, pacchetti usati per poco.
3. Per ogni punto stima quanto costa lasciarlo così (tempo, rischio di errori) e quanto costa sistemarlo.
4. Niente riscritture totali: proponi interventi piccoli, in ordine.

Verifica se questo progetto si può riprendere senza la memoria di chi l'ha fatto.

1. Fingi di arrivare adesso: dai soli documenti capisci a cosa serve, come si avvia, come si verifica, come si pubblica?
2. Prova i comandi scritti nei documenti che non modificano dati: funzionano ancora?
3. Segnala decisioni importanti non scritte, istruzioni superate, passaggi che stanno solo nella testa di qualcuno.
4. Indica il minimo da scrivere perché la prossima persona parta in un'ora.

Controlla che ciò che il progetto afferma sia vero e aggiornato.

1. Elenca le affermazioni verificabili: numeri, promesse, limiti, dati tecnici, prezzi, date.
2. Per ognuna cerca la fonte: il codice, una fonte primaria, un calcolo.
3. Segnala le affermazioni false, superate, contraddittorie o senza fonte.

Non inventare fonti: se non trovi conferma, scrivi «non verificato».

Verifica quanto questo sito è leggibile da motori di ricerca e assistenti AI. Nessun intervento garantisce indicizzazione: separa controlli tecnici e suggerimenti.

1. Titoli, descrizioni, canonical, robots e sitemap coerenti.
2. Pagine a cui non porta nessun link interno.
3. Dati strutturati validi; contenuto leggibile senza JavaScript.
4. Se hai accesso a Search Console, confronta con ciò che risulta indicizzato; altrimenti dichiaralo.

Fammi capire come è occupato il disco di questo computer e cosa non serve più.

1. Misura le cartelle principali della mia home (Scrivania, Documenti, Download, Immagini, Filmati, Musica, cartelle di lavoro): quanto pesano e quando sono state toccate l'ultima volta. Salta le cartelle di sistema, le librerie interne delle applicazioni, le cache e le cartelle di dipendenze; dimmi cosa hai escluso.
2. Elenca le venti voci più pesanti con peso, ultima modifica e a cosa servono, per quello che capisci dai nomi e dal contenuto.
3. Separa: roba viva, roba ferma da più di un anno, roba che si può ricreare (cache, esportazioni, copie di lavoro).
4. Dove non capisci a cosa serve una cartella, dillo invece di indovinare.

Non spostare, rinominare o cancellare niente.

Guarda cosa si è accumulato sulla Scrivania e nella cartella Download, e proponi dove va.

1. Elenca i file con data, peso e tipo. Raggruppali per argomento o progetto, non per estensione.
2. Per ogni gruppo proponi una destinazione fra le cartelle che uso già, dicendo perché. Se serve una cartella nuova, dillo.
3. Tieni da parte i dubbi: file che non capisci, roba personale, cose scaricate per caso.
4. Segnala ciò che si può buttare senza perdere niente (installatori già usati, doppioni scaricati, archivi già estratti).

Non spostare né rinominare niente: prepara l'elenco delle destinazioni e fammelo approvare.

Cerca i file doppi e le versioni multiple della stessa cosa.

1. Prima i file identici per contenuto, non solo per nome, nelle cartelle che ti indico o nella mia home, escludendo sistema, cache e librerie delle applicazioni.
2. Poi le famiglie di versioni: «copia», «copia 2», «finale», date diverse, esportazioni ripetute.
3. Per ogni gruppo indica quale terresti e perché (più recente, in un percorso ordinato, richiamato da altri file), e quanto spazio si libera.
4. Metti a parte i casi delicati: file dentro cartelle sincronizzate con la nuvola, dentro repository, o che potrebbero essere richiamati da un programma.

Non cancellare e non spostare niente.

Capisci come sono organizzate oggi le mie cartelle e proponi una regola che rispetti quello che già faccio.

1. Guarda la struttura reale: come sono raggruppate le cartelle, che nomi hanno, quali schemi ricorrono (date, cliente, progetto, anno).
2. Ricava le regole che seguo già, con esempi veri, e i punti dove non le seguo.
3. Proponi una convenzione minima: nomi di file e cartelle, dove nasce una cosa nuova, dove finisce quando è chiusa. Poche regole, tutte applicabili a mano.
4. Indica le cartelle che oggi si allontanano di più dalla regola e quanto costerebbe sistemarle.

Non rinominare né spostare niente.

Trova cosa è finito e si può togliere di mezzo.

1. Per ogni cartella di lavoro capisci se è viva, ferma o chiusa: ultima modifica, documenti di stato, scadenze passate, cose consegnate.
2. Elenca i candidati all'archivio con la prova (date, note, stato) e cosa resterebbe da fare se non fosse chiusa davvero.
3. Segnala quelle che sembrano ferme ma hanno una scadenza futura o un'azione pendente: quelle non si archiviano.
4. Proponi dove archiviarle, rispettando le cartelle di archivio che uso già.

Non spostare niente.

Capisci quali dei miei file esistono in un posto solo.

1. Individua i dati che non si possono ricreare: documenti, registrazioni, foto, progetti, archivi contabili, chiavi e credenziali. Delle credenziali segnala solo dove stanno: non aprirle e non riportarne il contenuto.
2. Controlla quali copie esistono davvero: backup del sistema (quando è riuscito l'ultimo), cartelle sincronizzate con la nuvola, repository con copia remota. «È configurato» non basta: cerca la prova.
3. Elenca ciò che non ha nessuna copia, in ordine di danno se sparisse.
4. Per ogni voce proponi dove metterla al sicuro e quanto spazio occuperebbe.

Non copiare né spostare file.

Guarda quanto pesano i file multimediali e cosa si può alleggerire.

1. Trova le cartelle con foto, registrazioni, sessioni audio, progetti video ed esportazioni; misura peso e date.
2. Distingui gli originali irripetibili da ciò che si ricrea: render, esportazioni, bounce, cache dei programmi.
3. Segnala le sproporzioni: video enormi per un uso che non li richiede, foto esportate più volte, registrazioni mai usate.
4. Proponi cosa comprimere, cosa spostare su un disco esterno e cosa lasciare dov'è, con il guadagno stimato.

Non convertire, non spostare, non cancellare.

Aiutami a trasformare uno smistamento che faccio a mano in una regola che si ripete.

1. Guarda dove si accumulano sempre le stesse cose e come le sistemo di solito, deducendolo dai nomi e dalla posizione dei file già sistemati.
2. Proponi da una a tre regole automatiche: cosa guardare, con quale criterio, dove finisce il file, cosa fare in caso di dubbio.
3. Per ognuna dimmi come si annulla, cosa può andare storto (file spostato per sbaglio, nomi simili, cartelle sincronizzate) e come me ne accorgerei.
4. Indica come realizzarla con quello che ho già sul computer, e cosa servirebbe installare.

Non attivare e non installare niente.

Qui sotto, o nella conversazione precedente, c'è un elenco di problemi. Valutali in modo neutrale, uno per uno.

1. Riproduci ogni problema da capo, senza basarti sulla descrizione.
2. Cerca anche le ragioni per cui potrebbe non esserlo.
3. Dai un verdetto: CONFERMATO (dimostrato), PLAUSIBILE (credibile, spieghi perché), NON VERIFICABILE (cosa servirebbe), SMENTITO (solo con una prova: non riprodurlo non basta).
4. Per i confermati proponi la correzione più piccola e un test che fallirebbe senza.

Prima di toccare qualcosa, dimmi come faresti questo lavoro.

1. Esplora ciò che serve: materiali coinvolti, documenti di stato, come il progetto risolve già problemi simili.
2. Fammi le domande che cambiano il lavoro, al massimo cinque, ognuna con la risposta che daresti tu.
3. Scrivi il piano in passi piccoli: cosa cambia, dove, come verificherai.
4. Indica rischi, cosa è difficile da annullare, cosa richiede un mio intervento, cosa lasciare fuori.

Procedi con le azioni che ho scelto; se non ho indicato numeri, con il lavoro di cui abbiamo parlato.

PRIMA DI PARTIRE
- Dimmi subito, in un solo messaggio, cosa ti serve da me: accessi, login, pagine da aprire nel browser, dati, decisioni. Poi comincia da ciò che non ne dipende.

COSA PUOI FARE E COSA NO
- Già autorizzato: modificare i file del progetto per questo lavoro, test e prove in locale, commit su un ramo di lavoro se il progetto usa git.
- Da decidere con me: unire alla versione principale, pubblicare, toccare produzione o dati reali, cancellare, mandare messaggi, spendere.
- Ciò che ho già autorizzato resta valido: non chiedermelo di nuovo.

MENTRE LAVORI
- Davanti a una scelta, preferisci la soluzione più semplice e reversibile; annotala in una riga.
- Verifica mentre lavori. Resta nel perimetro delle azioni scelte.

ALLA FINE
Un resoconto breve: cosa hai fatto e dove sta, le scelte prese, come l'hai verificato, cosa resta da decidere.

Riprendiamo un lavoro interrotto. Non fidarti della memoria della conversazione: ricostruisci lo stato dai fatti.

1. Leggi documenti di stato, diario e, se c'è git, ultimi commit e modifiche non salvate. Le modifiche non salvate potrebbero essere mie: non toccarle.
2. Riassumi: obiettivo, cosa è fatto e verificato, cosa è a metà, cosa non torna.
3. Controlla con prove mirate le parti da cui dipende il prossimo passo.
4. Se tutto torna, riparti con le autorizzazioni già date (modifiche, prove e commit su un ramo sì; unire, pubblicare, dati reali no). Se qualcosa non torna, chiedimi prima di proseguire.

Questo lavoro è lungo e per un po' non potrò risponderti. Organizzalo perché, quando torno, trovi uno stato chiaro.

1. Prima che me ne vada, dimmi tutto ciò che potrebbe bloccarti. Se il tuo ambiente può interrompersi, dimmelo: questo prompt non ti tiene attivo.
2. Dividi il lavoro in tappe con un risultato verificabile.
3. A ogni tappa verificata aggiorna un diario nel progetto (fatto, scelte, prove, prossima tappa) e, se c'è git, fai un commit sul ramo di lavoro.
4. Già autorizzato: modifiche, prove, commit sul ramo. Senza di me no: unire, pubblicare, dati reali, messaggi, spese.
5. Davanti a un dubbio scegli la strada prudente e segna «da confermare». Fermati se tutto dipende da me o serve un'azione non autorizzata.

In cima al diario: pronto, da confermare, bloccato, da dove ripartire.

Portiamo il lavoro a una chiusura pulita.

1. Verifica in proporzione a ciò che è cambiato: le parti toccate, quelle che ne dipendono e il percorso principale. Riporta gli esiti come sono.
2. Ripulisci solo ciò che hai creato per questo lavoro.
3. Se c'è git, salva con commit chiari sul ramo di lavoro. Unire e pubblicare restano decisioni mie, salvo autorizzazione già data.
4. Aggiorna i documenti di stato.
5. Consegnami il resoconto: cosa è pronto e dove, come l'hai verificato, cosa non hai potuto verificare, il prossimo passo.

Esegui gli spostamenti di file che ho approvato.

PRIMA
- Ripeti l'elenco esatto: da dove a dove, quanti file, quanto pesano. Se qualcosa è cambiato da quando l'abbiamo deciso, fermati e dimmelo.
- Crea le cartelle di destinazione che mancano.

MENTRE
- Sposta un gruppo alla volta e verifica che i file siano arrivati.
- Non sovrascrivere mai: se il nome esiste già, aggiungi un suffisso e segnalalo.
- Niente cancellazioni: ciò che ho scartato va in una cartella `_DA_ELIMINARE` con la data, che svuoto io.
- Non toccare cartelle sincronizzate con la nuvola, librerie di programmi (foto, musica, posta) e repository senza avvisarmi prima.
- Tieni un registro riga per riga, con percorso di partenza e di arrivo.

ALLA FINE
Dimmi quanti file hai spostato, quanto spazio si è liberato, cosa hai saltato e perché, e dove sono il registro e la cartella `_DA_ELIMINARE`. In fondo al registro scrivi il comando che annulla tutto.