Przejdź do głównej treści
Polski— Wybierz język
Menu

Projektowanie: Makiety i szybkie prototypowanie

Lekcja 8 z 12 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Projektowanie: Makiety i szybkie prototypowanie
  2. Makiety interfejsu użytkownika
  3. Eksploracja wielu kierunków wizualnych
  4. Prototypowanie opakowań
  5. Zautomatyzowane moodboardy
  6. Spójne zestawy ikon
  7. Dopracowywanie makiety poprzez edycję
  8. Gdzie kończy się prototypowanie AI

Zaktualizowano 2 listopada 2026 — Modele obrazowe. Model gpt-image-1, dla którego pierwotnie napisano ten kurs, został wycofany 23 października 2026. Modele gpt-image-1.5, gpt-image-1-mini oraz chatgpt-image-latest zostaną wycofane 1 grudnia 2026. Przykłady wykorzystują obecnie model gpt-image-2.5-sunburst, który oferuje najwyższą precyzję podczas edycji; model gpt-image-2.5-flare jest szybszy przy standardowym generowaniu. Oba modele obsługują również ustawienia jakości xhigh i max. Modele GPT Image zawsze zwracają obrazy w formacie base64: parametr response_format ze 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.