Design : Maquettes et prototypage rapide
På denna sida
Mis à jour le 2 novembre 2026 — Modèles d’image.
gpt-image-1, le modèle pour lequel ce cours a été initialement rédigé, a été arrêté le 23 octobre 2026.gpt-image-1.5,gpt-image-1-minietchatgpt-image-latestseront retirés le 1er décembre 2026. Les exemples utilisent désormaisgpt-image-2.5-sunburst, qui offre la plus grande précision pour l’édition ;gpt-image-2.5-flareest plus rapide pour la génération standard. Les deux modèles prennent également en charge les paramètres de qualitéxhighetmax. Les modèles GPT Image renvoient toujours des images en base64 : le paramètreresponse_formatdes anciens modèles DALL·E n’est plus accepté et a été supprimé du code. Source : Génération d’images (OpenAI).
Design : Maquettes et prototypage rapide
GPT Image transforme la phase de conception moins par la qualité de ses résultats que par le faible coût de leur abandon. Explorer trois directions visuelles pour une page d’accueil prenait autrefois une journée dans un outil de design ; cela prend maintenant quelques minutes. Cela te permet d’explorer six directions et d’en abandonner cinq sans hésitation. Cette leçon t’apprend à utiliser cette liberté sans confondre exploration et production.
Maquettes d’interface utilisateur
Une maquette générée sert à choisir une direction, pas à être découpée en composants. Ton prompt doit donc viser la crédibilité visuelle : composants d’interface réalistes, typographie claire, espacement professionnel, palette de couleurs cohérente et indication du niveau de fidélité attendu — dans ce cas, « rendu haute fidélité dans le style de Figma/Sketch ». Remarque comment la fonction sélectionne la résolution : 1024×1536 en portrait pour le mobile, 1536×1024 en paysage pour le bureau. Générer un écran mobile dans un cadre paysage produirait une maquette qui ne ressemble en rien à un appareil réel.
from openai import OpenAI
import base64
client = OpenAI()
def ui_mockup(description: str, platform: str, output: str):
"""Generate a user interface mockup."""
prompt = (
f"UI/UX mockup for {platform}: {description}, "
"modern and clean design, realistic UI components, "
"clear typography, professional spacing, "
"consistent color palette, "
"high-fidelity render in the style of 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"{platform} mockup: {output}")
ui_mockup(
"analytics dashboard with charts, KPI cards, and navigation sidebar",
"desktop",
"dashboard_mockup.png"
)
ui_mockup(
"fitness tracking app with home screen, statistics, and history",
"mobile",
"fitness_app_mockup.png"
)
Explorer plusieurs directions visuelles
Au début d’un projet, la question n’est pas « quelle est la bonne maquette ? » mais « quelles familles esthétiques méritent d’être présentées au client ? ». La fonction explore_directions répond exactement à ce besoin en maintenant le concept constant — une page d’accueil pour une plateforme d’apprentissage en ligne — et en ne faisant varier que deux axes : la direction artistique et la palette de couleurs. Les trois voies proposées ne sont pas de subtiles variations : minimalisme d’entreprise en blanc et bleu marine, moderne et coloré en violet et orange, et premium sombre en noir et bleu électrique ciblent trois positionnements de marque différents. C’est cet éventail qui rend la présentation utile.
from openai import OpenAI
import base64
client = OpenAI()
def explore_directions(concept: str, directions: list[dict], prefix: str):
"""Generate multiple visual directions for the same concept."""
for i, direction in enumerate(directions):
prompt = (
f"{concept}, "
f"art direction: {direction['style']}, "
f"palette: {direction['palette']}, "
"professional high-quality render"
)
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"Direction {i+1} ({direction['style'][:30]}) → {path}")
explore_directions(
"Homepage for an online learning platform",
[
{
"style": "corporate minimal, lots of white space",
"palette": "white, navy blue, light gray"
},
{
"style": "modern and colorful, flat design illustrations",
"palette": "purple, orange, white"
},
{
"style": "dark and premium, subtle gradients",
"palette": "black, electric blue, gold"
},
],
"landing_page"
)
Prototypage d’emballages
L’emballage est probablement le domaine où le gain est le plus spectaculaire, car un prototype physique est coûteux et arrive tardivement. Le prompt ici sépare délibérément trois entrées — le produit, le style et les éléments requis — puis impose une mise en scène constante : une vue aux trois quarts posée sur une surface, un rendu photoréaliste avec des ombres douces. Les deux exemples illustrent l’étendue que cette structure gère sans sourciller : un sac en papier kraft pour du thé biologique avec une typographie manuscrite et une fenêtre transparente sur un côté, un pot de crème blanc et or avec une lettrage doré de l’autre.
from openai import OpenAI
import base64
client = OpenAI()
def packaging_prototype(product: str, style: str, elements: str, output: str):
"""Generate a product packaging prototype."""
prompt = (
f"Packaging design for {product}, "
f"style: {style}, "
f"elements: {elements}, "
"3/4 view of packaging resting on a surface, "
"photorealistic render with soft shadows, "
"professional design ready for client presentation"
)
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"Packaging prototype: {output}")
packaging_prototype(
"premium organic tea in a kraft bag",
"natural and artisanal, handwritten typography",
"tea leaf logo, product name, organic label, transparent window",
"packaging_tea.png"
)
packaging_prototype(
"high-end moisturizing cream in a jar",
"minimalist luxury, white and gold",
"centered logo, brand name in gold lettering, 50ml capacity",
"packaging_cream.png"
)
Planches d’ambiance automatisées
Une planche d’ambiance (moodboard) transmet une intention avant de montrer une solution. Plutôt que de construire une planche à la main en aggregant des références, tu décris le thème et les ingrédients visuels, puis tu demandes une composition en grille asymétrique dans le style de Pinterest. L’exemple d’un espace de coworking moderne montre le niveau de détail utile : tu ne te contentes pas de nommer le lieu, tu listes l’intérieur lumineux avec des plantes, le mobilier scandinave, les textures bois et béton, la présence humaine détendue et une palette terracotta, vert sauge et blanc cassé. Ces cinq entrées donnent sa cohérence au résultat.
from openai import OpenAI
import base64
client = OpenAI()
def generate_moodboard(theme: str, elements: list[str], output: str):
"""Generate a visual moodboard for a given theme."""
elements_str = ", ".join(elements)
prompt = (
f"Professional moodboard for the theme \"{theme}\", "
f"including: {elements_str}, "
"asymmetric grid composition in the style of Pinterest, "
"varied photos and textures, consistent palette, "
"art direction style for agency presentation"
)
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(
"Modern coworking space",
[
"bright interior with plants",
"Scandinavian design furniture",
"wood and concrete textures",
"people working in a relaxed manner",
"terracotta, sage green, off-white palette"
],
"moodboard_coworking.png"
)
Ensembles d’icônes cohérents
Une seule icône est facile ; un ensemble cohérent est difficile, car la cohérence repose sur des détails invisibles pour un prompt naïf. La fonction icon_set les rend explicites : elle réinjecte le thème et le style pour chaque icône, exige un fond transparent ou blanc, un cadrage centré, une épaisseur de trait uniforme et des proportions carrées, et rappelle au modèle que l’image appartient à un ensemble. Pour les cinq icônes d’une application B2B SaaS — tableau de bord, utilisateurs, paramètres, notifications, analytiques — c’est ce rappel qui t’empêche d’obtenir cinq styles graphiques différents. L’utilisation d’un slug assure des noms de fichiers propres, gérant les apostrophes et les espaces.
from openai import OpenAI
import base64
client = OpenAI()
def icon_set(theme: str, icons: list[str], style: str, output_prefix: str):
"""Generate a consistent set of icons."""
for icon in icons:
prompt = (
f"Single icon representing \"{icon}\", "
f"theme: {theme}, "
f"style: {style}, "
"transparent or white background, centered, "
"consistent design within an icon set, "
"uniform stroke weight, square proportions"
)
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"Icon {icon} → {path}")
icon_set(
theme="B2B SaaS application",
icons=["dashboard", "users", "settings", "notifications", "analytics"],
style="line art, 2px stroke, navy blue, rounded corners",
output_prefix="icon"
)
Affiner une maquette par édition
Régénérer une maquette entière pour corriger une seule zone te fait perdre tout ce qui était déjà satisfaisant ailleurs. Le flux de travail ci-dessous procède différemment : il génère d’abord une page d’accueil complète pour une application de gestion de projet, puis ouvre une fenêtre dans le masque entre 8 % et 45 % de la hauteur — c’est-à-dire sous l’en-tête et au-dessus des blocs de fonctionnalités — pour rejouer uniquement la section hero. L’en-tête, la navigation et les trois blocs restent strictement identiques entre la v1 et la v2, rendant la comparaison honnête : tu vois l’effet de ton changement, et rien d’autre.
from openai import OpenAI
from PIL import Image, ImageDraw
import base64
client = OpenAI()
# Step 1: Generate the initial mockup
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=(
"Homepage mockup for a project management application, "
"modern design, header with navigation, hero section with illustration, "
"3 feature blocks, white background"
),
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 generated")
# Step 2: Modify the hero section via 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)
# Hero area: upper part (below the header)
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=(
"Hero section with a 3D isometric illustration of a kanban board, "
"title 'Manage Your Projects Simply', blue CTA button, subtle gradient background"
)
)
with open("mockup_v2.png", "wb") as f:
f.write(base64.b64decode(response.data[0].b64_json))
print("Mockup v2 with modified hero")
Où s’arrête le prototypage par IA
Tu dois être clair sur le statut de ce que tu produis ici. Les maquettes générées sont des explorations visuelles, pas des fichiers de production : le texte est bien rendu mais peut contenir des erreurs mineures, les composants ne sont ni interactifs ni exportables vers Figma, et la cohérence sur plusieurs écrans dans le même parcours utilisateur n’est pas garantie. Un designer recevant ces images comme livrable final serait en droit de s’y opposer.
Leur valeur réside ailleurs, et elle est considérable : elles servent à valider une direction avant d’investir dans le design final. Choisir entre trois voies en une heure au lieu de trois jours, arriver à un rendez-vous client avec des images plutôt que des adjectifs, éliminer une fausse bonne idée avant qu’elle ne consume une semaine de production — voilà ce que t’apporte réellement le prototypage par IA.
Pour t’en convaincre, construis ton propre outil de lancement de projet : un script qui, à partir d’un brief, génère trois directions visuelles pour une page d’accueil, une planche d’ambiance associée pour chacune, et un catalogue HTML comparatif qui te permet de les présenter côte à côte.