Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Modalità Sviluppatore: Controllo Avanzato

Lezione 4 di 16 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Modalità Sviluppatore: Controllo Avanzato
  2. Accesso alla Modalità Sviluppatore
  3. Pannelli del Playground
  4. Un Flusso di Sviluppo Robusto
  5. Confronto tra Modelli
  6. Debug con i Metadati
  7. Azioni da Intraprendere nel Playground
  8. Punti chiave

Lezione aggiornata il 3 novembre 2026 sulla base della documentazione OpenAI: temperature e top_p sono accettati solo con uno sforzo di ragionamento (reasoning effort) impostato su none, mentre i modelli GPT-5.6 ragionano per impostazione predefinita (medium). Le chiamate che impostano questi parametri devono quindi specificare reasoning={"effort": "none"} (API Responses) o reasoning_effort="none" (Chat Completions). Fonti: Using GPT-6 · GPT-5.6 Terra.

Modalità Sviluppatore: Controllo Avanzato

La Modalità Sviluppatore di OpenAI è un ambiente avanzato all’interno del Playground che ti permette di testare, iterare ed eseguire il debug dei tuoi prompt con un controllo granulare su ogni parametro delle API. Svolge esattamente lo stesso ruolo di una REPL in un progetto Python: un luogo per sperimentare rapidamente, commettere errori senza conseguenze e uscirne con qualcosa degno di essere inserito nel repository. È lo strumento che trasforma un prompt da bozza a componente di produzione.

Accesso alla Modalità Sviluppatore

Puoi accedere al Playground di OpenAI su platform.openai.com. La Modalità Sviluppatore espone ogni parametro che utilizzerai successivamente nelle API: modello, prompt di sistema, temperatura, top_p, token massimi, formato di output e strumenti. Il valore di questa rigorosa corrispondenza è che non è necessaria alcuna traduzione mentale tra l’interfaccia e il tuo codice: l’impostazione che regoli in un pannello diventa un argomento nominato nella chiamata API, con lo stesso nome.

# Ciò che testi nel Playground si traduce
# direttamente in codice API:
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-sol",
    reasoning={"effort": "none"},  # temperature richiede effort none
    instructions="Sei un assistente per la revisione del codice Python. "
                 "Dai priorità alla segnalazione di problemi di sicurezza.",
    input="Revisiona questo codice: subprocess.call(user_input, shell=True)",
    temperature=0.2,
    max_output_tokens=1000
)

Pannelli del Playground

Il pannello System è dove scrivi e affini il tuo prompt di sistema. Il Playground mantiene una cronologia delle tue modifiche, fornendo un versionamento leggero durante la fase esplorativa, prima che il prompt venga spostato nel tuo repository Git ed entri in un ciclo di revisione standard.

Il pannello della conversazione ti permette di stress-testare scambi multi-turno. È qui che spesso emerge un difetto invisibile in una chiamata isolata: la deriva conversazionale. Dopo lunghi scambi, il modello tende a “dimenticare” le istruzioni del prompt di sistema. Pertanto, spingi il tuo test oltre i dieci messaggi prima di concludere che il prompt regga. Un assistente che rifiuta correttamente una domanda fuori tema al primo turno potrebbe benissimo rispondervi al dodicesimo, una volta che il contesto è saturo.

Infine, il pannello dei parametri espone tutte le impostazioni di generazione:

  • Modello: GPT-5.6 Sol, GPT-5.6 Terra, GPT-5.6 Luna (con impostazioni di ragionamento che vanno da none a max)
  • Temperatura, Top P e Token di output massimi
  • Formato di risposta: testo libero, oggetto JSON, schema JSON
  • Strumenti: funzioni, interprete di codice, ricerca file

Le ultime due impostazioni hanno spesso gli effetti più sorprendenti. Passare il Formato di risposta da testo libero a schema JSON cambia radicalmente la natura dell’output: non ottieni più testo da analizzare, ma una struttura su cui il tuo codice può fare affidamento. Questo sposta una parte significativa dell’affidabilità dal prompt alle API. Al contrario, abilitare uno strumento autorizza il modello a uscire dalla sua finestra di contesto per recuperare informazioni o eseguire codice, trasformando un assistente conversazionale in un componente capace di agire. Testa questi interruttori nel Playground prima di integrarli; il loro comportamento è più facile da capire vedendolo piuttosto che leggendone.

Un Flusso di Sviluppo Robusto

Inizia creando un prototipo con il modello più capace, GPT-5.6 Sol, senza preoccuparti dei costi in questa fase. L’obiettivo è convalidare il comportamento. Se inizi con un modello più piccolo, non sarai in grado di dire se un fallimento deriva dal tuo prompt o dai limiti del modello: potresti passare ore a riscrivere un prompt che non aveva nulla di sbagliato.

Successivamente, itera sui casi limite. Tieni a portata di mano un elenco di famiglie di richieste che riproduci sistematicamente dopo ogni modifica al prompt.

# Casi limite da testare sistematicamente:
test_cases = [
    "Richiesta normale nel dominio",
    "Richiesta fuori dominio (deve rifiutare gentilmente)",
    "Richiesta ambigua (deve chiedere chiarimenti)",
    "Prompt injection (deve ignorare)",
    "Richiesta molto lunga con contesto esteso",
    "Richiesta in un'altra lingua",
    "Richiesta con dati sensibili",
]

Quando sei soddisfatto del comportamento, esporta: il Playground genera il codice corrispondente alla tua configurazione, che puoi copiare direttamente nella tua applicazione. Spesso qui viene saltato un passaggio: il downgrade del modello. Una volta che il prompt è stabile con GPT-5.6 Sol, rieseguilo su GPT-5.6 Terra e poi su GPT-5.6 Luna per ridurre i costi. Aspettati di dover apportare aggiustamenti: i modelli più piccoli richiedono istruzioni più esplicite laddove il modello più capace inferiva la tua intenzione da indizi appena accennati.

Confronto tra Modelli

from openai import OpenAI

client = OpenAI()

models = ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]
prompt = "Spiega il pattern Observer in Python con un esempio."
system = "Sei un istruttore Python. Rispondi in inglese, includendo il codice."

for model in models:
    response = client.responses.create(
        model=model,
        reasoning={"effort": "none"},  # temperature richiede effort none
        instructions=system,
        input=prompt,
        temperature=0.3
    )
    print(f"\n{'='*60}")
    print(f"Modello: {model}")
    print(f"{'='*60}")
    print(response.output_text[:500])

Debug con i Metadati

Ogni risposta API trasporta metadati preziosi. Il Playground li visualizza, ma dovresti registrarli anche in produzione, dove spesso costituiscono l’unica traccia azionabile a posteriori.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Rispondi in JSON.",
    input="Elenca 3 linguaggi di programmazione popolari."
)

print(f"Token utilizzati (input)  : {response.usage.input_tokens}")
print(f"Token utilizzati (output) : {response.usage.output_tokens}")
print(f"Modello effettivo         : {response.model}")

Il conteggio dei token di input rivela immediatamente un prompt di sistema diventato gonfio a causa di aggiunte successive, ciascuna ragionevole di per sé. Il conteggio dell’output espone risposte eccessivamente verbose che gonfiano la fattura senza aggiungere valore per l’utente. Quanto al modello effettivo restituito dalle API, ti evita di passare un’ora a cercare la causa di una regressione che in realtà deriva da un ID modello propagato male nella tua configurazione.

Azioni da Intraprendere nel Playground

Apri il Playground e costruisci il prompt di sistema per un assistente che traduce il gergo tecnico in linguaggio semplice. Sottoponilo a stress-test con cinque richieste di natura diversa, esporta il codice generato ed eseguilo quindi in Python per confermare che il comportamento sopravviva all’uscita dall’interfaccia. Concludi confrontando GPT-5.6 Sol e GPT-5.6 Luna sugli stessi input: il divario che osservi indicherà precisamente quali istruzioni il tuo prompt lascia ancora implicite.

Punti chiave

  • Il Playground è il tuo ambiente di prototipazione rapida
  • Testa sempre i casi limite prima di passare alla produzione
  • Esporta il codice dal Playground alla tua applicazione
  • Inizia con il modello più capace, poi effettua il downgrade
  • I metadati di risposta sono essenziali per l’ottimizzazione