CLAUDE CODE: ПОЛНЫЙ КУРС 2026 (4+ ЧАСА)

High-level overview

Claude Code is an agent-enabled interface to Claude designed for richer, agent-driven workflows beyond simple chat. It can access your filesystem, call web APIs, control browsers, run terminal commands, and use external tools.

Key capabilities:

• Filesystem operations: read, write, delete (with permission prompts by default).
• Internet/web requests and external API calls.
• Tool/extension ecosystem (MCPs) and Skills (reusable prompt + asset packages).
• Subagents: isolated worker agents for parallel or compartmentalized work.
• Agent teams: multi-agent orchestration with TeamLead and teammates.
• Project-level rules via a project “claude.md”.
• User-level AutoMemory for persistent user-specific notes.

---

Installations & frontends covered

UI/clients demonstrated:

• Antigravity (visual shell desktop client)
• VS Code extension
• Cursor-style IDEs
• Terminal client (cld) — mentions Warp and iTerm2 as terminals

Walkthrough highlights:

• Install Antigravity and the VS Code extension, log in, enable/disable AI and voice features.
• Add the Claude UI to VS Code’s activity bar.
• Create an alias to run cld with bypass permissions (used carefully).
• Example demo: scaffold a Chrome extension via Claude, load it unpacked into Chrome, preview results.

---

Voice input / “whisper” tools

Recommendations:

• Prefer external transcription (“whisper”) tools for dictation when you need higher and more consistent transcription quality.
  • Paid / high-quality options: VisperFlow (30-day links referenced), Aquavoice.
  • Free alternatives: Henny and other local Whisper-based tools.
• Claude has built-in voice input, but its transcription can be inconsistent; external whisper services often perform better.

---

Permissions and safety

Default behavior:

• Claude prompts before making file operations. A Bypass Permission mode exists but is dangerous — use with extreme caution.

Best practices:

• Use project-level sandboxing to constrain what Claude can modify.
• Never store production secrets in the repo. Use secure secret stores (GitHub Actions secrets, env vars managed properly, external vaults).
• Audit community skills/plugins before using them; verify security audits and provenance.

---

claude.md (project-level rules) and AutoMemory (user-level)

claude.md (project)

• Purpose: preload essential project context and rules into every session so agents don’t need to re-scan the entire repo on each start.
• Created with cld init.
• Keep concise — avoid huge files; ~<500 lines recommended.
• Good uses: process requirements, coding style, non-sensitive defaults (for example: “answer in Russian”, “never use letter ё”).

AutoMemory

• User-level, persistent memory where Claude may store notes about interactions.
• Stored at the user level (not committed to the repo); behavior is more opaque.
• Recommendation: prefer explicit rules in claude.md for reproducibility and handover; don’t rely on AutoMemory for critical operational requirements.

---

Tools ecosystem: MCP → Skills → CLI/SDK

Overview

• MCP (older paradigm): exposes external tool handles (e.g., Chrome DevTools, Exa) as callable APIs to Claude. Downsides include context-window bloat and rigidity.
• Skills (preferred): Anthropic’s newer abstraction — packaged prompts + assets + optional scripts/tools.
  • Only a small trigger/header is in context initially; full instructions and assets load on demand.
  • Easier to share, version, and install (marketplaces, NPX installers).
  • Can include documentation, reference files, and scripts.
• CLI & SDK approach: recommended for flexible integrations. Move heavy logic to external CLIs/APIs to reduce context bloat and gain more control.

Practical notes

• Examples: installing Chrome DevTools MCP, installing Exa (web search) as an MCP, using Playwright and other CLIs for browser automation.
• Tip: install global MCPs only if used frequently; otherwise scope them to the project to avoid context noise.

---

Skills & marketplace

What skills are

• Reusable modules that include trigger phrases, long instructions, reference files, scripts, and mappings to tools.
• Installable via NPX or cld tooling (project vs user/global scope).

Where to find them

• Official Anthropic marketplace / plugins
• Community marketplaces such as Skills.sh

Security

• Audit community skills before installing. Check provenance and any available security reviews; don’t blindly trust un-audited plugins.

---

Subagents

What they are

• Lightweight, isolated agent sessions used as parallel workers to handle parts of a larger task.

Use cases

• Parallelize long-running tasks (research, multi-variant generation).
• Run separate code reviewers or design variant generators.
• Avoid bloating the main session’s context.

Behavior and setup

• Each subagent has a limited context and can be given specific skills, tools, and models.
• They run in parallel and return results to the main agent.
• Fields when creating subagents: model, tools, skills, memory.

Benefits

• Much more context-efficient than stuffing everything into one session or launching many full sessions.

---

Agent Teams

Overview

• Team-level orchestration where a TeamLead agent spawns multiple full agents (teammates) that can communicate with each other.

Difference from subagents

• Teammates are often full Claude sessions with richer, interactive capabilities and message exchange.
• Heavier in terms of context and token usage.

Best uses

• Multi-perspective research (e.g., lawyer vs skeptic), debate/resolution of competing hypotheses, cross-discipline analysis.

Drawbacks

• More complex to set up and much higher token cost. Usually not recommended for beginners or routine coding tasks.
• Agent teams are behind experimental flags in settings.

---

Context window and management (core concept)

Context sizes

• Claude Code sessions commonly demonstrate ~200k token windows; Opus models can approach ~1M tokens.

Rule-of-thumb zones

• Green zone: first ~50% — reliable area for instructions and crucial context.
• Orange zone: up to ~70% — riskier; content may start losing priority.
• Red zone: >~85% — automatic compaction/summarization may start; risk of losing important details.

Recommendations

• Decompose large tasks into smaller sessions; avoid stuffing everything into one prompt.
• Use claude.md to keep essential persistent context at the start of session input.
• Use subagents, skills, and external CLIs to avoid filling the main context.
• Use “double-escape” patterns to rewind conversation or roll back workspace changes (undo dialogs + file changes).
• Keep per-project vs global configs organized (user settings vs project settings).
• Monitor token usage (example: cld init demo used ~33k tokens).

---

Developer workflows, git & automation

Process suggestions

• Build repeatable processes instead of ad-hoc prompts. Example: plan → implement → test → iterate.
• Use Git / GitHub branches and GitHub Actions to CI/automate agent-driven tasks.
• Keep secrets out of the repo; use GitHub Actions secrets or external vault services.
• Organize agents and skills in repo structures (e.g., .claude/ for skill definitions), deciding what belongs in the repo vs user-level configuration.

---

Examples & demos from the course

Selected practical demos shown:

• Installing and using the Claude VS Code extension and Antigravity client.
• Automatically creating a Chrome extension (scaffold + manifest) and loading it unpacked into Chrome.
• Setting an alias to run cld with bypass permissions.
• Using VisperFlow or Aquavoice for dictation and integrating voice into the workflow.
• Using Chrome DevTools MCP to open pages and take screenshots programmatically.
• Installing community skills for frontend design (via NPX) and composing skills to generate multiple landing versions.
• Launching subagents to generate multiple design variants in parallel and collecting results in the main session.
• Launching an agent Team (e.g., lawyer vs skeptic) to critique a landing page from multiple perspectives.

---

Practical tips / recommendations

• Start with a small, repeatable process; learn decomposition and tool integration before scaling to agent teams.
• Use cld init and a concise claude.md to reduce repeated startup token costs.
• Prefer skills and CLI integrations over many MCPs to minimize context bloat.
• Use project-level sandboxes and avoid granting global write permissions unless strictly necessary.
• Test voice input providers and prefer external whisper services for higher transcription quality.
• Begin with a Pro subscription and scale up as token/throughput needs grow (Pro ≈ $17–20/mo; Max ≈ $100/mo in demo).

---

Where to look for tools and docs

Primary resources:

• Official Claude Code docs (Anthropic) — skills, MCPs, subagents, agent teams, settings.
• Skills marketplace and Skills.sh (community/shared skills).
• MCP / Chrome DevTools docs and Exa (web search API) docs.
• NPX-centered installers for community skills.
• Git and GitHub Actions docs for automation and secrets management.

---

Main speaker / sources

Presenter:

• Vanya — YouTube and Telegram channel author; presents hands-on demos.

Primary tools and sources referenced:

• Anthropic / Claude Code official docs (skills, MCP, subagents, agent teams)
• Antigravity (desktop shell client)
• VS Code extension (Claude)
• Warp, iTerm2 (terminals)
• VisperFlow, Aquavoice, Whisper (voice transcription)
• Exa (crawling/search MCP)
• Playwright, Chrome DevTools MCP
• Skills.sh / Anthropic plugin marketplace
• Git, GitHub Actions, NPX

---

If useful, a concise checklist (install steps, safety checklist, recommended folder layout, and a minimal claude.md template) or a one-page “best-practices” for building an agent-driven repo can be extracted from this summary.