# Prompt Engineering 1: Asoslar (2026) — aniqlik, misollar, struktura va reasoning modellar

> **Holat:** 2026-yil sentabr. Model nomlari va parametrlar bir necha oyda o'zgaradi (2026-yil sentabrning o'zida OpenAI GPT-6 oilasini, Anthropic yangi Claude modellarini chiqardi). Shuning uchun bu dars **tamoyillarni** o'rgatadi, API misollari esa rasmiy hujjatlarga havola bilan beriladi.

## Mundarija

1. [Prompt engineering nima va nega hali ham kerak?](#nima)
2. [1-qoida: aniq va to'g'ridan-to'g'ri yozing](#aniqlik)
3. [2-qoida: "nega"ni tushuntiring](#motivatsiya)
4. [3-qoida: misollar (few-shot)](#misollar)
5. [4-qoida: XML teglar bilan struktura](#xml)
6. [5-qoida: rol va system prompt](#rol)
7. [Uzun hujjatlar bilan ishlash](#uzun-kontekst)
8. [Reasoning modellar: nima o'zgardi?](#reasoning)
9. [Structured outputs — kafolatlangan JSON](#structured)
10. [Oldin → keyin: 5 ta real misol](#oldin-keyin)
11. [Qayta ishlatiladigan shablon](#shablon)
12. [Xulosa](#xulosa)
13. [Manbalar](#manbalar)

---

## 1. Prompt engineering nima va nega hali ham kerak? {#nima}

**Prompt** — modelga beriladigan ko'rsatma va kontekst. **Prompt engineering** — model kerakli natijani barqaror berishi uchun shu matnni loyihalash.

2023-yilda "sehrli so'zlar" mashhur edi ("think step by step", "you are an expert…"). 2025–2026-yillarda **reasoning** (fikrlaydigan) modellar paydo bo'lgach, bunday hiylalarning ahamiyati kamaydi: fikrlash chuqurligi endi alohida **parametr** bilan boshqariladi (8-bo'lim). Lekin quyidagilar hali ham natijani to'g'ridan-to'g'ri belgilaydi:

- vazifa qanchalik **aniq** yozilgan;
- modelga qanday **kontekst** berilgan va nega;
- **misollar** va **struktura**;
- javob formati (masalan JSON schema).

Anthropic 2025-yilda bu yondashuvni **context engineering** deb atadi — "promptni chiroyli yozish"dan "modelga kerakli ma'lumotni kerakli vaqtda berish tizimi"ga o'tish. Bu haqda [Prompt Engineering 2](/ios-lessons/prompt-context-tools) darsida.

---

## 2. 1-qoida: aniq va to'g'ridan-to'g'ri yozing {#aniqlik}

Anthropic hujjatidagi eng foydali tasavvur: modelni **juda aqlli, lekin loyihangiz haqida hech narsa bilmaydigan yangi xodim** deb tasavvur qiling.

**Oltin qoida:** promptingizni loyihani bilmaydigan hamkasbingizga ko'rsating. U chalkashsa, model ham chalkashadi.

Yangi modellar ko'rsatmani **so'zma-so'z** bajaradi: aytilmagan narsani o'zidan qo'shish odati kamaygan. Shuning uchun istagan natijangizni ochiq ayting:

```text
Yomon:  Ilovaga login ekran qo'sh.

Yaxshi: iOS 17+ target uchun SwiftUI'da login ekran yarat:
        - email va parol maydonlari, "Kirish" tugmasi;
        - noto'g'ri email bo'lsa, maydon ostida xato matni;
        - login uchun mavjud AuthService.login(email:password:) async funksiyasini chaqir;
        - ranglar va shriftlarni DesignSystem.swift'dan ol, yangi rang qo'shma.
        Natija: bitta LoginView.swift fayli, preview bilan.
```

---

## 3. 2-qoida: "nega"ni tushuntiring {#motivatsiya}

Qoida bilan birga uning **sababini** ham yozsangiz, model uni o'xshash holatlarga to'g'ri qo'llaydi:

```text
Kam samarali: Hech qachon emoji ishlatma.

Samaraliroq:  Javoblaring Apple'ning VoiceOver ekran o'quvchisi orqali o'qiladi,
              shuning uchun emoji va dekorativ belgilar ishlatma — ular
              foydalanuvchiga ma'nosiz tovush bo'lib eshitiladi.
```

---

## 4. 3-qoida: misollar (few-shot) {#misollar}

Kerakli format yoki uslubni so'z bilan tushuntirishdan ko'ra **ko'rsatish** oson. Anthropic tavsiyasi — **3–5 ta** turli xil misol, `<example>` teglari ichida.

```text
Crash log'ning jiddiyligini aniqla: critical, high, medium yoki low.

<examples>
<example>
<log>EXC_BAD_ACCESS: force unwrap nil, CheckoutViewController.swift:42</log>
<severity>critical</severity>
</example>
<example>
<log>Non-fatal: image cache eviction, 200 MB threshold</log>
<severity>low</severity>
</example>
<example>
<log>Hang 2.4s on main thread while loading lesson list</log>
<severity>high</severity>
</example>
</examples>

<log>{{YANGI_LOG}}</log>
```

Ehtiyot bo'ling: misollar bir-biriga juda o'xshash bo'lsa, model ulardan kutilmagan "qolip"ni o'rganadi. Masalan, hammasi bir xil uzunlikda bo'lsa, javoblar ham shu uzunlikka moslashadi. Misollar **xilma-xil** bo'lsin va chekka holatlarni (edge case) ham qamrasin.

---

## 5. 4-qoida: XML teglar bilan struktura {#xml}

Prompt bir necha qismdan iborat bo'lsa (ko'rsatma, kontekst, ma'lumot, misollar), ularni teglar bilan ajrating. Model qaysi qism nima ekanini chalkashtirmaydi, siz esa promptni oson tahrirlaysiz:

```text
<role>Sen Swift 6 strict concurrency bo'yicha senior reviewer'san.</role>

<context>
Loyiha SwiftUI + actor asosidagi data qatlamini ishlatadi. Minimal target — iOS 17.
</context>

<diff>
{{DIFF}}
</diff>

<instructions>
1. Faqat data race va Sendable muammolarini top.
2. Har bir topilma uchun fayl:qator va tuzatish taklifini ber.
3. Stil masalalarini e'tiborsiz qoldir — ularni SwiftLint tekshiradi.
</instructions>
```

Teg nomlari maxsus bo'lishi shart emas, faqat **izchil** bo'lsin. Google ham Gemini uchun XML teglar yoki Markdown sarlavhalarini izchil ishlatishni tavsiya qiladi ([Gemini prompting strategies](https://ai.google.dev/gemini-api/docs/prompting-strategies)).

---

## 6. 5-qoida: rol va system prompt {#rol}

**System prompt** — suhbat davomida amal qiladigan asosiy ko'rsatma. Bitta jumlalik rol ham modelning ohangi va e'tiborini sezilarli toraytiradi:

```text
Sen iOS dasturchilarga Swift va SwiftUI bo'yicha yordam beradigan tajribali mentor'san.
Javoblaringni o'zbek tilida yoz, texnik atamalarni ingliz tilida qoldir.
```

Rol + vazifa + cheklovlar + format — system prompt'ning tipik tarkibi.

---

## 7. Uzun hujjatlar bilan ishlash {#uzun-kontekst}

Modelga katta matn bersangiz (masalan 20 000+ token: dokumentatsiya, bir nechta fayl, log), ikki qoida ishlaydi:

1. **Hujjatni promptning boshiga, savolni oxiriga** qo'ying. Anthropic testlarida murakkab, ko'p hujjatli kirishlarda bu javob sifatini **30% gacha** oshirgan.
2. **Avval iqtibos, keyin javob:** modeldan javob berishdan oldin hujjatning tegishli joylarini `<quotes>` teglarida keltirishni so'rang. Bu to'qib chiqarishni (hallucination) kamaytiradi va javobni tekshirishni osonlashtiradi.

```text
<documents>
  <document>
    <source>App Store Review Guidelines, 5.1.2</source>
    <document_content>{{MATN}}</document_content>
  </document>
</documents>

Avval hujjatdan savolga tegishli jumlalarni <quotes> ichida keltir.
Keyin faqat shu iqtiboslarga tayanib <answer> ichida javob ber.
Savol: ilovamiz foydalanuvchi matnini tashqi AI servisiga yuborsa, nima qilishimiz kerak?
```

---

## 8. Reasoning modellar: nima o'zgardi? {#reasoning}

**Reasoning model** javob berishdan oldin ichki "fikrlash" bosqichidan o'tadi. 2025–2026-yillarda uchala yirik provayder fikrlash chuqurligini alohida parametr sifatida ochdi:

| Provayder            | Parametr                                                | Qiymatlar                                               |
| -------------------- | ------------------------------------------------------- | ------------------------------------------------------- |
| Anthropic (Claude)   | `thinking: {type: "adaptive"}` + `output_config.effort` | `low`, `medium`, `high`, `xhigh`, `max` (modelga qarab) |
| OpenAI (GPT-5)       | `reasoning_effort` + `verbosity`                        | `minimal`, `low`, `medium`, `high` (standart: `medium`) |
| OpenAI (GPT-6 Astra) | `reasoning_effort`                                      | `none` qo'llab-quvvatlanmaydi — o'rniga `low`           |

Claude API'ga so'rov (joriy shakl):

```bash
curl https://api.anthropic.com/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  --data-binary @- <<'JSON'
{
  "model": "claude-opus-5",
  "max_tokens": 16000,
  "thinking": {"type": "adaptive"},
  "output_config": {"effort": "medium"},
  "messages": [
    {"role": "user", "content": "Bu SwiftUI view nega ikki marta render bo'lyapti? ..."}
  ]
}
JSON
```

> JSON heredoc (`<<'JSON'`) ichida beriladi: shunda o'zbekcha matndagi apostrof (`bo'lyapti`) shell'ni buzmaydi. `-d '...'` ichida `'` belgisi qatorni yopib qo'yardi.

Muhim o'zgarishlar (eski maqolalarda uchraydi — ishlatmang):

- **`budget_tokens` (qat'iy "fikrlash byudjeti") eskirdi.** Claude 4.6 modellarida _deprecated_, eng yangi modellarda yuborilsa **400** xato qaytadi. O'rniga `thinking: {type: "adaptive"}` + `effort` ishlating.
- **Prefill olib tashlandi.** Assistant javobini oldindan boshlab berish (masalan, JSON olish uchun javobni `{` bilan boshlash) Claude 4.6+ modellarida **400** qaytaradi. O'rniga structured outputs ishlating (9-bo'lim).
- **"Step by step" deyish shart emas.** Fikrlash parametr orqali yoqilganda, qo'lda zanjirli fikrlashni (chain-of-thought) so'rash kamdan-kam foyda beradi. Fikrlash o'chiq rejimda esa u hali ham zaxira usul bo'lib qoladi.
- **Effort'ni vazifaga moslang.** Oddiy klassifikatsiya va qisqa javoblar `low`da yaxshi ishlaydi; murakkab kod va ko'p bosqichli vazifalar `high`/`xhigh` talab qiladi. Default'ni oshirishdan oldin real so'rovlarda o'lchang.
- **Gemini'da `temperature`ni o'zgartirmang.** Google Gemini 3 uchun standart qiymatni qoldirishni tavsiya qiladi: o'zgartirish modelni aylanib qolishiga yoki sifat pasayishiga olib kelishi mumkin.

---

## 9. Structured outputs — kafolatlangan JSON {#structured}

Ilovangiz model javobini kod bilan qayta ishlasa, "iltimos JSON qaytar" deyish yetarli emas: javob buzilgan yoki boshqa formatda kelishi mumkin. **Structured outputs** javobni siz bergan **JSON Schema**ga mos kelishini kafolatlaydi.

Claude API'da `output_config.format`:

```bash
curl https://api.anthropic.com/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  --data-binary @- <<'JSON'
{
  "model": "claude-opus-5",
  "max_tokens": 1024,
  "output_config": {
    "format": {
      "type": "json_schema",
      "schema": {
        "type": "object",
        "properties": {
          "severity": {"type": "string", "enum": ["critical", "high", "medium", "low"]},
          "affected_ios_version": {"type": "string"},
          "reproducible": {"type": "boolean"},
          "summary": {"type": "string"}
        },
        "required": ["severity", "affected_ios_version", "reproducible", "summary"],
        "additionalProperties": false
      }
    }
  },
  "messages": [
    {"role": "user", "content": "TestFlight feedback: iPhone 15, iOS 26.1 — dars ochilganda ilova yopilib qolyapti, har safar."}
  ]
}
JSON
```

Javob (misol):

```json
{
  "severity": "critical",
  "affected_ios_version": "26.1",
  "reproducible": true,
  "summary": "Dars ochilganda ilova har safar yopiladi (iPhone 15, iOS 26.1)."
}
```

Schema cheklovlari (Claude):

- Har bir `object`da `"additionalProperties": false` **majburiy**.
- **Qo'llanmaydi:** rekursiv schema, sonli cheklovlar (`minimum`, `maximum`, `multipleOf`), satr uzunligi (`minLength`, `maxLength`). Bunday talablarni `description`da so'z bilan yozing va natijani kodda tekshiring.
- Yangi schema birinchi so'rovda bir martalik "kompilyatsiya" vaqtini oladi, keyin 24 soat cache'da turadi.
- `stop_reason` `"max_tokens"` bo'lsa, javob chala qolgan bo'lishi mumkin. `"refusal"` bo'lsa, schema'ga mos kelmasligi mumkin — ikkalasini ham kodda tekshiring.

OpenAI'da ham xuddi shunday imkoniyat bor (Structured Outputs, `strict: true`). Provayderlarning cheklovlari biroz farq qiladi — rasmiy sahifasini o'qing.

---

## 10. Oldin → keyin: 5 ta real misol {#oldin-keyin}

**1) Refactor so'rovi**

```text
Oldin:  Bu kodni yaxshila.

Keyin:  ProfileViewModel.swift'ni Swift Concurrency'ga o'tkaz:
        - completion handler'larni async/await'ga almashtir;
        - class'ni @MainActor bilan belgila;
        - public API (metod nomlari) o'zgarmasin — uni 6 ta ekran ishlatadi;
        - o'zgarishdan keyin mavjud ProfileViewModelTests testlari o'tishi kerak.
```

**2) Test yozish**

```text
Oldin:  Testlar yoz.

Keyin:  PriceFormatter uchun Swift Testing (@Test) testlari yoz. Qamrab ol:
        - 0, manfiy son, 1 000 000 dan katta son;
        - "uz_UZ" va "en_US" locale'lari;
        - UZS'da kasr qismi ko'rsatilmasligi.
        Mavjud implementatsiyani o'zgartirma — faqat testlar.
```

**3) Code review (XML bilan)** — 5-bo'limdagi misolga qarang.

**4) Tool tavsifi (agent uchun)**

```text
Oldin:  "run_build": "Builds the app."

Keyin:  "xcode_build": "Runs xcodebuild for the given scheme and simulator destination.
        Use it before running tests or when the user asks to check that the project
        compiles. Returns success or failure plus the first 20 compiler errors.
        Does NOT run tests or install the app — use xcode_test for tests."
```

**5) Matnni tasniflash — structured output bilan** — 9-bo'limdagi TestFlight misoli.

---

## 11. Qayta ishlatiladigan shablon {#shablon}

```text
<role>
Sen [aniq rol: masalan, senior iOS muhandis / support triage yordamchisi]san.
</role>

<context>
Loyiha: [nomi]. Platforma: [iOS versiyasi, Swift versiyasi].
Nega bu vazifa muhim: [modelga sababini tushuntiring].
</context>

<instructions>
1. [Qadamlar — tartib muhim bo'lsa raqamlang]
2. ...
</instructions>

<examples>
<example>...</example>   (3–5 ta, xilma-xil)
</examples>

<output_format>
[Aniq format: JSON schema / teglar / oddiy matn.
Nima QILMASLIK kerakligini ham yozing: masalan, "kirish so'zlarsiz, darhol javob".]
</output_format>
```

---

## 12. Xulosa {#xulosa}

- Modelni "kontekstni bilmaydigan aqlli yangi xodim" deb tasavvur qiling: aniq yozing va sababini tushuntiring.
- 3–5 ta xilma-xil misol va XML struktura — hali ham eng kuchli vositalar.
- Uzun hujjat — tepada, savol — pastda. Avval iqtibos, keyin javob.
- Reasoning chuqurligi endi parametr: Claude'da `thinking: {type: "adaptive"}` + `effort`. `budget_tokens` va prefill — eskirgan.
- Kod qayta ishlaydigan javob uchun structured outputs ishlating, lekin `stop_reason`ni baribir tekshiring.

---

## Manbalar {#manbalar}

1. [Anthropic — Prompting best practices](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices)
2. [Anthropic — Extended/adaptive thinking](https://platform.claude.com/docs/en/build-with-claude/extended-thinking)
3. [Anthropic — Effort](https://platform.claude.com/docs/en/build-with-claude/effort)
4. [Anthropic — Structured outputs](https://platform.claude.com/docs/en/build-with-claude/structured-outputs)
5. [OpenAI — GPT-5 prompting guide](https://developers.openai.com/cookbook/examples/gpt-5/gpt-5_prompting_guide)
6. [OpenAI — Model prompt guidance (GPT-6)](https://developers.openai.com/api/docs/guides/prompt-guidance)
7. [Google — Gemini prompting strategies](https://ai.google.dev/gemini-api/docs/prompting-strategies)