Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Design: Mockup e prototipazione rapida

Lezione 8 di 12 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Design: Mockup e prototipazione rapida
  2. Mockup di interfacce utente
  3. Esplorare molteplici direzioni visive
  4. Prototipazione di packaging
  5. Moodboard automatizzati
  6. Set di icone coerenti
  7. Affinare un mockup tramite editing
  8. Dove si ferma la prototipazione con IA

Aggiornato il 2 novembre 2026 — Modelli immagine. gpt-image-1, il modello per cui questo corso era stato originariamente scritto, è stato dismesso il 23 ottobre 2026. gpt-image-1.5, gpt-image-1-mini e chatgpt-image-latest verranno ritirati il 1° dicembre 2026. Gli esempi utilizzano ora gpt-image-2.5-sunburst, che offre la massima precisione per le modifiche; gpt-image-2.5-flare è più veloce per la generazione standard. Entrambi i modelli supportano anche le impostazioni di qualità xhigh e max. I modelli GPT Image restituiscono sempre le immagini in base64: il parametro response_format dei vecchi modelli DALL·E non è più accettato ed è stato rimosso dal codice. Fonte: Generazione di immagini (OpenAI).

Design: Mockup e prototipazione rapida

GPT Image cambia la fase di design meno grazie alla qualità del suo output che grazie al basso costo dello scarto. Esplorare tre direzioni visive per una homepage richiedeva un giorno in uno strumento di design; ora bastano pochi minuti. Questo ti permette di esplorare sei direzioni e abbandonarne cinque senza esitazione. Questa lezione ti mostra come sfruttare questa libertà senza confondere l’esplorazione con la produzione.

Mockup di interfacce utente

Un mockup generato serve a scegliere una direzione, non a essere sezionato in componenti. Il tuo prompt deve quindi puntare alla credibilità visiva: componenti UI realistici, tipografia chiara, spaziatura professionale, una palette di colori coerente e una dichiarazione del livello di fedeltà atteso—in questo caso, “render ad alta fedeltà nello stile di Figma/Sketch”. Nota come la funzione seleziona la risoluzione: 1024×1536 verticale per mobile, 1536×1024 orizzontale per desktop. Generare una schermata mobile in un frame orizzontale produrrebbe un mockup che non assomiglia affatto a un dispositivo reale.

from openai import OpenAI
import base64

client = OpenAI()

def ui_mockup(description: str, platform: str, output: str):
    """Genera un mockup di interfaccia utente."""
    prompt = (
        f"Mockup UI/UX per {platform}: {description}, "
        "design moderno e pulito, componenti UI realistici, "
        "tipografia chiara, spaziatura professionale, "
        "palette di colori coerente, "
        "render ad alta fedeltà nello stile di Figma/Sketch"
    )

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1536" if platform == "mobile" else "1536x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Mockup {platform}: {output}")


ui_mockup(
    "dashboard analitico con grafici, schede KPI e barra di navigazione laterale",
    "desktop",
    "dashboard_mockup.png"
)

ui_mockup(
    "app di fitness tracking con schermata home, statistiche e cronologia",
    "mobile",
    "fitness_app_mockup.png"
)

Esplorare molteplici direzioni visive

All’inizio di un progetto, la domanda non è «qual è il mockup giusto?», ma «quali famiglie estetiche meritano di essere mostrate al cliente?». La funzione explore_directions risponde esattamente a questa esigenza mantenendo costante il concetto—una homepage per una piattaforma di apprendimento online—e variando solo due assi: direzione artistica e palette di colori. I tre percorsi proposti non sono variazioni sottili: minimalismo aziendale in bianco e blu navy, moderno e colorato in viola e arancione, e premium scuro in nero e blu elettrico mirano a tre posizionamenti di brand diversi. È proprio questa gamma a rendere utile la presentazione.

from openai import OpenAI
import base64

client = OpenAI()

def explore_directions(concept: str, directions: list[dict], prefix: str):
    """Genera molteplici direzioni visive per lo stesso concetto."""
    for i, direction in enumerate(directions):
        prompt = (
            f"{concept}, "
            f"direzione artistica: {direction['style']}, "
            f"palette: {direction['palette']}, "
            "render professionale di alta qualità"
        )

        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=prompt,
            size="1024x1024",
            quality="high",
        )

        path = f"{prefix}_direction_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        print(f"Direzione {i+1} ({direction['style'][:30]}) → {path}")


explore_directions(
    "Homepage per una piattaforma di apprendimento online",
    [
        {
            "style": "minimalismo aziendale, molto spazio bianco",
            "palette": "bianco, blu navy, grigio chiaro"
        },
        {
            "style": "moderno e colorato, illustrazioni flat design",
            "palette": "viola, arancione, bianco"
        },
        {
            "style": "scuro e premium, sfumature sottili",
            "palette": "nero, blu elettrico, oro"
        },
    ],
    "landing_page"
)

Prototipazione di packaging

Il packaging è probabilmente il dominio in cui il guadagno è più drammatico, perché un prototipo fisico è costoso e arriva in ritardo. Il prompt qui separa deliberatamente tre input—il prodotto, lo stile e gli elementi richiesti—per poi imporre una messa in scena costante: una vista a 3/4 appoggiata su una superficie, render fotorealistico con ombre morbide. I due esempi illustrano la gamma che questa struttura gestisce senza battere ciglio: un sacchetto di carta kraft per tè biologico con tipografia scritta a mano e una finestra trasparente su un lato, un barattolo di crema bianco e oro con lettering dorato sull’altro.

from openai import OpenAI
import base64

client = OpenAI()

def packaging_prototype(product: str, style: str, elements: str, output: str):
    """Genera un prototipo di packaging prodotto."""
    prompt = (
        f"Design di packaging per {product}, "
        f"stile: {style}, "
        f"elementi: {elements}, "
        "vista a 3/4 del packaging appoggiato su una superficie, "
        "render fotorealistico con ombre morbide, "
        "design professionale pronto per la presentazione al cliente"
    )

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Prototipo packaging: {output}")


packaging_prototype(
    "tè biologico premium in sacchetto kraft",
    "naturale e artigianale, tipografia scritta a mano",
    "logo foglia di tè, nome prodotto, etichetta biologica, finestra trasparente",
    "packaging_tea.png"
)

packaging_prototype(
    "crema idratante di alta gamma in barattolo",
    "lusso minimalista, bianco e oro",
    "logo centrato, nome del brand in lettering oro, capacità 50ml",
    "packaging_cream.png"
)

Moodboard automatizzati

Un moodboard trasmette un’intenzione prima di mostrare una soluzione. Invece di costruire una bacheca a mano aggregando riferimenti, descrivi il tema e gli ingredienti visivi, poi chiedi una composizione a griglia asimmetrica nello stile di Pinterest. L’esempio di uno spazio di coworking moderno mostra il livello di dettaglio utile: non ti limiti a nominare il luogo, elenchi interni luminosi con piante, mobili scandinavi, texture di legno e cemento, presenza umana rilassata e una palette terracotta, verde salvia e bianco sporco. Questi cinque input conferiscono coerenza al risultato.

from openai import OpenAI
import base64

client = OpenAI()

def generate_moodboard(theme: str, elements: list[str], output: str):
    """Genera un moodboard visivo per un dato tema."""
    elements_str = ", ".join(elements)
    prompt = (
        f"Moodboard professionale per il tema \"{theme}\", "
        f"inclusi: {elements_str}, "
        "composizione a griglia asimmetrica nello stile di Pinterest, "
        "foto e texture varie, palette coerente, "
        "stile di direzione artistica per presentazione agenzia"
    )

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Moodboard: {output}")


generate_moodboard(
    "Spazio di coworking moderno",
    [
        "interni luminosi con piante",
        "mobili di design scandinavo",
        "texture di legno e cemento",
        "persone che lavorano in modo rilassato",
        "palette terracotta, verde salvia, bianco sporco"
    ],
    "moodboard_coworking.png"
)

Set di icone coerenti

Una singola icona è facile; un set coerente è difficile, perché la coerenza si basa su dettagli invisibili a un prompt ingenuo. La funzione icon_set li rende espliciti: reinietta il tema e lo stile per ogni icona, richiede uno sfondo trasparente o bianco, inquadratura centrata, spessore del tratto uniforme e proporzioni quadrate, e ricorda al modello che l’immagine appartiene a un set. Per le cinque icone di un’app B2B SaaS—dashboard, utenti, impostazioni, notifiche, analitica—è proprio questo promemoria a impedire di ottenere cinque stili grafici diversi. L’uso di uno slug garantisce nomi di file puliti, gestendo apostrofi e spazi.

from openai import OpenAI
import base64

client = OpenAI()

def icon_set(theme: str, icons: list[str], style: str, output_prefix: str):
    """Genera un set coerente di icone."""
    for icon in icons:
        prompt = (
            f"Singola icona che rappresenta \"{icon}\", "
            f"tema: {theme}, "
            f"stile: {style}, "
            "sfondo trasparente o bianco, centrata, "
            "design coerente all'interno di un set di icone, "
            "spessore del tratto uniforme, proporzioni quadrate"
        )

        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=prompt,
            size="1024x1024",
            quality="high",
        )

        slug = icon.lower().replace(" ", "_").replace("'", "")
        path = f"{output_prefix}_{slug}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        print(f"Icona {icon} → {path}")


icon_set(
    theme="Applicazione B2B SaaS",
    icons=["dashboard", "users", "settings", "notifications", "analytics"],
    style="line art, tratto 2px, blu navy, angoli arrotondati",
    output_prefix="icon"
)

Affinare un mockup tramite editing

Rigenerare un intero mockup per correggere una singola area ti fa perdere tutto ciò che era già soddisfacente altrove. Il flusso di lavoro qui sotto procede diversamente: genera prima una homepage completa per un’app di gestione progetti, poi apre una finestra nella maschera tra l’8% e il 45% dell’altezza—cioè sotto l’intestazione e sopra i blocchi delle funzionalità—per rigenerare solo la sezione hero. L’intestazione, la navigazione e i tre blocchi rimangono rigorosamente identici tra la v1 e la v2, rendendo il confronto onesto: vedi l’effetto della tua modifica e nient’altro.

from openai import OpenAI
from PIL import Image, ImageDraw
import base64

client = OpenAI()

# Passo 1: Genera il mockup iniziale
response = client.images.generate(
    model="gpt-image-2.5-sunburst",
    prompt=(
        "Mockup homepage per un'applicazione di gestione progetti, "
        "design moderno, intestazione con navigazione, sezione hero con illustrazione, "
        "3 blocchi funzionalità, sfondo bianco"
    ),
    size="1024x1536",
    quality="high",
)

data = base64.b64decode(response.data[0].b64_json)
with open("mockup_v1.png", "wb") as f:
    f.write(data)
print("Mockup v1 generato")

# Passo 2: Modifica la sezione hero tramite editing
source = Image.open("mockup_v1.png")
w, h = source.size
mask = Image.new("RGBA", (w, h), (0, 0, 0, 255))
draw = ImageDraw.Draw(mask)
# Area hero: parte superiore (sotto l'intestazione)
draw.rectangle([0, int(h * 0.08), w, int(h * 0.45)], fill=(0, 0, 0, 0))
mask.save("mask_hero.png")

response = client.images.edit(
    model="gpt-image-2.5-sunburst",
    image=open("mockup_v1.png", "rb"),
    mask=open("mask_hero.png", "rb"),
    prompt=(
        "Sezione hero con un'illustrazione isometrica 3D di una kanban board, "
        "titolo 'Manage Your Projects Simply', pulsante CTA blu, sfondo a sfumatura sottile"
    )
)

with open("mockup_v2.png", "wb") as f:
    f.write(base64.b64decode(response.data[0].b64_json))
print("Mockup v2 con hero modificato")

Dove si ferma la prototipazione con IA

Devi essere chiaro sullo status di ciò che produci qui. I mockup generati sono esplorazioni visive, non file di produzione: il testo è ben reso ma può contenere errori minori, i componenti non sono né interattivi né esportabili in Figma e la coerenza tra più schermate nello stesso flusso utente non è garantita. Un designer che ricevesse queste immagini come deliverable finale avrebbe ragione a obiettare.

Il loro valore sta altrove, ed è considerevole: servono a validare una direzione prima di investire nel design finale. Scegliere tra tre percorsi in un’ora invece che in tre giorni, arrivare a un incontro con il cliente con immagini invece che con aggettivi, eliminare una falsa buona idea prima che consumi una settimana di produzione—ecco cosa ti compra realmente la prototipazione con IA.

Per convincertene, costruisci il tuo strumento di avvio progetto: uno script che, partendo da un brief, genera tre direzioni visive per una homepage, un moodboard associato per ciascuna e un catalogo HTML comparativo che ti permette di presentarle fianco a fianco.