# Smonta una funzione e rifalla tua

I prompt della risorsa di Riccardo Belli su REA (Reverse Engineer Anything), il tool open source che fa studiare al tuo agente una funzione di un'app anche senza il codice sorgente.

Le parti da cambiare sono tra parentesi quadre.

## 0. Installazione

Ti serve Node.js con npm: la 22 dalla 22.19 in su, la 24 dalla 24.11 in su oppure la 26 e successive. Controlla con `node -v`.

Nel terminale:

```
npx rea-agents setup
```

Scegli gli agenti, rivedi le modifiche, approva e riavvia l'agente. In Claude Code scrivi `/mcp`: nella lista deve comparire `rea`.

Se preferisci che lo installi Claude Code:

```
Installa REA, il pacchetto npm rea-agents, per Claude Code.
Prima controlla con node -v che la versione di Node.js vada bene
(22 dalla 22.19, 24 dalla 24.11 oppure 26 e successive).
Poi lancia: npx -y rea-agents@latest setup --client claude_code --dry-run
e mostrami tutte le modifiche che propone.
Aspetta il mio ok prima di rilanciare lo stesso comando con --yes al posto di --dry-run.
Alla fine ricordami di riavviare Claude Code.
```

Per aggiornarlo: `npx rea-agents@latest setup`, poi riavvia l'agente.

## 1. Studia la funzione

In un'app:

```
Usa REA per capire come funziona [la funzione, per esempio i risultati che compaiono mentre scrivi nella ricerca] in [nome dell'app].
L'app è installata qui: [percorso dell'app sul tuo computer].

Voglio sapere:
1. da dove parte la funzione e che pezzi di codice attraversa, passo per passo
2. che dati entrano, che dati escono e dove vengono salvati
3. che librerie o servizi esterni usa

Per ogni passo mostrami la prova: il file, la funzione o l'indirizzo dove l'hai trovata.
Tieni separato quello che hai visto, quello che hai dedotto e quello che non sai.
Non scrivere ancora codice.
```

Su un sito:

```
Usa REA per capire come funziona [la funzione] sul sito [indirizzo del sito].
Guarda la struttura della pagina, gli script e le chiamate di rete che partono quando la uso.
Mostrami le prove e tieni separato quello che hai visto da quello che hai dedotto.
Non scrivere ancora codice.
```

## 2. Mettila per iscritto

Nella stessa chat:

```
Scrivi la specifica della funzione che hai appena studiato.
Mi serve per rifarla da zero nel mio progetto.
Descrivi con parole tue cosa fa, i casi limite e i dati che usa.
Non copiare codice, testi o immagini dell'app originale.
Segna ogni punto come visto, dedotto o ignoto.
Salvala in docs/specifica-[nome-funzione].md.
```

Leggila tu prima di andare avanti. I punti ignoti sono le scelte che fai tu.

## 3. Rifalla a modo tuo

In una sessione nuova, nel tuo progetto:

```
Leggi docs/specifica-[nome-funzione].md e il mio progetto.
Costruisci una versione mia di questa funzione con [il tuo stack, per esempio Next.js e Supabase].
Scrivila da zero con lo stile del mio codice e usa solo la specifica.
Prima di scrivere codice proponimi un piano di massimo cinque punti e aspetta il mio ok.
Alla fine scrivi i test per i casi limite della specifica e falli girare.
```

## Bonus: lo stesso trucco sulle tue skill

Passo 1, trova le regole:

```
Voglio costruire una skill che faccia [il lavoro, per esempio gli script dei miei reel].
Nella cartella esempi/migliori ci sono sei lavori venuti benissimo.
Nella cartella esempi/peggiori ci sono sei lavori che non hanno funzionato.
Leggili tutti e confrontali.
Dimmi cosa hanno in comune i migliori e cosa manca ai peggiori: struttura, attacco, lunghezza, tono, chiusura.
Accanto a ogni regola scrivi se è vista (c'è in tutti i migliori), dedotta (è una tua ipotesi) o ignota (dagli esempi non si capisce).
Non costruire ancora la skill.
```

Leggi le regole una per una. Togli quelle sbagliate, conferma le dedotte che ti tornano e lascia fuori le ignote.

Passo 2, costruisci e prova:

```
Queste sono le regole che ho controllato:
[incolla le regole]

Costruisci la skill in .claude/skills/[nome-skill]/SKILL.md.
Copia i tre esempi migliori in una cartella examples/ dentro la skill.
Nel SKILL.md scrivi di leggerli prima di cominciare ogni lavoro.
Poi provala: fai un lavoro nuovo con la skill e confrontalo con i migliori.
Dimmi cosa manca.
```

## Usalo bene

REA è fatto per la ricerca, lo studio, la compatibilità fra programmi e per il software che è tuo o che hai il permesso di analizzare. Molte licenze vietano il reverse engineering dei programmi commerciali. Prima di aprirne uno, leggi la sua. Niente licenze aggirate, niente codice altrui copiato: capisci come funziona, lo descrivi con parole tue e lo riscrivi da zero.

Riccardo Belli · riccardobelli.com