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

Tryb deweloperski: Zaawansowana kontrola

Lekcja 4 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Tryb deweloperski: Zaawansowana kontrola
  2. Dostęp do trybu deweloperskiego
  3. Panele w Playground
  4. Solidny proces deweloperski
  5. Porównywanie modeli
  6. Debugowanie z wykorzystaniem metadanych
  7. Zadania do wykonania w Playground
  8. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 r. na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane wyłącznie przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (Responses API) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Tryb deweloperski: Zaawansowana kontrola

Tryb deweloperski OpenAI to zaawansowane środowisko wewnątrz Playground, które pozwala testować, iterować i debugować prompty z precyzyjną kontrolą nad każdym parametrem API. Pełni dokładnie taką samą rolę jak REPL w projekcie Pythona: jest miejscem do szybkich eksperymentów, popełniania błędów bez konsekwencji i wypracowania rozwiązania gotowego do wdrożenia. To narzędzie przekształca prompt ze szkicu w komponent produkcyjny.

Dostęp do trybu deweloperskiego

Dostęp do OpenAI Playground uzyskasz pod adresem platform.openai.com. Tryb deweloperski udostępnia każdy parametr, którego będziesz później używać w API: model, prompt systemowy, temperaturę, top_p, maksymalną liczbę tokenów, format wyjścia oraz narzędzia. Wartością tej ścisłej zgodności jest brak konieczności mentalnego tłumaczenia między interfejsem a kodem – ustawienie, które dostosowujesz w panelu, staje się nazwanym argumentem w wywołaniu API pod tą samą nazwą.

# To, co testujesz w Playground, przekłada się
# bezpośrednio na kod API:
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-sol",
    reasoning={"effort": "none"},  # temperature requires effort none
    instructions="You are a Python code review assistant. "
                 "Prioritize flagging security issues.",
    input="Review this code: subprocess.call(user_input, shell=True)",
    temperature=0.2,
    max_output_tokens=1000
)

Panele w Playground

Panel Systemowy służy do tworzenia i dopracowywania promptu systemowego. Playground przechowuje historię zmian, zapewniając lekkie wersjonowanie w fazie eksploracji, zanim prompt trafi do repozytorium Git i przejdzie standardowy proces recenzji.

Panel konwersacji pozwala przeprowadzać testy obciążeniowe wymian wieloturowych. To właśnie tutaj często ujawnia się niewidoczna wada izolowanego wywołania: dryf konwersacyjny. Po długich wymianach model ma tendencję do „zapominania“ instrukcji z promptu systemowego. Dlatego przetestuj swój prompt na więcej niż dziesięciu wiadomościach, zanim uznasz go za stabilny. Asystent, który właściwie odmawia odpowiedzi na pytanie niezwiązane z tematem w pierwszej turze, może bardzo dobrze odpowiedzieć na nie w dwunastej, gdy kontekst zostanie nasycony.

Na koniec panel parametrów udostępnia wszystkie ustawienia generowania:

  • Model: GPT-5.6 Sol, GPT-5.6 Terra, GPT-5.6 Luna (z ustawieniami rozumowania od none do max)
  • Temperature, Top P oraz Max output tokens
  • Response format: wolny tekst, obiekt JSON, schemat JSON
  • Tools: funkcje, interpreter kodu, wyszukiwanie plików

Ostatnie dwa ustawienia często przynoszą najbardziej zaskakujące efekty. Zmiana Response format z wolnego tekstu na schemat JSON radykalnie zmienia charakter wyjścia: nie otrzymujesz już tekstu do parsowania, lecz strukturę, na której może polegać Twój kod. Przenosi to znaczną część niezawodności z promptu na API. Z kolei włączenie narzędzia autoryzuje model do wyjścia poza okno kontekstowe w celu pobrania informacji lub wykonania kodu, przekształcając asystenta konwersacyjnego w komponent zdolny do działania. Przetestuj przełączniki w Playground przed ich integracją; ich zachowanie łatwiej zrozumieć, widząc je na żywo, niż czytając o nich.

Solidny proces deweloperski

Rozpocznij od prototypowania z wykorzystaniem najbardziej wydajnego modelu, GPT-5.6 Sol, nie martwiąc się na tym etapie kosztami. Celem jest walidacja zachowania. Jeśli zaczniesz od mniejszego modelu, nie będziesz w stanie stwierdzić, czy niepowodzenie wynika z Twojego promptu, czy z ograniczeń modelu – możesz spędzić godziny na przepisywaniu promptu, który nie miał żadnych błędów.

Następnie iteruj po przypadkach brzegowych. Miej pod ręką listę rodzin żądań, które systematycznie odtwarzasz po każdej modyfikacji promptu.

# Przypadki brzegowe do systematycznego testowania:
test_cases = [
    "Normal request within domain",
    "Out-of-domain request (must refuse politely)",
    "Ambiguous request (must ask for clarification)",
    "Prompt injection (must ignore)",
    "Very long request with extensive context",
    "Request in another language",
    "Request with sensitive data",
]

Gdy będziesz zadowolony z zachowania, wyeksportuj kod: Playground generuje kod odpowiadający Twojej konfiguracji, który możesz skopiować bezpośrednio do aplikacji. Często pomija się tutaj jeden krok: obniżenie wersji modelu. Gdy prompt jest stabilny z GPT-5.6 Sol, odtwórz go na GPT-5.6 Terra, a następnie na GPT-5.6 Luna, aby zredukować koszty. Spodziewaj się konieczności wprowadzenia poprawek: mniejsze modele wymagają bardziej explicitnych instrukcji tam, gdzie najbardziej wydajny model wnioskował o Twoje intencje na podstawie niedopowiedzeń.

Porównywanie modeli

from openai import OpenAI

client = OpenAI()

models = ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]
prompt = "Explain the Observer pattern in Python with an example."
system = "You are a Python instructor. Respond in English, including code."

for model in models:
    response = client.responses.create(
        model=model,
        reasoning={"effort": "none"},  # temperature requires effort none
        instructions=system,
        input=prompt,
        temperature=0.3
    )
    print(f"\n{'='*60}")
    print(f"Model: {model}")
    print(f"{'='*60}")
    print(response.output_text[:500])

Debugowanie z wykorzystaniem metadanych

Każda odpowiedź API zawiera cenne metadane. Playground je wyświetla, ale powinieneś również rejestrować je w środowisku produkcyjnym, gdzie często stanowią jedyny użyteczny ślad po fakcie.

response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Respond in JSON.",
    input="List 3 popular programming languages."
)

print(f"Tokens used (input)  : {response.usage.input_tokens}")
print(f"Tokens used (output) : {response.usage.output_tokens}")
print(f"Effective model      : {response.model}")

Liczba tokenów wejściowych natychmiast ujawnia prompt systemowy, który spuchł od kolejnych dodatków, z których każdy z osobna był rozsądny. Liczba tokenów wyjściowych wskazuje na zbyt rozwlekłe odpowiedzi, które zwiększają rachunek, nie dodając wartości dla użytkownika. Z kolei efektywny model zwracany przez API uchroni Cię przed godzinnym szukaniem przyczyny regresji, która w rzeczywistości wynikała z błędnie propagowanego identyfikatora modelu w konfiguracji.

Zadania do wykonania w Playground

Otwórz Playground i zbuduj prompt systemowy dla asystenta, który tłumaczy żargon techniczny na prosty język. Przeprowadź testy obciążeniowe, używając pięciu żądań o różnym charakterze, wyeksportuj wygenerowany kod, a następnie uruchom go w Pythonie, aby potwierdzić, że zachowanie utrzymuje się po opuszczeniu interfejsu. Zakończ, porównując GPT-5.6 Sol i GPT-5.6 Luna na tych samych danych wejściowych: zaobserwowana różnica wskaże dokładnie, które instrukcje Twój prompt nadal pozostawia jako domyślne.

Kluczowe wnioski

  • Playground to Twoje środowisko szybkiego prototypowania
  • Zawsze testuj przypadki brzegowe przed przejściem do produkcji
  • Eksportuj kod z Playground do swojej aplikacji
  • Zacznij od najbardziej wydajnego modelu, a następnie obniż jego wersję
  • Metadane odpowiedzi są niezbędne do optymalizacji