Design: Mockups e Prototipagem Rápida
Nesta página
Atualizado em 2 de novembro de 2026 — Modelos de imagem. O
gpt-image-1, modelo para o qual este curso foi originalmente escrito, foi descontinuado em 23 de outubro de 2026. Ogpt-image-1.5,gpt-image-1-miniechatgpt-image-latestserão aposentados em 1 de dezembro de 2026. Os exemplos agora utilizam ogpt-image-2.5-sunburst, que oferece a maior precisão para edição; ogpt-image-2.5-flareé mais rápido para geração padrão. Ambos os modelos também suportam as definições de qualidadexhighemax. Os modelos GPT Image devolvem sempre imagens em base64: o parâmetroresponse_formatdos modelos DALL·E mais antigos já não é aceite e foi removido do código. Fonte: Image generation (OpenAI).
Design: Mockups e Prototipagem Rápida
O GPT Image altera a fase de design menos pela qualidade do seu output do que pelo baixo custo de o descartar. Explorar três direções visuais para uma homepage costumava levar um dia numa ferramenta de design; agora leva alguns minutos. Isto permite-lhe explorar seis direções e abandonar cinco sem hesitação. Esta lição mostra-lhe como usar essa liberdade sem confundir exploração com produção.
Mockups de Interface de Utilizador
Um mockup gerado serve para escolher uma direção, não para ser fatiado em componentes. O seu prompt deve, portanto, visar credibilidade visual: componentes de UI realistas, tipografia clara, espaçamento profissional, uma paleta de cores consistente e uma declaração do nível de fidelidade esperado — neste caso, “renderização de alta fidelidade no estilo Figma/Sketch”. Note como a função seleciona a resolução: 1024×1536 retrato para telemóvel, 1536×1024 paisagem para desktop. Gerar um ecrã de telemóvel num enquadramento de paisagem produziria um mockup que não se assemelha em nada a um dispositivo real.
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"
)
Explorar Múltiplas Direções Visuais
No início de um projeto, a questão não é «qual é o mockup correto?», mas «quais famílias estéticas merecem ser mostradas ao cliente?». A função explore_directions responde exatamente a essa necessidade, mantendo o conceito constante — uma homepage para uma plataforma de ensino online — e variando apenas dois eixos: direção de arte e paleta de cores. Os três caminhos propostos não são variações subtis: minimalismo corporativo em branco e azul-marinho, colorido moderno em roxo e laranja, e preto premium em preto e azul elétrico visam três posicionamentos de marca diferentes. É este leque que torna a apresentação útil.
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"
)
Prototipagem de Embalagens
A embalagem é provavelmente o domínio onde o ganho é mais dramático, porque um protótipo físico é caro e chega tarde. O prompt aqui separa deliberadamente três entradas — o produto, o estilo e os elementos necessários — e impõe uma encenação constante: uma vista de 3/4 repousando sobre uma superfície, renderização fotorrealista com sombras suaves. Os dois exemplos ilustram o leque que esta estrutura handling sem pestanejar: um saco de papel kraft para chá orgânico com tipografia manuscrita e uma janela transparente num lado, um frasco de creme branco e dourado com letras douradas no outro.
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"
)
Moodboards Automatizados
Um moodboard transmite uma intenção antes de mostrar uma solução. Em vez de construir um quadro à mão agregando referências, descreve o tema e os ingredientes visuais, pedindo depois uma composição em grelha assimétrica no estilo Pinterest. O exemplo de um espaço de coworking moderno mostra o nível de detalhe útil: não nomeia apenas o local, lista o interior luminoso com plantas, mobiliário escandinavo, texturas de madeira e betão, presença humana descontraída e uma paleta de terracota, verde-sálvia e branco-sujo. Estas cinco entradas conferem coerência ao resultado.
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"
)
Conjuntos de Ícones Consistentes
Um único ícone é fácil; um conjunto consistente é difícil, porque a consistência depende de detalhes invisíveis a um prompt ingénuo. A função icon_set torna-os explícitos: reinjeta o tema e o estilo para cada ícone, exige um fundo transparente ou branco, enquadramento centrado, espessura de traço uniforme e proporções quadradas, e lembra ao modelo que a imagem pertence a um conjunto. Para os cinco ícones de uma aplicação B2B SaaS — dashboard, utilizadores, definições, notificações, análises — é este lembrete que impede obter cinco estilos gráficos diferentes. Usar um slug garante nomes de ficheiros limpos, lidando com apóstrofes e espaços.
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"
)
Refinar um Mockup Através de Edição
Regenerar um mockup inteiro para corrigir uma única área faz-lhe perder tudo o que já estava satisfatório noutros locais. O fluxo de trabalho abaixo procede de forma diferente: primeiro gera uma homepage completa para uma aplicação de gestão de projetos, depois abre uma janela na máscara entre 8% e 45% da altura — ou seja, abaixo do cabeçalho e acima dos blocos de funcionalidades — para refazer apenas a secção hero. O cabeçalho, a navegação e os três blocos permanecem estritamente idênticos entre a v1 e a v2, tornando a comparação honesta: vê o efeito da sua alteração e nada mais.
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")
Onde a Prototipagem com IA Termina
Precisa de ser claro sobre o estatuto do que produz aqui. Os mockups gerados são explorações visuais, não ficheiros de produção: o texto está bem renderizado, mas pode conter erros menores, os componentes não são interativos nem exportáveis para o Figma, e a consistência entre múltiplos ecrãs no mesmo fluxo de utilizador não é garantida. Um designer que receba estas imagens como um entregável final teria razão em objetar.
O seu valor reside noutro lugar, e é considerável: servem para validar uma direção antes de investir no design final. Escolher entre três caminhos numa hora em vez de três dias, chegar a uma reunião com o cliente com imagens em vez de adjetivos, eliminar uma falsa boa ideia antes que esta consuma uma semana de produção — é isto que a prototipagem com IA realmente lhe compra.
Para se convencer, construa a sua própria ferramenta de arranque de projeto: um script que, a partir de um brief, gera três direções visuais para uma homepage, um moodboard associado para cada uma e um catálogo HTML comparativo que lhe permite apresentá-las lado a lado.