Legacy migration
- Time
- 3 days → 4 hours
- Stack
- expert + senior dev → you + Claude
- Quality
- regression risk → test coverage
10× productivity for developers · Agentic engineering · June 2026 Edition
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.
One-time payment, no subscription · 14-day withdrawal right under consumer protection law · Invoice on request
$ 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 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
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
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.
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.
/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.
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
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
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.
5 portfolio projects
5 custom commands per project type (web app, CLI, API, library). Reusable across the team.
.claude/commands/*.md
Integrate Linear with Claude. List tickets, comment, update status, assign, search.
linear-mcp.py + npm package
10 hooks blocking common mistakes: rm -rf, hardcoded secrets, broken imports, unused vars.
.claude/settings.json + scripts/
Agent reviews PRs automatically. Checks style, naming, complexity, test coverage, security.
agent.ts + GitHub Action
Full SaaS from zero to live with Claude Code: backend, frontend, deploy, monitoring, billing.
Working project + post-mortem
Stack
Terminal interface, agentic loop, file editing, bash execution
Building custom agents programmatically
Messages, Files, Batch, Vision, Citations
Extending Claude with your own tools
Workflow automation via settings.json
Reusable command packs and namespaced skills
VS Code, JetBrains, Cursor parallel
50% off on repeating system prompts
New in 2026
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.
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 →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 →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.
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
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.
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.
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.
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.
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...
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.
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.
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%.
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.
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
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
Ready-to-use prompts for refactoring, bug investigation, security review, performance, accessibility, documentation. Copy, paste, done.
settings.json snippets to copy: deny destructive, auto-format, pre-commit lint, custom slash command validation, session start init.
3 working MCP servers to download: GitHub bridge, Linear bridge, Notion bridge. Fork and adapt to your stack.
5 production-ready commands: /review, /test-this, /refactor, /security-review, /docs. With prompts, hooks, and example outputs.
One-page quick reference: all key commands, flags, environment variables, file paths. Print it and pin it up.
A dedicated channel for developers. Updates, new Claude features, code reviews, Q&A with fellow students.
Pricing
one-time payment · lifetime access · no subscription
Stripe · Card · Apple Pay · Google Pay
FAQ
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.
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.
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.
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.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Comparison
CLI agent vs AI-first IDE — when each wins
Comparison
Agentic loop vs autocomplete — the real difference
Comparison
Two CLI agents compared head to head
Comparison
Terminal agent vs browser-based dev environment
Comparison
Anthropic vs Google — two agentic CLI tools
All courses
Compare every course and pick the right one for you
Ready?
One-time payment · lifetime access · delivered in 1–2 minutes