Summary of "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.
Category
Technology
Share this summary
Is the summary off?
If you think the summary is inaccurate, you can reprocess it with the latest model.
Preparing reprocess...