Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Design: Mockups e Prototipagem Rápida

Aula 8 de 12 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Design: Mockups e Prototipagem Rápida
  2. Mockups de Interface de Utilizador
  3. Explorar Múltiplas Direções Visuais
  4. Prototipagem de Embalagens
  5. Moodboards Automatizados
  6. Conjuntos de Ícones Consistentes
  7. Refinar um Mockup Através de Edição
  8. Onde a Prototipagem com IA Termina

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. O gpt-image-1.5, gpt-image-1-mini e chatgpt-image-latest serão aposentados em 1 de dezembro de 2026. Os exemplos agora utilizam o gpt-image-2.5-sunburst, que oferece a maior precisão para edição; o gpt-image-2.5-flare é mais rápido para geração padrão. Ambos os modelos também suportam as definições de qualidade xhigh e max. Os modelos GPT Image devolvem sempre imagens em base64: o parâmetro response_format dos 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.