AI Prompt Engineering · Lekcja

Modułowe sekcje promptu

Czytelnie oddzielaj kontekst, instrukcje, ograniczenia i format wyniku.

Modułowe sekcje promptu to bezpłatna lekcja AI Prompt Engineering na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Prompt Engineering, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Problem z monolitycznymi promptami

Monolityczny prompt umieszcza wszystko w jednym akapicie: informacje wprowadzające, zadanie, zasady, przykłady i format odpowiedzi są ze sobą wymieszane. Wraz ze wzrostem złożoności promptów monolityczna struktura powoduje:

stosowanie przez modele zasad do niewłaściwych sekcji
trudności z ustaleniem, która część spowodowała niepoprawny wynik
ciągi promptów niemożliwe do utrzymania
niespójne działanie w różnych wersjach modelu

Prompty modułowe rozwiązują wszystkie te problemy.

Pięć podstawowych sekcji promptu

Dobrze ustrukturyzowany prompt ma pięć odrębnych sekcji, z których każda ma jasno określony cel:

Kontekst — informacje wprowadzające potrzebne modelowi do zrozumienia sytuacji
Zadanie — jasno określone działanie, które model musi wykonać
Ograniczenia — zasady i limity dotyczące odpowiedzi
Format odpowiedzi — struktura, długość i schemat oczekiwanej odpowiedzi
Przykłady — demonstracje poprawnego działania

Nie każdy prompt wymaga wszystkich pięciu sekcji. Należy używać tylko tych, które są potrzebne.

Sekcja kontekstu

Sekcja kontekstu zawiera informacje wprowadzające, ale nie mówi modelowi, co ma zrobić. Dobry kontekst obejmuje:

informacje o użytkowniku końcowym
informacje o platformie lub produkcie, dla którego przeznaczony jest prompt
istotną wiedzę dziedzinową
wcześniejszy stan, który model powinien znać

context_section = '''
<context>
You are assisting a customer support agent at a B2B SaaS company.
The company sells project management software used by engineering teams.
Customers are typically CTOs, engineering managers, or senior developers.
The support agent is handling a live chat conversation with a customer.
</context>
'''

print(context_section)

Sekcja zadania

Sekcja zadania dokładnie określa, co model ma wygenerować. Powinna być konkretna, ukierunkowana na działanie i pozbawiona zbędnych informacji wprowadzających.

task_section = '''
<task>
Draft a response to the customer message below.
The response should:
1. Acknowledge the customer's issue
2. Provide a concrete next step
3. Set a realistic expectation for resolution time
</task>

<customer_message>
Our Gantt chart view stopped loading after the last update.
This is blocking our sprint planning session today.
</customer_message>
'''

print(task_section)

Sekcja ograniczeń

Ograniczenia wyznaczają granice — określają, czego model NIE może robić, oraz wyraźne limity, których musi przestrzegać.

constraints_section = '''
<constraints>
- Do not promise a fix by a specific date unless you are certain.
- Do not mention competitor products by name.
- Keep the response under 100 words.
- Use a professional but empathetic tone.
- Do not ask the customer for information already provided in their message.
</constraints>
'''

print(constraints_section)

Sekcja formatu odpowiedzi

Sekcja formatu odpowiedzi dokładnie informuje model, jak ma ustrukturyzować odpowiedź — na przykład według schematu JSON, z nagłówkami Markdown, jako zwykły tekst lub numerowaną listę.

output_format_section = '''
<output_format>
Respond with a JSON object containing:
{
  "subject": "string (email subject line)",
  "body": "string (email body, plain text, under 150 words)",
  "priority": "high | medium | low",
  "escalate": true | false
}
Do not include any text outside the JSON object.
</output_format>
'''

print(output_format_section)

Sekcja przykładów

Przykłady pokazują modelowi poprawną parę wejście-wyjście. Należy umieszczać je po ograniczeniach, aby model najpierw zapoznał się z zasadami, a dopiero potem z demonstracją.

examples_section = '''
<examples>
  <example>
    <input>Customer: My invoices are not downloading.</input>
    <output>{
      "subject": "Invoice Download Issue",
      "body": "Thank you for reaching out. We see the issue with invoice downloads and our team is investigating. We expect a fix within 2 hours. We will email you once resolved.",
      "priority": "high",
      "escalate": true
    }</output>
  </example>
</examples>
'''

print(examples_section)

Składanie modułowego promptu

Podejście modułowe ułatwia składanie i edytowanie promptu. Każdą sekcję można modyfikować niezależnie.

def build_support_prompt(customer_message):
    context = '<context>B2B SaaS customer support for project management software.</context>'
    task = f'<task>Draft a JSON response to this customer message.</task>\n<customer_message>{customer_message}</customer_message>'
    constraints = '<constraints>Under 100 words. Professional tone. No competitor names.</constraints>'
    output_fmt = '<output_format>Return JSON: {"subject": str, "body": str, "priority": str, "escalate": bool}</output_format>'
    return '\n\n'.join([context, task, constraints, output_fmt])

message = 'The Gantt chart stopped loading after your last update.'
print(build_support_prompt(message))

Korzyści podczas debugowania

Gdy modułowy prompt generuje niepoprawny wynik, można wyodrębnić problematyczną sekcję:

Wykonano niewłaściwe zadanie? — sprawdź sekcję Zadanie
Naruszono zasadę? — sprawdź sekcję Ograniczenia
Niewłaściwa struktura odpowiedzi? — sprawdź sekcję Format odpowiedzi
Niska jakość? — sprawdź sekcję Przykłady lub dodaj więcej kontekstu

Można zmieniać jedną sekcję naraz i ponownie testować prompt bez przepisywania całości.

Korzyści podczas utrzymania

Modułowe prompty przechowywane jako ustrukturyzowane obiekty lub funkcje są znacznie łatwiejsze w utrzymaniu niż długie literały tekstowe:

aktualizuj kontekst po zmianie produktu bez modyfikowania logiki zadania
zmień format odpowiedzi z JSON na Markdown bez zmiany ograniczeń
testuj A/B różne zestawy przykładów, pozostawiając wszystkie pozostałe elementy bez zmian
niezależnie kontroluj wersje poszczególnych sekcji

class Prompt:
    def __init__(self):
        self.context = ''
        self.task = ''
        self.constraints = []
        self.output_format = ''
        self.examples = []

    def build(self):
        parts = []
        if self.context:
            parts.append(f'<context>\n{self.context}\n</context>')
        if self.task:
            parts.append(f'<task>\n{self.task}\n</task>')
        if self.constraints:
            c = '\n'.join(f'- {r}' for r in self.constraints)
            parts.append(f'<constraints>\n{c}\n</constraints>')
        if self.output_format:
            parts.append(f'<output_format>\n{self.output_format}\n</output_format>')
        return '\n\n'.join(parts)

Kiedy pomijać sekcje

Nie każdy prompt wymaga wszystkich pięciu sekcji. Skorzystaj z poniższych wskazówek:

Pomiń kontekst, gdy zadanie jest samo w sobie zrozumiałe (np. przetłumacz to zdanie)
Pomiń ograniczenia w przypadku prostych zadań ekstrakcji, które nie mają sytuacji brzegowych
Pomiń przykłady, gdy zadanie jest proste lub model dobrze wykonuje je już w trybie zero-shot
Zawsze uwzględniaj zadanie i format odpowiedzi — są to minimalne wymagane sekcje

Nadmierne uszczegóławianie prostych promptów dodaje szum bez żadnych korzyści.

Szybkie sprawdzenie

Modułowy prompt generuje odpowiedź o niepoprawnej strukturze. Którą sekcję należy najpierw sprawdzić?

Sekcje modułowe — najważniejsze informacje

Modułowe sekcje promptu są podstawą łatwej w utrzymaniu i debugowaniu inżynierii promptów:

pięć podstawowych sekcji: Kontekst, Zadanie, Ograniczenia, Format odpowiedzi i Przykłady
każda sekcja ma jedną odpowiedzialność — ich mieszanie powoduje niejasności
modułowa struktura umożliwia debugowanie i testy A/B poszczególnych sekcji
przechowuj prompty jako ustrukturyzowane obiekty lub funkcje, a nie surowe ciągi znaków
pomijaj niepotrzebne sekcje — nadmierne uszczegóławianie dodaje szum
w każdym nietrywialnym prompcie zawsze uwzględniaj co najmniej Zadanie i Format odpowiedzi

Często zadawane pytania

Czy lekcja „Modułowe sekcje promptu” jest bezpłatna?

Tak — pełny tekst „Modułowe sekcje promptu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Prompt Engineering, przejdź na CoddyKit PRO. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Co nauczysz się w „Modułowe sekcje promptu”?

Czytelnie oddzielaj kontekst, instrukcje, ograniczenia i format wyniku. Ćwiczysz AI Prompt Engineering z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Prompt Engineering?

Nie wymagamy żadnego doświadczenia. AI Prompt Engineering w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Modułowe sekcje promptu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Prompt Engineering?

Tak. Każda lekcja AI Prompt Engineering zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do AI Prompt Engineering