Skip to main content

10× productivity for developers · Agentic engineering · June 2026 Edition

Claude Code Course: agentic coding from first prompt to autonomous agent

10× productivity for developers who already write code and want to step into agentic engineering — the new discipline after prompt engineering and vibe coding (Karpathy, February 2025). A practical PDF course for developers and non-coders alike. Learn Claude Code CLI, Plan Mode, Subagents, hooks, slash commands, MCP servers, Claude Agent SDK, Anthropic API, Skills, Computer Use, and vibe coding in 8 hours of reading.

No coding experience required to start — Claude writes the code, you steer the vision. 220-page PDF, 10 modules, 50+ prompts, 5 portfolio projects. Lifetime access, free updates. See also comparisons: Claude Code vs Cursor, Claude Code vs GitHub Copilot, and Claude Code vs Aider.

220-page PDF 10 modules 50+ dev prompts 5 portfolio projects Discord 24/7 Lifetime access

One-time payment, no subscription · 14-day withdrawal right under consumer protection law · Invoice on request

claude-code — session 01
$ claude
Claude Code 1.4.0 · model: claude-opus-4-7
Reading CLAUDE.md...  ✓ (context: 4.2k tokens, cached)

> Refactor the useUser hook to support suspense and error boundary.
> Add tests. Maintain backward compatibility.

→ planning (3 steps)
→ /test-this (skill, hook PostToolUse: prettier)
→ commit: refactor(hooks): useUser + suspense + tests
✓ 14 files modified, 27 tests added, 0 regressions.

> /security-review
→ MCP github-bridge: comparing with previous PR...
→ skill: 0 hardcoded secrets, 0 unsafe queries, 0 missing CSP.
✓ Ready to merge.

Example session from module 8. PostToolUse hook + custom skill + MCP server working together.

New discipline

Agentic engineering — why it's the future of software development

Agentic engineering is the new discipline of designing systems where an agent (like Claude Code or an application built on the Claude Agent SDK) executes multi-step tasks autonomously. The agent uses tools, keeps context between steps, plans, corrects errors, and reports results. It sits in the lineage of "software 2.0" (Karpathy 2017) and "vibe coding" (Karpathy February 2025), but as a distinct engineering discipline. It's the next rung after prompt engineering — which focused on single queries — and after vibe coding, which focused on intuitively directing a model without understanding the code.

The difference looks like this. A prompt engineer queries the model once and interprets the response. A vibe coder converses iteratively, steering by feel. An agentic engineer designs loops where the model makes its own decisions, uses hooks, reaches for data through MCP servers, spawns subagents, writes memory to files, and tests its own changes. This is no longer a chatbot conversation — it's building a system. Hence the engineering analogy: agentic engineering has its own patterns, anti-patterns, tests, debug techniques, and SLAs.

For a mid-level developer (3–7 years of experience) this discipline is the biggest productivity lever since Stack Overflow. If you already write code, you have an advantage over a pure vibe coder — you read agent output critically, catch hallucinations, and design guardrails. On the other hand, this skill won't come from just using Copilot. Agentic engineering requires deliberate practice with tools like Claude Code, the Claude Agent SDK vs alternatives, and Plan Mode. The market for this skill is forming right now — developers who get in early are 12–18 months ahead of the average.

See also: Claude Code vs OpenAI Codex and Claude Code vs Bolt — how agentic architecture differs across tools.

Reality check

99% of developers use Claude Code like ChatGPT and miss 90% of its potential

Anthropic ships a CLI with an agentic loop, hooks, MCP, Agent SDK, Files API, prompt caching, and Batch API. In practice, most developers only use the message-response loop. The rest sits idle — because the documentation is scattered, English-only, and without practical workflow patterns.

3%

of Claude Code features used

The average developer uses the CLI like an upgraded ChatGPT. Hooks, MCP, Agent SDK, custom skills, plugins, Batch API — all left untouched.

0

hooks in settings.json

Without automation you start every project from scratch. Lint, format, validation, deny destructive commands — all manual or skipped entirely.

10×

more context copying

Without MCP servers you paste code, DB schema, Linear ticket, error log, config file... every single time. MCP eliminates 90% of that.

50–80%

costs left on the table

Without prompt caching and Batch API you pay full price for every token. Caching = -50%, Batch = -50%. Together the course pays for itself in the first month.

What's holding you back

Four things blocking developers in their work with Claude and AI tooling

Copy-pasting context into ChatGPT, starting from zero every time

Each conversation from scratch. You paste project structure, conventions, the last commit. Claude Code with CLAUDE.md and hooks remembers all that for you. Without it you waste 30 minutes a day on re-briefing.

10 hours a week thrown away on re-contextualising the same conversation.

Claude doesn't know your setup and guesses

It's missing your DB schema, endpoint list, Linear ticket, internal docs. Instead of one prompt you ask ten. MCP servers give it live access to those sources.

Hallucinations, refactors that break other modules.

Typing the same commands 100 times

/review, /test-this, /refactor, /commit-with-summary, /update-docs. Every project needs 5–15 commands. Without slash commands you copy prompts from Notion or Discord.

No consistency across the team — everyone does it differently.

Paying for redundant tokens, costs keep climbing

Every conversation is a new context, new cost. Without prompt caching you pay 100% for a system prompt that hasn't changed in months. Without Batch API you pay 100% for tasks that could wait 24h.

Anthropic bill grows 3–5×, CTO starts asking questions.

Productivity math

What takes a senior a day, you do in an hour

Legacy migration

Time
3 days 4 hours
Stack
expert + senior dev you + Claude
Quality
regression risk test coverage

PR review

Time
30 min/PR 2 min/PR
Stack
your time agent /review
Quality
subjective rule-based

Bug investigation

Time
2–4 h 15 min
Stack
grep + log + intuition scientific method skill
Quality
trial and error hypothesis → test

Where these numbers come from: my own practice and 30+ projects with Claude Code in 2026. These aren't benchmark highs — they're weekly averages. See the full curriculum →

Curriculum

Ten modules — from CLI setup to autonomous agent

Every module has a theory section (what it is), a practical section (how to do it), anti-patterns (what to avoid), and a hands-on exercise with a ready solution. Together: 220 pages of PDF.

  1. 01

    Setup and Claude Code Fundamentals

    25 pages
    • CLI installation on macOS, Linux, Windows, WSL
    • API key setup, model selection (Opus / Sonnet / Haiku), cost per model
    • First project: hello world and first commit with Claude Code
    • Anatomy of the .claude/ folder (settings, commands, skills, hooks, memory)
    • IDE integrations: VS Code, JetBrains, Cursor (parallel use)
  2. 02

    Effective Prompting for Developers

    20 pages
    • Claude-specific patterns: XML tags, system prompt vs message
    • TDD prompting (red, green, refactor with AI)
    • Refactor prompts: small / medium / large scope
    • Bug investigation: 5 whys with Claude, hypothesis-driven debugging
    • Code review prompts for different types of change
  3. 03

    Slash Commands and Custom Skills

    25 pages
    • Anatomy of a slash command and system args
    • Custom slash commands per project (.claude/commands/)
    • Plugin skills (claude-code-plugins) and namespaced skills
    • Skill packs: testing, refactoring, debugging, documentation
    • Implemented examples: /review, /test-this, /refactor, /security-review
  4. 04

    Hooks and Automation in Claude Code

    25 pages
    • Hook types: PreToolUse, PostToolUse, UserPromptSubmit, Stop, SessionStart
    • Hook config syntax in settings.json
    • Use cases: blocking destructive commands, auto-format, custom validation
    • Hookify pattern — converting recurring frustration into a hook
    • Hands-on: 10 ready-to-use hooks to download
  5. 05

    MCP Servers — Extending Claude with Your Tools

    30 pages
    • What Model Context Protocol is and why it changes everything
    • Architecture: stdio vs SSE servers, security model
    • MCP clients: Claude Code, Claude Desktop, Cursor, Cline
    • Writing your own MCP server in Python and Node.js (step by step)
    • Use cases: DB integration, GitHub, Linear, Notion, internal APIs
    • Hands-on: build an MCP server for a team workflow
  6. 06

    Claude Agent SDK — Building Autonomous Agents

    25 pages
    • Agent loop architecture, tools, system prompt
    • Context window management and memory: file-based, persistent
    • Multi-step tasks, error handling, retry logic, idempotency
    • Subagents and parallel execution
    • Hands-on: agent that autonomously triages GitHub issues
  7. 07

    Anthropic API — Production Patterns

    25 pages
    • Messages API: messages, system, max_tokens, stop_sequences
    • Prompt caching: when, how, how much it saves (50% off)
    • Batch API: async tasks at 50% off
    • Tool use and function calling with Claude in Python and TypeScript
    • Files API, citations, vision (image / PDF input)
  8. 08

    Production Workflow Patterns

    20 pages
    • Greenfield vs brownfield projects — where to start
    • Code review workflow with Claude (per PR, per module, per release)
    • Migration patterns: legacy to modern stack
    • Debugging patterns: local, staging, production
    • Documentation generation: README, ADR, runbooks
    • Pair programming with Claude vs solo — when to use which
  9. 09

    Security and Cost Control

    20 pages
    • Prompt injection: attack vectors and defence layers
    • Secrets management in Claude Code (env vars, .gitignore, vault)
    • Cost monitoring, alerts, per-project dashboard
    • Token budgeting — how not to blow the budget in the first week
    • Compliance: GDPR, sensitive data at Anthropic, BAA / data residency
    • Self-hosted alternatives — when NOT to use Claude (classification)
  10. 10

    Case Studies + 5 Portfolio Projects

    25 pages
    • Case: SaaS migration with Claude Code (real, 14 days → 2 days)
    • Case: MCP server for a team — adoption story in an 8-person dev team
    • Case: agent autonomously fixing backlog bugs (P3–P4)
    • 5 portfolio projects to build during the course
    • Learning roadmap: development plan for the next 6 months

5 portfolio projects

You will leave the course with five working projects

01

Your own slash command pack

5 custom commands per project type (web app, CLI, API, library). Reusable across the team.

.claude/commands/*.md

02

MCP server: linear-bridge

Integrate Linear with Claude. List tickets, comment, update status, assign, search.

linear-mcp.py + npm package

03

Hook system guardrails

10 hooks blocking common mistakes: rm -rf, hardcoded secrets, broken imports, unused vars.

.claude/settings.json + scripts/

04

Custom agent: PR-reviewer

Agent reviews PRs automatically. Checks style, naming, complexity, test coverage, security.

agent.ts + GitHub Action

05

Production app shipped solo

Full SaaS from zero to live with Claude Code: backend, frontend, deploy, monitoring, billing.

Working project + post-mortem

Stack

The complete Anthropic ecosystem in one course

Claude Code CLI

Terminal interface, agentic loop, file editing, bash execution

Claude Agent SDK

Building custom agents programmatically

Anthropic API

Messages, Files, Batch, Vision, Citations

Model Context Protocol

Extending Claude with your own tools

Hooks & Settings

Workflow automation via settings.json

Plugins & Skills

Reusable command packs and namespaced skills

IDE Integrations

VS Code, JetBrains, Cursor parallel

Prompt Caching

50% off on repeating system prompts

New in 2026

The 2026 standard that most developers haven't touched yet

Anthropic's 2026 trends report identifies four features that have become the default for senior-level work with Claude: Plan Mode, Subagents, Skills, and Computer Use. Their adoption is still limited in most dev ecosystems — this course is the first place to cover all four in one structured sequence.

Plan Mode

Claude plans multi-step tasks before touching a single file. Anti-spaghetti workflow that cuts bad refactors and blind fixes. Press one key before a big change, review the step-by-step plan, approve it — then Claude executes. The new default for senior-level work with an agent.

Claude Code vs Cursor — when Plan Mode matters →

Subagents

Parallel execution for 5× faster research and simultaneous file analysis. The orchestrator splits work across subagents, each with its own context window, all reporting back. In practice: audit 200 files in 4 minutes instead of 25.

Claude Code vs Codex — agent architecture comparison →

Skills

Reusable workflow packs per project and namespaced commands. A skill is a packaged prompt + tools + examples that you use across multiple projects. Build once, use everywhere. The emerging standard for distributing dev knowledge in 2026.

Computer Use

Claude sees your screen and clicks UI elements — GA since September 2025. End-to-end test automation, scraping apps that have no API, smoke tests after deploy. Not just a CLI agent — a desktop operator under your supervision.

Who it's for

Five types of people who get the most out of this Claude Code course

Founders without coding experience (vibe coders)

You have an idea for a SaaS, tool, or automation but don't know how to code. Claude Code writes the code, you manage the vision. The course teaches you how to direct an agent step by step, how to verify the output, how not to break production. No CS degree, no terminal experience needed.

Mid-level developers (3–7 years)

You know TypeScript / Python / Go, use Copilot or Cursor, have heard of Claude Code but aren't sure where to start. This course will push you to senior-level productivity in 8 hours of reading.

Tech leads and staff engineers

You're responsible for the productivity of 5–15 devs. You need a structured rollout plan, governance, cost control, ROI numbers for the CTO. The course delivers a ready playbook plus onboarding materials.

Indie hackers and solo founders with dev experience

You build SaaS products alone. Every hour is a build/buy decision. The course teaches a workflow that shrinks the cycle from idea to shipping — from weeks to days.

Freelancers and IT contractors

You sell B2B contracts. You want to deliver more in the same time and raise your rates. The course shows how to increase throughput 3–5×.

You might be thinking...

Five reasons people delay learning Claude Code — answered

"I can't code — this isn't for me"

It's precisely for you, if you have an idea and persistence. Claude Code writes the code, you steer the vision. Vibe coding is a new category, and the course has a dedicated chapter for people with no terminal experience. Assumption: if you can send an email and open a folder, you can do this. Claude handles the coding — the course handles working with Claude.

"I already use Cursor or GitHub Copilot"

Claude Code works in parallel — it doesn't replace your IDE. It's a CLI agent that complements Cursor and Copilot. Cursor edits, Claude Code plans, MCP provides context that Cursor doesn't have. The course shows how to integrate all three.

"The Anthropic API is expensive"

Without optimization, yes. The course covers prompt caching (50% off repeating prompts), Batch API (50% off async), and model selection per task (Haiku 4.5 vs Opus 4.7 — a 10× price difference). In practice: students cut their bill by 50–80%.

"I don't know anything about AI or ML"

The course requires no ML knowledge or PhD. Claude Code is a developer tool, not an ML project. You don't need to understand how a transformer works — you just need to learn to talk to it. If you can write in English, you have everything you need.

"I can just read the Anthropic docs myself"

You can. The Anthropic documentation is ~50 pages + 100 pages of MCP spec + 80 pages of Agent SDK. That's 230 pages scattered across 6 sub-sites, in English, with no workflow patterns. This course is 220 pages with a system, code examples, and 5 projects. Time: course ~8h vs docs ~50h.

Your instructor

Who wrote this course

ŁK

Łukasz Kowalski

Creator of KursVideoAI — I use Claude Code every day on commercial projects. I build MCP servers, write custom skills, and deploy autonomous agents to production. This course is a distillation of the workflow I actually use, not a rehash of Anthropic's docs. More about me →

Bonuses

What you get beyond the 220-page PDF

50+ dev prompt bank

Ready-to-use prompts for refactoring, bug investigation, security review, performance, accessibility, documentation. Copy, paste, done.

Hooks template pack (10 hooks)

settings.json snippets to copy: deny destructive, auto-format, pre-commit lint, custom slash command validation, session start init.

MCP server starter kit

3 working MCP servers to download: GitHub bridge, Linear bridge, Notion bridge. Fork and adapt to your stack.

Slash commands pack

5 production-ready commands: /review, /test-this, /refactor, /security-review, /docs. With prompts, hooks, and example outputs.

Cheat sheet PDF

One-page quick reference: all key commands, flags, environment variables, file paths. Print it and pin it up.

Discord channel #claude-code

A dedicated channel for developers. Updates, new Claude features, code reviews, Q&A with fellow students.

Pricing

One payment. Lifetime access. The complete Claude Code course.

June 2026 Edition One-time payment
See price →

one-time payment · lifetime access · no subscription

  • 220-page PDF, 10 modules
  • Full ecosystem: CLI, hooks, slash commands, MCP, Agent SDK, API
  • 50+ developer prompts ready to use
  • 10 hook templates to copy
  • 3 MCP server starter kits (GitHub, Linear, Notion)
  • 5 production-ready slash commands
  • 5 portfolio projects to build
  • Cheat sheet PDF (one page)
  • Discord channel #claude-code 24/7
  • Lifetime access + all future updates for free
  • 14-day withdrawal right under consumer protection law
Get the Claude Code Course

Stripe · Card · Apple Pay · Google Pay

FAQ

Common questions about the Claude Code course

What is the difference between agentic engineering and prompt engineering?

Prompt engineering is the art of crafting one-off queries to a model (e.g. ChatGPT, Claude in chat). Agentic engineering is designing systems where an agent (Claude Code, Claude Agent SDK) executes multi-step tasks autonomously — using tools (bash, file editor, MCP), keeping context between steps, and self-correcting. It's the difference between a single prompt and a complex pipeline. The course covers both, but the center of gravity has shifted to agentic.

Does the course cover Plan Mode and when to use it?

Yes. Plan Mode is the Claude Code feature that forces the agent to present a step-by-step plan before touching any files. Use it before large refactors, migrations, and brownfield investigations. Module 8 shows 5 situations where Plan Mode is essential (e.g. refactoring 14 files, legacy migration, production debugging) and 3 where it wastes time (hot fix, obvious 1-line change, prototype). After that module, Plan Mode becomes your default before any change larger than 50 lines.

What are subagents and how do I use them in Claude Code?

Subagents are parallel agents running in separate context windows that report to an orchestrator (the main agent). In practice, when you ask for an audit of 200 files, the main agent distributes the work across 5–10 subagents, each handles its share, and the orchestrator aggregates the results. Speed-up: 3–5×. Module 6 shows patterns for when subagents help (research, audits, parallel test runs) and when they hurt (sequentially dependent tasks). Hands-on: subagent pipeline that audits a repo in 4 minutes.

Does the course show how to build an MCP server from scratch?

Yes. Module 5 (30 pages) is dedicated to MCP servers, including writing your own from scratch in Python and Node.js. Architecture: stdio vs SSE, security model, error handling, deploy. Three ready-made servers as templates (GitHub bridge, Linear bridge, Notion bridge) to fork. After the module you can build your own MCP server for a team workflow in under an hour.

Does the course cover Computer Use (Claude seeing the screen)?

Yes. Computer Use became GA in September 2025 — Claude sees a screenshot and clicks UI coordinates. The course covers use cases (smoke tests after deploy, scraping apps without an API, automating repetitive workflows in tools with no API) as well as limits (slow, expensive, requires supervision). It also shows how to combine Computer Use with Plan Mode: the agent plans what to click, then clicks.

Can I learn Claude Code if I don't know how to program?

Yes — that is one of the two main use cases for this course (vibe coding). Claude Code writes the code for you; your role is to describe what you want, verify the output, and decide on changes. What you need: patience and logical thinking. What you don't need: a programming language, terminal experience, or a CS course. The first module and a dedicated FAQ section for vibe coders walk you step by step from installing the CLI to your first working application.

What is vibe coding and does this course teach it?

Vibe coding is a new way of working with AI where you don't write code yourself — instead you direct Claude (or another agent) through your product vision and it delivers the implementation. You assess, correct, and verify. The course covers both sides: vibe coders (how to direct an agent when you don't know the code yourself) and developers (how to use Claude Code to ship faster in production).

I already use Copilot — is this course still useful?

Yes. Claude Code is a CLI agent that works alongside GitHub Copilot, Cursor, and other IDEs. Copilot is autocomplete in the editor; Claude Code is an agent that plans, edits multiple files, runs bash commands, and uses MCP servers. These are different layers of the stack. The course shows how to integrate them and when to use each one.

How long does it take to finish the Claude Code course?

The full PDF (220 pages) takes 8–10 hours to read. With hands-on work (5 portfolio projects + hook setup + first MCP server) that's a weekend or 7 evenings of about 1 hour each. Lifetime access means you set your own pace.

Does the course also cover the Anthropic API and Claude Agent SDK?

Yes. Module 6 covers the full Claude Agent SDK (agent loop architecture, tools, memory, subagents). Module 7 covers the Anthropic API (Messages, Batch, prompt caching, tool use, Files, Vision). The complete Anthropic ecosystem in one course.

What is the difference between Claude Code, Cursor, and GitHub Copilot?

Cursor is an AI-first IDE (editor with a model inside). Copilot is autocomplete in VS Code. Claude Code is a CLI agent with an agentic loop, hooks, slash commands, MCP servers, and custom skills. Cursor edits, Copilot suggests, Claude Code plans and executes multi-step tasks. The course covers all three and the workflow for each.

Does the course cover MCP servers (Model Context Protocol)?

Yes. Module 5 (30 pages) is dedicated entirely to MCP. Architecture: stdio vs SSE, writing your own server in Python and Node, 3 ready-made servers as templates (GitHub, Linear, Notion). MCP is a game-changer for developers deploying Claude in production, so it gets thorough coverage.

How do I start with Claude Code from scratch if I've never used a CLI?

Module 1 (25 pages) walks you through it: installation on Mac / Linux / WSL, API key setup, first hello-world project, .claude/ folder structure, IDE integration. The only assumption is basic git and bash (cd, ls, cat). If you don't have those, spend one evening on bash + git, then start your first Claude Code session.

Do I need a Claude Pro subscription to start with Claude Code?

No. Claude Code can be run with an Anthropic API key (pay-per-use, no subscription) or with a Claude Pro / Max subscription. The course covers the costs of both options, when each makes sense, and how to choose a model (Haiku 4.5 / Sonnet 4.6 / Opus 4.7) based on your budget and task.

Are Claude Code hooks complicated to learn?

No. A hook is a JSON config in settings.json, optionally with a shell command. Module 4 (25 pages) explains all 5 hook types (PreToolUse, PostToolUse, UserPromptSubmit, Stop, SessionStart), provides 10 ready-made hooks to download, and walks through the hookify pattern with examples. After the module you can write your own hook in 10 minutes.

Does the course teach how to build custom agents with the Claude Agent SDK?

Yes. Module 6 (25 pages) is dedicated to the Claude Agent SDK. Agent loop architecture, tools, system prompt, file-based memory, multi-step tasks, error handling, parallel subagents. Hands-on: build an agent that autonomously triages GitHub issues. After the module you have a template for every future agent project.

Does the course show how to optimize Anthropic API costs?

Yes, in two sections: Module 7 (prompt caching 50% off + Batch API 50% off) and Module 9 (cost monitoring, alerts, token budgeting). In practice, students reduce their Anthropic bill by 50–80% within a month. The course pays for itself in the first week of production use.

Does Claude Code work with large codebases (1M+ lines)?

Yes, but it requires specific patterns: CLAUDE.md per module, an MCP server with code search, slash commands per workflow, and file-based memory. Module 8 covers production workflow patterns for brownfield / legacy / monorepo projects. It shows how Claude Code scales from a solo dev to a 20-person team.

Will I get updates when Anthropic releases a new model or feature?

Yes, all updates are free forever. New modules are added when a significant feature ships (e.g. new Computer Use, Memory Tool 2.0, Files API v2). Currently 10 modules; planned growth to 14–16 over the year.

Is this course a PDF or video?

PDF (220 pages) + Discord. No video in v1. Deliberate choice: developers read faster than they watch, and a PDF is easier to search, copy code from, and consume at your own pace. Video may appear in v2 as a bonus.

Can I get a refund if the course isn't right for me?

Yes — you have 14 days to withdraw under consumer protection law. The right to withdraw expires once you access the PDF with your explicit consent. The price is a one-time payment with no subscription.

Ready?

Either you stay in the 3% of Claude Code features — or today you learn the rest.

Get the Claude Code Course

One-time payment · lifetime access · delivered in 1–2 minutes