Claude Code: dasturchi va engineerlar uchun to'liq qo'llanma

Bob 01Muqaddima

Bu kitob Claude Code'ni jiddiy ishlatmoqchi bo'lgan dasturchilar uchun yozilgan: o'rnatishdan boshlab MCP, hooks va Agent SDK darajasigacha — qisqa va aniq.

Claude Code — bu Anthropic tomonidan yaratilgan terminal-asosidagi AI assistent. U sizning kompyuteringizda turib, fayllarni o'qiydi, o'zgartiradi, kod yozadi, testlarni ishga tushiradi, git buyruqlarini bajaradi va hatto butun feature'larni mustaqil ravishda implementatsiya qilishi mumkin. Lekin uning haqiqiy kuchi — bu uni qanday kengaytirish mumkinligida: hooks orqali avtomatlashtirish, MCP orqali tashqi xizmatlarga ulanish va custom skills/agents orqali maxsus workflow'larni qurishda.

Kitob bilingual yozilgan: tushuntirishlar o'zbek tilida, lekin barcha buyruqlar, fayl nomlari, frontmatter maydonlari va konfiguratsiya namunalari ingliz tilida — chunki Claude Code'ning rasmiy interfeysi ingliz tilida va siz aynan shu so'zlarni terminalingizga yozasiz.

Har bir bobda quyidagilar bor: nima ekanligi, qachon ishlatish, aniq misollar va samaradorlik maslahatlari. Kitob qisqa, lekin tig'iz — bekor so'z yo'q.

Bob 02Claude Code nima va kim uchun

CLI tool sifatida Claude Code sizning fayllaringizni o'qiy oladi, shell ishga tushiradi va MCP orqali tashqi xizmatlarga ulanadi — Claude.ai web interfeysidan tubdan farq qiladi.

Asosiy tushuncha

Claude Code — bu CLI tool. Siz uni terminalda claude deb ishga tushirasiz va u sizning current working directory'da ishlay boshlaydi. ChatGPT/Claude.ai dan farqli o'laroq, bu joyda Claude:

• Sizning fayllaringizni o'qiy oladi (Read tool orqali)
• Fayllarni tahrir qiladi yoki yangi fayl yozadi (Edit, Write)
• Shell buyruqlarini ishga tushiradi (Bash — testlar, build, git, har qanday CLI)
• Internet orqali qidiradi (WebSearch, WebFetch)
• Subagentlar yordamida parallel ish bajaradi
• MCP serverlar orqali tashqi servislarga ulanadi (GitHub, Notion, Slack, database va h.k.)

Claude Code va Claude.ai farqi

Qachon nima ishlatish kerak

Claude Code'ni ishlating, qachonki: real codebase'da ishlasangiz, multi-file refactoring qilsangiz, testlar yozish/ishga tushirish kerak bo'lsa, CI/CD'ga AI qo'shsangiz yoki o'zingizning workflow'ingizni avtomatlashtirsangiz.

Claude.ai'ni ishlating, qachonki: tezda biror narsani so'rasangiz, fayl qo'shmasdan g'oya muhokama qilsangiz yoki mobil qurilmadan kirsangiz.

Bob 03O'rnatish va birinchi qadamlar

Native installer, autentifikatsiya, birinchi sessiya va loyiha xotirasini sozlovchi CLAUDE.md — kichik qadamlar bilan to'g'ri start.

O'rnatish

Eng oson va tavsiya qilingan usul — native installer. Bu sizga avtomatik update'larni beradi va NodeJS o'rnatish talab qilmaydi.

macOS / Linux

curl -fsSL https://claude.ai/install.sh | bash

Windows (PowerShell)

irm https://claude.ai/install.ps1 | iex

Homebrew (macOS)

brew install --cask claude-code

Tekshirish

claude --version
claude /doctor

/doctor buyrug'i installatsiya bilan bog'liq muammolarni topib beradi: PATH masalalari, auth holati, MCP server statuslari, hooks va sozlamalar ierarxiyasi.

Authentication

Ikki yo'l mavjud:

1. Claude subscription (Pro / Max / Team) — agar sizda Claude.ai obunasi bo'lsa:

claude
# Birinchi marta ishga tushirganda /login ochiladi

2. API key (Anthropic Console) — pre-paid kreditlar bilan ishlatish uchun:

export ANTHROPIC_API_KEY="sk-ant-..."
claude

Korporativ foydalanuvchilar uchun: AWS Bedrock (CLAUDE_CODE_USE_BEDROCK=1), Google Vertex AI va Microsoft Foundry ham qo'llab-quvvatlanadi.

Birinchi sessiya

cd ~/projects/my-app
claude

Sessiya boshlandi. Endi o'z prompt'ingizni yozing. Misol:

> @src/auth/login.ts faylini o'qib, asosiy mantiqni tushuntir

E'tibor bering: @filename sintaksisi Claude'ga shu faylni darhol o'qishni buyuradi. Bu — tezroq va aniqroq, "u faylni o'qisin" deb yozishdan ko'ra.

CLAUDE.md — loyiha xotirasi

Birinchi marta loyihada ishlaganda, quyidagi buyruqni bajaring:

/init

Bu buyruq CLAUDE.md faylini yaratadi. Bu fayl — Claude'ning loyihangiz haqidagi doimiy xotirasi. Har sessiyada Claude uni avtomatik o'qiydi va ko'rsatmalarga rioya qiladi.

Yaxshi CLAUDE.md'da quyidagilar bo'lishi kerak:

# Project: Acme Dashboard

## Tech stack
- Next.js 14, TypeScript, Tailwind CSS
- Postgres with Drizzle ORM
- Vitest for testing

## Code style
- Use ES modules, never CommonJS
- Destructure imports: `import { foo } from "bar"`
- 2-space indent, single quotes
- Functional React components only

## Commands
- `npm run dev` — start dev server
- `npm test` — run unit tests
- `npm run db:migrate` — apply migrations

## Workflow
- Always run `npm test` after editing files in `src/`
- Never commit migrations without `--down` script
- Use feature branches; PR titles in conventional commits format

## Gotchas
- `lib/legacy/*` is deprecated — don't add code there
- `src/api/*` requires auth middleware

Fayl ierarxiyasi

Bob 04Asosiy ish jarayoni

Bir tipik sessiya qanday boshlanadi va tugaydi, qanday tool'lar mavjud va parallel ishlatish nima uchun samarali — boshqaruvning asoslari.

Sessiya hayotiy davri

Bir tipik sessiya quyidagicha kechadi:

1. Siz claude deb ishga tushirasiz
2. Claude CLAUDE.md, sozlamalar, hook'lar va skill metadata'sini yuklaydi
3. Siz prompt yozasiz; Claude javob beradi yoki tools'larni chaqiradi
4. Har bir tool chaqiruvi natija qaytaradi (fayl mazmuni, shell output va h.k.)
5. Claude fikrlaydi, yana tools chaqiradi yoki javob beradi
6. Sessiya tugaganda yoki Ctrl+D//exit bosganda transcript ~/.claude/projects/ ga saqlanadi

Asosiy CLI buyruqlari

claude                        # Interaktiv sessiya
claude "task here"            # Boshlang'ich prompt bilan
claude -p "query"             # Print mode (javob berib chiqib ketadi)
claude -c                     # Oxirgi sessiyani davom ettirish
claude -r                     # Sessiyani tanlab davom ettirish
claude --resume my-feature    # Nomi bo'yicha
claude --fork-session         # Yangi shoxga o'tib (tarix saqlanadi)
claude -n "feature-auth"      # Sessiyaga nom berish
claude --add-dir /path/to/dir # Boshqa katalogga ham kirish
claude update                 # Yangilash

Tool turlari

Claude Code'da quyidagi asosiy tool'lar mavjud:

Parallel tool ishlatish

Claude Code parallel tool execution'ni qo'llab-quvvatlaydi. Bu — eng katta samaradorlik trick'laridan biri. Misol uchun, agar Claude bir nechta mustaqil narsani o'qishi kerak bo'lsa, u ularni parallel chaqiradi.

Foydalanuvchi sifatida sizning vazifangiz — promptni shunday tuzishki, parallel ish iloji bo'lsin:

YOMON:  "src/auth.ts ni o'qib, keyin src/db.ts ni o'qib, keyin..."
YAXSHI: "Quyidagi fayllarni parallel o'qib, har birining maqsadini ayt:
        src/auth.ts, src/db.ts, src/api/users.ts, src/api/posts.ts"

Fayl reference (@) sintaksisi

@README.md                          # Faylni darhol o'qiydi
@src/auth/login.ts                  # Nisbiy yo'l
@/absolute/path/to/file             # Absolyut yo'l

Multiple fayllarni bir promptda eslab o'tishingiz mumkin. Claude ularni parallel o'qiydi.

Image input

Screenshot'larni to'g'ridan-to'g'ri terminalga drag-drop qiling yoki paste (Cmd+V / Ctrl+V) qiling. Claude rasmni ko'radi va shu asosida ishlay oladi.

Tipik foydalanish:

• UI design'ni yopishtirib: "Shu UI'ni React'da implementatsiya qil"
• Error screenshot'ni yopishtirib: "Bu xatoni nima bo'lgan?"
• Diagramma yopishtirib: "Bu architecture'ni implement qil"

Pipe input

Shell pipeline orqali ham input bera olasiz:

cat error.log | claude -p "bu xatoni tahlil qilib, root cause'ini ayt"
git diff | claude -p "bu o'zgarishlar uchun PR description yoz"
gh pr view 42 --comments | claude -p "PR'ga umumiy javob tayyorla"

Bob 05Kontekst boshqaruvi va xotira

Claude'ning eng cheklangan resursi — kontekst oynasi. Uni samarali boshqarish professional foydalanuvchining asosiy ko'nikmasi.

Modellarning aksariyatida bu 200,000 token. Bu juda katta ko'rinadi, lekin amaliyotda u tezda to'lib qoladi: katta fayllar, uzun shell output'lar va davomli muloqot.

Kontekst doimiy ishtirokchilari

Har bir sessiyada quyidagilar kontekst joyini egallaydi:

• System prompt — Claude'ning asosiy ko'rsatmalari (~5-10K token)
• CLAUDE.md mazmuni
• Tool definitions — har bir tool schema'si
• Skill metadata — mavjud skill'larning nomi va description'i
• Conversation history — barcha xabarlar va tool natijalari

Kontekst buyruqlari

/context        # Kim qancha joy egallayapti — ko'rish
/compact        # Tarixni qisqartirish (avtomatik xulosa qiladi)
/compact focus on auth   # Maxsus mavzuga e'tibor berib qisqartirish
/clear          # Hammasini tozalash (yangi sessiya kabi)
/resume         # Eski checkpoint'dan davom ettirish
Esc Esc         # Rewind menu — orqaga qaytish

Qachon /clear, qachon /compact?

/clear — agar siz yangi, mustaqil vazifaga o'tayotgan bo'lsangiz. Misol: Auth feature'ini tugatdingiz, endi billing'ga o'tyapsiz. Eski kontekst yangi vazifaga foyda bermaydi va shovqin keltiradi.

/compact — agar siz hozirgi vazifani davom ettirayotgan bo'lsangiz, lekin tarix juda uzayib ketgan. Claude eski tool natijalarini xulosalaydi, lekin asosiy qarorlarni va kod o'zgarishlarini eslab qoladi.

Auto-compaction

Kontekst to'lganda Claude avtomatik ravishda compaction qiladi. Bu jarayon:

1. Eski tool output'larni o'chiradi
2. Conversation tarixini xulosaga aylantiradi
3. Kod o'zgarishlari va asosiy qarorlarni saqlaydi

Lekin bu — hech qachon ideal emas. Iloji boricha auto-compaction'ga yetib bormaslik kerak. Yo'llari:

• Skills lazy-load: faqat kerak bo'lganda yuklanadi
• Subagentlar — ulkan investigation'ni isolated kontekstda bajaring
• Read tool'da limit va offset parametrlardan foydalaning, butun katta faylni o'qishdan saqlaning
• Grep va Glob — "files_with_matches" mode'da, kontent tortmasdan

Sessiya saqlash va davom ettirish

Har bir sessiya local'da JSONL fayl sifatida saqlanadi: ~/.claude/projects/<encoded-path>/sessions/. Bu sizga bir necha kundan keyin ham qaytib kelish imkonini beradi.

claude -n "auth-refactor"            # Sessiyaga nom berish
# ... ish qiling, exit ...
# Bir hafta o'tdi
claude --resume auth-refactor        # Tarix bilan davom etish

Ham foydali: --fork-session — mavjud sessiyani ko'chirib yangi shoxda boshlash, eski sessiya saqlanadi. Bu — "agar X qilsam-chi?" eksperimentlari uchun.

Rewind (Esc Esc)

Sessiyada ikki marta Esc bosing — checkpoint menu ochiladi. U yerdan siz quyidagilarni bajarishingiz mumkin:

• Faqat suhbatni orqaga qaytarish (kod o'zgarishlari saqlanadi)
• Faqat kodni orqaga qaytarish (suhbat saqlanadi)
• Hammasini ma'lum nuqtaga qaytarish

Bu — "Claude noto'g'ri yo'ldan ketdi" holatlari uchun ajoyib qo'l qurol.

Bob 06Slash kommandlar

Slash buyruqlari — Claude'ga maxsus instruksiyalar berishning eng tezkor usuli. Sessiya davomida promptga / bilan boshlab teriladi.

Built-in buyruqlar to'liq ro'yxati

Thinking modes

Claude'ga "ko'proq vaqt o'ylash" buyurish mumkin. Bu murakkab vazifalarda ajoyib ishlaydi:

Yoki promptingiz ichida shunchaki "think hard about this" deb yozsangiz ham ishlaydi.

Plan mode

Shift+Tab'ni ikki marta bosing — siz "plan mode"'ga o'tasiz. Bu rejimda Claude:

• Faqat o'qiy oladi (Read, Grep, Glob, WebSearch)
• Hech narsa o'zgartira olmaydi
• Sizga aniq plan taklif qiladi va sizning tasdig'ingizni so'raydi

Bu — xavfli yoki katta o'zgarishlar oldidan ajoyib qadam. "Avval o'ylab ko'raylik, keyin qilamiz."

Permission mode'lar

Shift+Tab bir marta bosish — permission mode aylanadi:

CLI orqali ham:

claude --permission-mode plan
claude --permission-mode acceptEdits

Bob 07Custom Skills va kommandlar

Skill — Claude'ga "ma'lum vaziyatda quyidagicha ishla" deb aytadigan markdown fayl. Avtomatik yuklanadi, kontekstni asramaydi, dasturlash ko'nikmasi talab qilmaydi.

Joy va tuzilish

Skill papkasi quyidagicha ko'rinadi:

my-skill/
├── SKILL.md          (asosiy — majburiy)
├── reference.md      (qo'shimcha — ixtiyoriy)
├── examples.md       (qo'shimcha)
└── scripts/
    └── helper.sh     (executable)

SKILL.md formati

---
name: pr-summarizer
description: Use when the user asks for a PR summary or wants to describe changes
  in a pull request. Generates a concise summary based on git diff.
allowed-tools: Bash Read Grep
argument-hint: [pr-number]
model: claude-sonnet-4-6
---

# PR Summarizer

Goal: produce a 3-5 bullet PR description from the current diff.

## Steps

1. Run `gh pr diff $1` (or `git diff main...HEAD` if no PR yet)
2. Identify: new features, bug fixes, refactors, breaking changes
3. Output as markdown with headings: Summary, Changes, Test plan

## Style

- Concise, no marketing language
- Bullet points, not paragraphs
- Mention any DB migrations or breaking API changes

Frontmatter maydonlari

Argument substitution

Skill ichida argument'lardan foydalanish:

$ARGUMENTS         # Hammasi bir string
$1, $2, $3         # Pozitsiyaga ko'ra
${CLAUDE_SESSION_ID}      # Sessiya ID
${CLAUDE_SKILL_DIR}       # Skill papkasi yo'li

Shell injection (dynamic context)

Backtick bilan boshlanuvchi ! buyruqlar Claude promptni ko'rmasdan oldin shell'da bajariladi va ularning natijasi promptga qo'shiladi:

---
name: weekly-standup
---

Joriy git holati: !`git log --since="1 week ago" --oneline`

Yopilgan PR'lar: !`gh pr list --state merged --search "merged:>$(date -v-7d +%Y-%m-%d)"`

Bu ma'lumotlardan foydalanib, haftalik standup uchun 3 nuqtali xulosa yoz.

Yaxshi skill yozish qoidalari

1. Description aniq bo'lsin. Claude unga qarab skill'ni avtomatik tanlaydi. "Use when..." formati eng yaxshi ishlaydi.
2. Qisqalik. Skill mazmuni 200-500 so'z bo'lishi optimal. Uzun bo'lsa — alohida reference.md ga ajrating va undan reference qiling.
3. allowed-tools'ni belgilang. Bu — ham xavfsizlik, ham aniqlik. Skill faqat o'zining ishini qila olsin.
4. Output format'ni ayting. "Output as markdown bullet list" — oddiy, lekin samarali.
5. Eng yaxshisi: examples qo'shing. "Misol uchun, agar foydalanuvchi X so'rasa, javob Y bo'lsin."

Legacy commands (.claude/commands/)

Eski format hali ham ishlaydi:

.claude/commands/test-changed.md

# Test changed files

Run tests for files changed in the last commit.

```!
git diff --name-only HEAD~1 | grep -E '\.(ts|tsx|js)$' | xargs npm test --
```

Lekin yangi loyihalarda — skills'ni tanlang. Skills moslashuvchanroq, plugin'lar bilan yaxshi ishlaydi va subagent'larga yuborish imkoni bor.

Bob 08Hooks: avtomatlashtirish kuchi

Hooks — bu Claude Code'ning lifecycle event'larida avtomatik ishga tushadigan skript yoki webhook'lar. Sizdan oldin va sizdan keyin shovqinsiz ishlaydigan ko'mak.

Ular sizga quyidagi imkoniyatlarni beradi:

• Har Edit'dan keyin avtomatik prettier ishga tushirish
• Xavfli buyruqlar bajarishdan oldin to'xtatish
• Session boshlanishida kontekst qo'shish (masalan, hozirgi git branch)
• Har turn'dan keyin Slack'ga xabar yuborish
• Token sarflanishini tekshirib turish

Hook event'lar

Hook konfiguratsiyasi

Hooks settings.json ichida belgilanadi (loyiha yoki user darajasida):

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write $CLAUDE_FILE_PATH"
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "/usr/local/bin/safety-check.sh"
          }
        ]
      }
    ],
    "SessionStart": [
      {
        "matcher": "startup|resume",
        "hooks": [
          {
            "type": "command",
            "command": "git status --short && git log -5 --oneline"
          }
        ]
      }
    ]
  }
}

Hook handler turlari

1. Command — shell skript. JSON stdin'da keladi.

{ "type": "command", "command": "/path/to/script.sh", "timeout": 30 }

2. HTTP — webhook'ga POST.

{
  "type": "http",
  "url": "http://localhost:8080/webhook",
  "headers": { "Authorization": "Bearer $TOKEN" }
}

3. Prompt — LLM input'ni baholaydi.

{
  "type": "prompt",
  "prompt": "Is this command safe? $ARGUMENTS",
  "model": "haiku"
}

4. Agent — subagent ishga tushiradi.

{
  "type": "agent",
  "prompt": "Verify migration safety: $ARGUMENTS"
}

Bloklash va modifikatsiya

Hook script'i exit code orqali Claude'ga signal beradi:

Yana boy nazorat — JSON output orqali:

{
  "continue": true,
  "stopReason": "...",
  "suppressOutput": false,
  "systemMessage": "Claude'ga ko'rsatiladigan xabar",
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "additionalContext": "Tool ishlatilmasdan oldin shu narsalarni eslang...",
    "permissionDecision": "allow|deny|ask|defer"
  }
}

Amaliy hook misollari

Avtomatik linter

{
  "PostToolUse": [{
    "matcher": "Edit|Write",
    "hooks": [{
      "type": "command",
      "command": "if echo \"$CLAUDE_FILE_PATH\" | grep -E '\\.(ts|tsx)$'; then npx eslint --fix \"$CLAUDE_FILE_PATH\"; fi"
    }]
  }]
}

Xavfli rm bloklash

#!/bin/bash
INPUT=$(cat)
COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command')
if echo "$COMMAND" | grep -qE 'rm\s+-rf\s+/'; then
  echo "Blocked: rm -rf / is forbidden" >&2
  exit 2
fi
exit 0

Slack notification when done

{
  "Stop": [{
    "hooks": [{
      "type": "http",
      "url": "https://hooks.slack.com/services/...",
      "headers": { "Content-Type": "application/json" }
    }]
  }]
}

Xavfsizlik

Barcha hook'larni vaqtincha o'chirish:

{ "disableAllHooks": true }

Bob 09MCP serverlar

MCP (Model Context Protocol) — AI assistentni tashqi servislarga ulash uchun ochiq standart. GitHub, Notion, Linear, Slack, Postgres va yuzlab boshqa xizmatlarga schema'siga ega tool'lar sifatida kirish.

Nega MCP?

MCP bo'lmaganda, har bir integratsiya uchun siz Bash orqali curl yozishingiz kerak edi. MCP esa ularni type-safe, schema'siga ega tool'larga aylantiradi.

MCP server qo'shish

claude mcp add                       # Interaktiv setup
claude mcp add notion                # Nomi bo'yicha
claude mcp add ./mcp-config.json     # Fayldan
/mcp                                  # Joriy serverlarni ko'rish

.mcp.json formati

Loyiha root'ida .mcp.json joylashadi (jamoaviy ulashish uchun git'ga commit qilinadi):

{
  "mcpServers": {
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "$GITHUB_TOKEN"
      }
    },
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://localhost/mydb"]
    },
    "linear": {
      "type": "http",
      "url": "https://mcp.linear.app/sse",
      "headers": { "Authorization": "Bearer $LINEAR_TOKEN" }
    }
  }
}

Transport turlari

MCP tool'lardan foydalanish

Bir marta server qo'shilgach, uning tool'lari Claude'ga avtomatik ko'rinadi. Ularning nomlari mcp__<server>__<tool> formatida bo'ladi.

Misol: mcp__github__create_pull_request, mcp__postgres__query.

Foydalanuvchi sifatida siz oddiy tarzda yozasiz: "Create a GitHub PR with title X". Claude o'zi to'g'ri MCP tool'ni topadi va chaqiradi.

MCP resources (@server:resource)

Ba'zi MCP serverlar nafaqat tool, balki resurslar ham taqdim etadi (masalan, Notion sahifasi yoki database jadvali). Ularni @ bilan reference qilish mumkin:

@notion:page-id-here          # Notion sahifani kontekstga olib kirish
@github:repo:owner/name       # GitHub repo metadata

MCP slash buyruqlari

Ba'zi serverlar oldindan tayyorlangan promptlar (slash buyruqlari) ham taqdim etadi:

/mcp__github__create_issue
/mcp__linear__triage_inbox

Mashhur MCP serverlar

MCP'ga ruxsat qoidalari

{
  "permissions": {
    "rules": [
      "mcp__github__*",                    // GitHub'ning hammasi ruxsat
      "!mcp__github__delete_repository",   // lekin delete'ni ta'qiqlash
      "mcp__postgres__query"               // faqat select query
    ]
  }
}

Bob 10Plugins va Marketplaces

Plugin — skills, commands, agents, hooks va MCP serverlarning birgalikda paketlangan to'plami. Yagona install bilan o'rnatiladi va hammasi ishlay boshlaydi.

Plugin nimadan iborat

my-plugin/
├── .claude-plugin/
│   └── plugin.json          (manifest)
├── skills/
│   └── my-skill/SKILL.md
├── agents/
│   └── reviewer.md
├── hooks/
│   └── hooks.json
├── .mcp.json
├── settings.json            (default sozlamalar)
└── README.md

plugin.json manifest

{
  "name": "my-plugin",
  "description": "What this plugin does",
  "version": "1.0.0",
  "author": { "name": "You", "email": "you@example.com" },
  "homepage": "https://github.com/you/my-plugin",
  "repository": "https://github.com/you/my-plugin",
  "license": "MIT",
  "keywords": ["code-review", "ci"]
}

Plugin o'rnatish

/plugin browse                     # Marketplace'ni ko'rish
/plugin install <plugin-name>     # Marketplace'dan
/plugin install ./local-plugin     # Local papkadan
claude --plugin-dir ./my-plugin    # Faqat shu sessiyaga
/plugin list                       # O'rnatilganlar
/reload-plugins                    # Hot-reload (rivojlantirish vaqtida)

Plugin namespacing

Plugin ichidagi skills avtomatik ravishda namespace oladi:

/my-plugin:my-skill

Bu — ikki plugin bir xil nomli skill'ga ega bo'lishini oldini oladi.

Marketplace yaratish

Jamoangiz uchun ichki plugin marketplace yaratish mumkin. Bu — oddiy git repo + marketplace.json fayli:

{
  "name": "acme-internal",
  "plugins": [
    { "name": "deploy-helpers", "url": "https://github.com/acme/deploy-helpers" },
    { "name": "db-tools",       "url": "https://github.com/acme/db-tools" }
  ]
}

Keyin har kim:

/plugin add-marketplace https://github.com/acme/marketplace

Plugin development workflow

1. Yangi papka yarating: my-plugin/
2. Ichida .claude-plugin/plugin.json yarating
3. Skills, agents, hooks qo'shing
4. Test: claude --plugin-dir ./my-plugin
5. O'zgartirgandan keyin: /reload-plugins
6. Tayyor bo'lganda — git'ga push, marketplace'ga qo'shing

Bob 11Subagentlar

Subagent — maxsus rol yoki vazifa uchun mo'ljallangan, izolatsiyalangan kontekstga ega Claude instance'i. Asosiy Claude ularni Task / Agent tool orqali chaqiradi.

Nega subagent kerak?

• Kontekst izolyatsiyasi: Subagent o'z kontekstida ishlaydi. Asosiy suhbat tarixi shovqin keltirmaydi.
• Maxsuslashtirilgan rol: "code-reviewer" agenti faqat code review bo'yicha mutaxassis sifatida ishlaydi.
• Cheklangan tool'lar: Misol uchun, "researcher" agent faqat o'qish va qidirish qilishi mumkin.
• Parallelism: Bir nechta subagent'ni parallel ishga tushirish mumkin.
• Kontekstni asramaslik: Katta investigation natijalari subagent ichida qoladi, asosiy kontekst toza qoladi.

Subagent fayli formati

.claude/agents/security-reviewer.md:

---
name: security-reviewer
description: Reviews code for security vulnerabilities. Use proactively
  when reviewing PRs, analyzing untrusted input handling, or auditing
  authentication and authorization code.
tools: Read Grep Glob Bash
model: claude-opus-4-6
---

You are a senior application security engineer. Your job is to review code
for security vulnerabilities, especially:

1. Injection vulnerabilities (SQL, command, XSS, SSRF)
2. Authentication and authorization flaws
3. Hardcoded secrets, weak crypto, insecure randomness
4. Insecure deserialization, path traversal
5. Race conditions in security-relevant code

For each issue found, output:
- Severity: CRITICAL | HIGH | MEDIUM | LOW
- File and line
- Vulnerability class (e.g., "SQL injection")
- Why it's a problem
- Concrete fix

If no issues, say so plainly. Don't invent issues.

Frontmatter maydonlari

Subagent'larni chaqirish

Asosiy suhbatda:

"Use the security-reviewer agent to audit src/auth/"
"Spawn three parallel agents to investigate the bug, test fixes, and update docs"

Yoki Claude o'zi description'ga qarab, vazifaga mos agent'ni avtomatik tanlaydi.

Skill ichidan chaqirish:

---
name: deep-research
context: fork
agent: Explore
---

Research the following topic thoroughly: $ARGUMENTS

Worktree isolatsiya

Eksperimental yoki risky o'zgarishlar uchun:

---
name: experimental-refactor
isolation: worktree
---

Bu agent .claude/worktrees/experimental-refactor nomli alohida git worktree'da ishlaydi. Asosiy ish daraxtingiz daxlsiz qoladi. Agar agent muvaffaqiyatli ishlasa, siz natijani branch sifatida olib o'tasiz; aks holda — o'chirib tashlaysiz.

Parallel agentlar

Eng kuchli pattern: bir vaqtning o'zida bir nechta mustaqil agent ishga tushirish.

"Spawn the following in parallel:
 - 'researcher' agent: investigate similar bugs in the codebase
 - 'tester' agent: write a failing test that reproduces the bug
 - 'docs' agent: find and read related documentation
Then I'll synthesize the results."

Claude bularning hammasini bir xabarda chaqiradi va parallel ishlaydi.

Built-in agent turlari

Bob 12Agent SDK

Agent SDK — Claude Code'ning programmatic interface'i. CI/CD pipeline, web app backend, custom CLI tool — Claude'ning tool-using qobiliyatini o'z dasturlaringizga olib kelish.

SDK turlari

• TypeScript / Node.js: @anthropic-ai/claude-agent-sdk
• Python: claude-agent-sdk

Headless mode (eng oddiy)

Eng oddiy "SDK" — bu shunchaki claude -p:

claude -p "Run the test suite, fix any failures, return a summary" \
  --output-format json \
  --max-turns 20 \
  --max-budget-usd 5.00

Bu buyruq interactive sessiyasiz ishlaydi va natijani JSON sifatida qaytaradi. Ideal CI/CD uchun.

Output format'lar

Tool nazorati

claude -p "task" \
  --allowedTools "Read Grep Bash(npm test)" \
  --disallowedTools "Edit Write" \
  --permission-mode auto

TypeScript SDK misoli

import { query } from "@anthropic-ai/claude-agent-sdk";

for await (const event of query({
  prompt: "Refactor src/auth/ to use the new JWT library",
  options: {
    cwd: "/path/to/project",
    allowedTools: ["Read", "Edit", "Write", "Bash"],
    permissionMode: "acceptEdits",
    maxTurns: 30,
    model: "claude-sonnet-4-6",
  },
})) {
  if (event.type === "text") {
    console.log(event.text);
  } else if (event.type === "tool_use") {
    console.log("Tool:", event.name);
  } else if (event.type === "result") {
    console.log("Done. Cost:", event.usage.total_cost_usd);
  }
}

Python SDK misoli

from claude_agent_sdk import query, ClaudeAgentOptions

options = ClaudeAgentOptions(
    cwd="/path/to/project",
    allowed_tools=["Read", "Edit", "Write", "Bash"],
    permission_mode="acceptEdits",
    max_turns=30,
)

async for event in query(
    prompt="Add tests for src/utils/format.ts",
    options=options,
):
    print(event)

Custom system prompt

claude -p "task" \
  --system-prompt "You are a Python expert. Write idiomatic, type-hinted code." \
  --append-system-prompt "Always use ruff for linting."

Yoki fayldan:

claude -p "task" --system-prompt-file ./prompts/expert.txt

Custom tool'lar (MCP orqali)

SDK'da o'z tool'laringizni qo'shish — bu MCP server yozish demakdir. Eng oddiyi:

// my-tools.mcp.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({ name: "my-tools", version: "1.0.0" });

server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "send_email",
    description: "Send an email",
    inputSchema: {
      type: "object",
      properties: {
        to: { type: "string" },
        subject: { type: "string" },
        body: { type: "string" }
      }
    }
  }]
}));

server.setRequestHandler("tools/call", async (req) => {
  if (req.params.name === "send_email") {
    // Send email logic
    return { content: [{ type: "text", text: "Email sent" }] };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);

Va keyin .mcp.json'da ro'yxatga olasiz.

Tipik SDK use case'lar

• CI/CD bot: Har commit'da test failure'larni avtomatik tahlil qilish va fix yuborish
• Code review bot: PR'ga avtomatik comment yozish
• Doc generator: Source code'dan API doc generatsiya qilish
• Migration assistant: Katta migration'larni partiyalab amalga oshirish
• Customer support bot: Codebase'ga asoslangan support agent

Bob 13Sozlamalar va ruxsatlar

Sozlamalar ierarxiyasi, permission qoidalari va environment variables — Claude qaysi tool'larni qachon ishlatishini boshqarish.

Sozlamalar ierarxiyasi

Sozlamalar bir nechta darajada bo'lishi mumkin. Pastdagilar yuqoridagilarni qayta belgilaydi (override):

1. Managed — korporativ siyosat (override qilinmaydi)
2. User — ~/.claude/settings.json
3. Project — .claude/settings.json (git'da)
4. Local — .claude/settings.local.json (gitignore)

settings.json sxemasi

{
  "model": "claude-sonnet-4-6",
  "effort": "medium",
  "defaultMode": "acceptEdits",
  "permissions": {
    "default": "ask",
    "rules": [
      "Read",
      "Glob",
      "Grep",
      "Bash(npm test)",
      "Bash(npm run *)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Bash(git log *)",
      "Edit(src/**)",
      "Write(src/**)",
      "!Bash(rm *)",
      "!Bash(curl *)",
      "mcp__github__list_*",
      "mcp__github__get_*"
    ]
  },
  "env": {
    "NODE_ENV": "development"
  },
  "statusLine": "fancy",
  "hooks": { /* ... */ }
}

Permission rule sintaksisi

Permission mode'lar

Muhim environment variables

statusLine sozlash

Status line — bu sessiya pastida ko'rinadigan info qatori. /statusline-setup agenti uni sozlashga yordam beradi. Misol uchun, branch nomi, model, joriy xarajat ko'rsatiladi.

Bob 14IDE integratsiya

VS Code va JetBrains uchun rasmiy plugin'lar, terminal integratsiyasi va vim mode — Claude Code'ni tabiiy ravishda ish muhitiga olib kirish.

VS Code

O'rnatish:

code --install-extension anthropic.claude-code

Yoki Marketplace'dan "Claude Code" qidiring.

Imkoniyatlar:

• Editor ichida diff review (changes side-by-side ko'rinadi)
• Right-click > "Send to Claude"
• Selection'ni Claude'ga yuborish (Cmd+Shift+L)
• Integrated terminal'da Claude Code avtomatik aniqlanadi
• File tree'dan fayllarni @ orqali tezkor reference

JetBrains (IntelliJ, WebStorm, PyCharm va h.k.)

Marketplace: "Claude Code" plugin'ini qidiring va o'rnating. Featurelari VS Code'ga o'xshash.

Terminal integration

Quyidagi terminal'lar Claude Code uchun yaxshi ishlaydi:

• iTerm2 (macOS)
• Windows Terminal
• Alacritty
• WezTerm
• Ghostty
• VS Code integrated terminal

Vim mode

Sessiyada /vim buyrug'i prompt input'ga vim keybinding'larni qo'shadi.

Bob 15Maksimal samaradorlik

Aniq prompt, kontekst injection, plan mode, parallel ishlar, model tanlash — Claude Code'dan eng ko'p foyda olish bo'yicha amaliy maslahatlar.

Specificity — aniqlik kuchi

YOMON: "Login'ni yaxshilang."
YAXSHI: "src/auth/login.ts da, password validation regex'ni RFC 5321 standard'ga keltiring. Test qo'shing — valid va invalid inputs uchun. Existing test style'iga rioya qiling (bkz: src/auth/__tests__/email.test.ts)."

Aniq prompt — aniq natija. Claude taxmin qilishni yaxshi ko'rmaydi; agar siz aytib bersangiz, u to'g'ri qiladi.

Kontekst injection

Claude'ga reference fayllarni darhol bering:

"Implement a new payment provider in @src/payments/providers/.
Follow the same pattern as @src/payments/providers/stripe.ts.
Add tests like @src/payments/providers/__tests__/stripe.test.ts.
Use types from @src/payments/types.ts."

Plan mode — oldindan rejalashtirish

Katta o'zgarishlar oldidan: Shift+Tab ikki marta — plan mode. Claude oldin tahlil qiladi, plan beradi, siz tasdiqlaysiz, keyin amalga oshiradi. Bu — "rework" kamaytirishning eng yaxshi usuli.

Subagent delegation

Investigatsion ishlarni subagent'ga bering. Misol:

"Use the Explore agent to investigate how authentication is implemented
across the codebase. Report back with: entry points, middleware chain,
session management, and any TODOs or known issues. Under 300 words."

Subagent qaytadi, asosiy kontekst toza qoladi. Siz natijani olib, asosiy ishni davom ettirasiz.

Parallel ishlar

Mustaqil tasklarni parallel ishga tushiring. Misollar:

• "3 ta agent ishga tushir: birinchisi tests yozadi, ikkinchisi docs yozadi, uchinchisi PR description tayyorlaydi"
• "Quyidagi 5 ta faylni parallel o'qib, har birining muammoini ayt"
• Headless: 10 ta fayl uchun parallel claude -p ishga tushiring

/clear — aggressive ishlatish

Yangi vazifa = yangi sessiya. Eski kontekst — bu shovqin. Tezroq, aniqroq, arzonroq.

CLAUDE.md — doimiy xotira

Loyihada qayta-qayta tushuntirayotgan narsangizni CLAUDE.md ga qo'shing. Bu bir marta yoziladi, har sessiyada ishlaydi. Token jihatdan eng samarali investitsiya.

Skills — takror workflow'lar uchun

Agar siz biror narsani 3+ marta qilgan bo'lsangiz — skill yarating. Skill'lar metadata sifatida yuklanadi (kontekst arzon) va kerakli paytda to'liq mazmunini olib chiqadi.

Hooks — siz unutmasligingiz uchun

Linter, formatter, test runner kabi narsalarni hook'larga aylantirib qo'ying. Claude shularni unutsa ham, hook ishlatadi.

Model tanlash

/model bilan sessiya o'rtasida ham almashtirish mumkin.

Cost optimization

• /cost — vaqti-vaqti bilan tekshiring
• --max-budget-usd — cap qo'ying
• Oddiy ish uchun Haiku, murakkab uchun Opus
• Aggressively /compact ishlating
• Long-running headless ish — --max-turns

Screenshots for UI work

UI ishi uchun — har doim screenshot. Implementatsiya, browser'da oching, screenshot oling, yopishtiring — "shu dizayn'ga to'g'rimi?". Iteratsiya aylanasi qisqaradi.

TDD bilan ishlash

Test-driven development — AI assistent uchun ideal. Claude'ga aytishingiz: "Avval failing test yoz, keyin implement qil, keyin testlar o'tishini tekshir." Bu sikl Claude'ga aniq feedback beradi.

Verification step — har doim

Claude o'z ishini tekshirishni unutmasin. TodoList'da har doim "verify" stepi bo'lsin: test ishga tushirish, screenshot ko'rish, diff o'qish va h.k. Trust but verify.

Bob 16Real workflow misollari

Git workflow, bug investigation, refactoring, code review, CI integration — qaysi vaziyatda Claude'ni qanday ishlatish.

Git workflow: feature branch'dan PR gacha

git checkout -b feature/user-export

claude
> Implement a CSV export endpoint at GET /api/users/export.
  Follow the pattern in @src/api/orders/export.ts. Use the existing
  CSV utilities from @lib/csv.ts. Add tests.

[Claude works ...]

> Run all tests
> Looks good. Now create a commit and open a PR. Use conventional commit format.

[Claude runs git add, commit, gh pr create]

Bug investigation

claude

> We have a flaky test in @src/api/__tests__/auth.test.ts.
  It fails about 1 in 5 runs with "session expired".
  Use the Explore agent to investigate the auth flow and find the race
  condition. Then propose a fix.

[Explore agent investigates, returns summary]

> OK, that hypothesis sounds right. Implement the fix and add a
  regression test that demonstrates the issue.

Refactoring katta module

claude

> (Shift+Tab Shift+Tab — plan mode)
> I want to refactor src/legacy/payments/ to use the new payment provider
  abstraction. Don't make any changes — first, give me a plan. List:
  files to change, new files to create, migration strategy, risks.

[Claude returns plan]

> Approved. Switch to acceptEdits mode and implement step 1.

Code review

claude

> /review

[Built-in /review skill activates, reviews PR diff, posts comments]

Yoki manual:

> Use the security-reviewer agent to audit the changes in this PR.
  Then use a separate reviewer agent for code quality.
  Run them in parallel.

CI integration (headless)

.github/workflows/claude-review.yml:

name: Claude Review
on: pull_request
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with: { fetch-depth: 0 }
      - run: curl -fsSL https://claude.ai/install.sh | bash
      - run: |
          claude -p "Review this PR for bugs, security issues, and style.
                     Run: gh pr diff. Output as markdown checklist." \
            --output-format json \
            --max-budget-usd 1.00 \
            --allowedTools "Bash(gh *) Read Grep" \
          > review.json
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      - run: gh pr comment $PR_NUMBER --body-file review.json

Migration script generation

claude

> @src/db/schema.ts da User table'ga 'two_factor_enabled' boolean
  ustun qo'shildi. Postgres uchun migration yoz: up + down. Existing
  rows uchun default false. Index kerak emas. Migration'ni
  ./migrations/ ga qo'y.

Documentation generation

claude

> src/api/ ichidagi har bir endpoint uchun OpenAPI spec yoz.
  Existing spec @docs/openapi.yaml ni baseline qilib ol.
  Endpoint discover qilish uchun src/api/routes.ts dan boshla.

Multi-step ish — subagent orchestration

claude

> I need to migrate from express to fastify. Here's the plan:

  1. Use the 'researcher' agent to find all express-specific code.
     Output: file list with the type of usage.
  2. Use the 'planner' agent to design the migration phases.
  3. We'll execute phases one by one with my approval.

  Start by spawning the researcher and planner in parallel.

Bob 17Muammolarni hal qilish

Diagnostika, tipik xatolar, debug logging va plugin/MCP'ni izolatsiya qilish — nimadir noto'g'ri ketganda nima qilish kerak.

/doctor — birinchi qadam

Har qanday muammo — /doctor bilan boshlang. U quyidagilarni tekshiradi:

• Versiya va auto-update statusi
• PATH va shell integration
• Auth holati
• Sozlamalar ierarxiyasi
• Hooks va MCP server statuslari
• IDE integratsiya holati

Tipik muammolar

Debug logging

claude --debug "api,hooks"
claude --debug-file /tmp/claude-debug.log

Versiya muammolari

claude --version
claude update          # Native installer'lar uchun
brew upgrade claude-code   # Homebrew
winget upgrade Anthropic.ClaudeCode

Plugin/MCP muammolarini izolatsiya qilish

Agar nimadir g'alati ishlasa, sof boshlang:

claude --plugin-dir /dev/null   # Plugin'larsiz
claude --mcp-config /dev/null   # MCP'larsiz
claude --bare                   # Minimal mode

Ilova ACLI bayroqlari

Sessiya boshqaruvi, fayl/papka kirish, konfiguratsiya, tools va debug — barcha CLI bayroqlari bir joyda.

Sessiya boshqaruvi

claude                              # Interaktiv
claude "prompt"                     # Boshlang'ich prompt bilan
claude -p "query"                   # Print mode (chiqib ketadi)
claude -c, --continue               # Oxirgisini davom ettirish
claude -r, --resume [name]          # Sessiya tanlash / nomi bilan
claude --fork-session               # Yangi shoxda davom ettirish
claude -n "name"                    # Sessiyaga nom berish

Fayl/papka kirish

claude --add-dir /path              # Qo'shimcha papka kirish
claude -w branch-name               # Worktree mode

Konfiguratsiya

claude --model claude-opus          # Model override
claude --effort high                # Effort darajasi
claude --permission-mode auto       # Permission mode
claude --settings ./settings.json   # Settings fayl
claude --system-prompt "text"       # System prompt almashtirish
claude --append-system-prompt "..." # Qo'shimcha qo'shish
claude --system-prompt-file path    # Fayldan

Tools / Permissions

claude --allowedTools "..."         # Pre-approve
claude --disallowedTools "..."      # Bloklash
claude --tools "Bash,Edit,Read"     # Faqat shu tool'lar
claude --dangerously-skip-permissions  # Hech narsa so'ramaslik

Output formatlar (headless)

claude -p --output-format json
claude -p --output-format stream-json
claude -p --output-format text

Cheklovlar va xarajat

claude -p --max-turns 5
claude -p --max-budget-usd 10.00

MCP / Plugin

claude --mcp-config ./mcp.json
claude --plugin-dir ./my-plugin

Debug

claude --debug "api,hooks"
claude --debug-file /tmp/log.txt
claude --verbose
claude --bare                       # Minimal mode (tez startup)
claude --version
claude update

Ilova BFayl joylari

Foydalanuvchi va loyiha darajasidagi sozlama, skill, agent, hook, MCP va sessiya fayllarining joylari.

Ilova CCheatsheet

Eng kerakli buyruqlar, fayllar va patternlar — tezkor murojaat uchun.

Eng kerakli buyruqlar

claude                     # Boshlash
claude -c                  # Davom
claude -r                  # Tanlab davom
claude -p "..."            # Headless

@file                      # Fayl kontekstga
/clear                     # Toza boshlash
/compact                   # Tarix qisqartirish
/context                   # Kontekst hajmi
/cost                      # Xarajat
/model                     # Model almashtirish
/agents                    # Agent ro'yxati
/mcp                       # MCP serverlar
/hooks                     # Hooks
/permissions               # Ruxsat qoidalari
/init                      # CLAUDE.md
/review                    # PR review
/doctor                    # Diagnostika
/think hard                # Kuchli fikrlash
/ultrathink                # Eng kuchli fikrlash

Shift+Tab                  # Permission mode aylanish
Shift+Tab x2               # Plan mode
Esc Esc                    # Rewind menu
Cmd/Ctrl+V                 # Image paste

Eng kerakli fayllar

./CLAUDE.md                      # Loyiha xotirasi
./.claude/settings.json          # Loyiha sozlamalari
./.claude/skills/*/SKILL.md      # Custom skills
./.claude/agents/*.md            # Subagentlar
./.mcp.json                      # MCP konfigi

Eng samarali patternlar

1. Plan mode oldin, acceptEdits keyin
2. Subagent — investigation uchun, asosiy — implementation uchun
3. Bir nechta mustaqil narsa — parallel
4. Yangi vazifa — /clear
5. Takror ish — skill yarating
6. Unutilmaslik kerak narsa — hook'ga aylantiring
7. Murakkab masala — /ultrathink
8. Har doim verification step