Projektowanie: Makiety i szybkie prototypowanie
Na tej stronie
Zaktualizowano 2 listopada 2026 — Modele obrazowe. Model
gpt-image-1, dla którego pierwotnie napisano ten kurs, został wycofany 23 października 2026. Modelegpt-image-1.5,gpt-image-1-miniorazchatgpt-image-latestzostaną wycofane 1 grudnia 2026. Przykłady wykorzystują obecnie modelgpt-image-2.5-sunburst, który oferuje najwyższą precyzję podczas edycji; modelgpt-image-2.5-flarejest szybszy przy standardowym generowaniu. Oba modele obsługują również ustawienia jakościxhighimax. Modele GPT Image zawsze zwracają obrazy w formacie base64: parametrresponse_formatze starszych modeli DALL·E nie jest już akceptowany i został usunięty z kodu. Źródło: Image generation (OpenAI).
Projektowanie: Makiety i szybkie prototypowanie
GPT Image zmienia fazę projektowania nie tyle dzięki jakości swoich wyników, co dzięki niskiemu kosztowi ich odrzucenia. Eksploracja trzech kierunków wizualnych dla strony głównej kiedyś zajmowała dzień w narzędziu graficznym; teraz trwa kilka minut. Pozwala to zbadać sześć kierunków i porzucić pięć z nich bez wahania. Ta lekcja pokaże Ci, jak wykorzystać tę swobodę, nie myląc eksploracji z produkcją.
Makiety interfejsu użytkownika
Wygenerowana maketa służy do wyboru kierunku, a nie do cięcia na komponenty. Twój prompt musi więc dążyć do wiarygodności wizualnej: realistyczne komponenty UI, czytelna typografia, profesjonalne odstępy, spójna paleta kolorów oraz określenie oczekiwanego poziomu szczegółowości – w tym przypadku „render wysokiej wierności w stylu Figma/Sketch“. Zwróć uwagę, jak funkcja dobiera rozdzielczość: 1024×1536 w orientacji pionowej dla urządzeń mobilnych, 1536×1024 w poziomej dla komputerów stacjonarnych. Wygenerowanie ekranu mobilnego w kadrze poziomym dałoby makietę, która nie przypominałaby prawdziwego urządzenia.
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"
)
Eksploracja wielu kierunków wizualnych
Na początku projektu pytanie nie brzmi „która maketa jest właściwa?“, lecz „które rodziny estetyczne warto pokazać klientowi?“. Funkcja explore_directions odpowiada dokładnie na tę potrzebę, utrzymując koncepcję w stałej formie – strona główna platformy e-learningowej – i zmieniając tylko dwie osie: kierunek artystyczny i paletę kolorów. Trzy proponowane ścieżki to nie subtelne wariacje: korporacyjny minimalizm w bieli i granacie, nowoczesna kolorystyka w fioletach i pomarańczach oraz premium dark w czerni i elektrycznym błękicie celują w trzy różne pozycjonowania marki. To właśnie ten zakres czyni prezentację użyteczną.
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"
)
Prototypowanie opakowań
Opakowania to prawdopodobnie dziedzina, w której zysk jest najbardziej dramatyczny, ponieważ fizyczny prototyp jest drogi i pojawia się późno. Prompt tutaj celowo rozdziela trzy dane wejściowe – produkt, styl i wymagane elementy – a następnie narzuca stałą scenografię: widok 3/4 spoczywający na powierzchni, fotorealistyczny render z miękkimi cieniami. Dwa przykłady ilustrują zakres, jaki ta struktura obsługuje bez mrugnięcia okiem: torba z papieru kraft na herbatę ekologiczną z odręczną typografią i przezroczystym okienkiem z jednej strony oraz słoik z kremem w bieli i złocie ze złotym napisem z drugiej.
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"
)
Zautomatyzowane moodboardy
Moodboard przekazuje intencję, zanim pokaże rozwiązanie. Zamiast ręcznie budować tablicę, agregując odniesienia, opisujesz temat i wizualne składniki, a następnie prosisz o asymetryczną kompozycję siatki w stylu Pinterest. Przykład nowoczesnej przestrzeni coworkingowej pokazuje użyteczny poziom szczegółowości: nie nazywasz tylko miejsca, ale wymieniasz jasne wnętrze z roślinami, skandynawskie meble, tekstury drewna i betonu, zrelaksowaną obecność ludzi oraz paletę terakoty, szałwii i złamanej bieli. Te pięć danych wejściowych nadaje wynikowi spójność.
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"
)
Spójne zestawy ikon
Pojedyncza ikona jest łatwa; spójny zestaw jest trudny, ponieważ spójność opiera się na detalach niewidocznych dla naiwnego promptu. Funkcja icon_set czyni je jawnymi: ponownie wprowadza temat i styl dla każdej ikony, wymaga przezroczystego lub białego tła, wyśrodkowanego kadrowania, jednolitej grubości linii i kwadratowych proporcji oraz przypomina modelowi, że obraz należy do zestawu. W przypadku pięciu ikon aplikacji B2B SaaS – pulpit, użytkownicy, ustawienia, powiadomienia, analityka – to właśnie to przypomnienie zapobiega uzyskaniu pięciu różnych stylów graficznych. Użycie sluga zapewnia czyste nazwy plików, obsługując apostrofy i spacje.
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"
)
Dopracowywanie makiety poprzez edycję
Regenerowanie całej makiety w celu poprawy jednego obszaru powoduje utratę wszystkiego, co już było satysfakcjonujące gdzie indziej. Poniższy przepływ pracy działa inaczej: najpierw generuje kompletną stronę główną dla aplikacji do zarządzania projektami, a następnie otwiera okno w masce między 8% a 45% wysokości – czyli poniżej nagłówka i powyżej bloków funkcji – aby ponownie wygenerować tylko sekcję hero. Nagłówek, nawigacja i trzy bloki pozostają ściśle identyczne między wersją 1 a wersją 2, co czyni porównanie uczciwym: widzisz efekt swojej zmiany i nic więcej.
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")
Gdzie kończy się prototypowanie AI
Musisz mieć jasność co do statusu tego, co tutaj produkujesz. Wygenerowane makiety to eksploracje wizualne, a nie pliki produkcyjne: tekst jest dobrze oddany, ale może zawierać drobne błędy, komponenty nie są interaktywne ani eksportowalne do Figmy, a spójność między wieloma ekranami w tym samym przepływie użytkownika nie jest gwarantowana. Projektant otrzymujący te obrazy jako finalny deliverable miałby rację, zgłaszając sprzeciw.
Ich wartość leży gdzie indziej i jest ogromna: służą do walidacji kierunku przed zainwestowaniem w projekt końcowy. Wybór między trzema ścieżkami w godzinę zamiast trzech dni, przyjście na spotkanie z klientem z obrazami zamiast przymiotników, wyeliminowanie fałszywie dobrego pomysłu, zanim pochłonie tydzień produkcji – oto, co naprawdę kupujesz dzięki prototypowaniu AI.
Aby się o tym przekonać, zbuduj własne narzędzie do kickoffu projektu: skrypt, który na podstawie briefu generuje trzy kierunki wizualne dla strony głównej, powiązany moodboard dla każdego z nich oraz porównawczy katalog HTML, który pozwala zaprezentować je obok siebie.