Novice to Agentic AI Developer

TL;DR

At 12 hours a week, plan on about 26 weeks (roughly six months) to go from zero to competent: shipping a paid SaaS product and running a supervised multi-agent business system. Full-time at 7 hours a day, the same plan takes about 9 weeks. The quickest route is not "learn to code first, then AI". Build something real with an AI coding agent in week 2, then go back and learn just enough terminal, Git, Python/TypeScript, web stack and security to understand, check and fix what the agent produced. Karpathy now says the field has moved past "vibe coding" to "agentic engineering", and that gap between producing code and supervising it is the skill this curriculum teaches.

• Path: about 324 hours over 9 phases, ordered by how soon each one gets you shipping. First deployed app in week 2, a paid SaaS around week 16, a supervised multi-agent "business ops" system by week 26. Full-time: about 9 weeks. The best free 2025–2026 resources are the freeCodeCamp Claude Code courses (2026), Anthropic's free Claude Academy (relaunched 20 August 2026), DeepLearning.AI's Anthropic short courses, Andrew Ng's Agentic AI, Karpathy's talks, GitHub's own GitHub for Beginners series (season 3, 2026) and the Hugging Face MCP course.
• Tools: use Claude Code as your main agent (Claude Pro, $20/month, about £16–£20). Keep a second agent (Codex CLI, which has free and cheap tiers, or Google's Antigravity CLI, which replaced Gemini CLI for individual users in June 2026) to cross-check its work and avoid lock-in. Use Lovable/Bolt/v0 only for throwaway prototypes. The two best-documented ways vibe-coded products fail are security (Supabase tables with Row-Level Security switched off) and agents with unchecked access to production.
• GitHub is the backbone, not a side topic. It is taught in depth in Phase 1 (Module 1.4) and then used in every later phase as the task queue, review gate and audit trail for your agents.
• Reality check on "a company that builds companies": in late 2026, agents can reliably automate well-specified workflows (research, drafting, coding, triage, reporting) when a human approves the results. A fully autonomous business is still a demo, not a dependable way to operate. Design for "human as CEO and approver, agents as staff", and give agents more autonomy only once evals and logs show they can handle it.

How to use this curriculum

• Skip rule: every module ends with a "ready to move on when…" checkpoint. If you can already pass it, skip the module. With a light coding background you will probably skim Phase 1 and parts of Phase 2, but do not skip Module 1.4 (GitHub in depth).
• Verification marks: ✔ means the page was confirmed to exist during research and its key details were checked. ◐ means an official docs URL or well-known resource that was not opened individually, so check it loads first. If a duration or date could not be confirmed, the table says so. YouTube creators often retitle or re-upload videos; if a link breaks, search for the exact title on the named channel.
• Pricing: USD prices are converted at roughly £0.80 per $1, before UK VAT. Your checkout price in GBP may be higher once 20% VAT is added.
• Core habit: build alongside every resource. Pause the video, make the agent do the step, then ask it to explain what it did. Watching without building is the most common reason self-taught learners stall.
• One rule for the whole course: never ship code you cannot get the agent to explain to you.

Phase 0 – Orientation (Week 1, ~6 hours)

Objectives: understand what vibe coding and agentic engineering mean, where the field is in late 2026, and how to learn with an AI pair. Prerequisites: none.

Key context

• Origin: Andrej Karpathy coined "vibe coding" in a post on X on 2 February 2025, meaning it for throwaway weekend projects. Collins English Dictionary made it Word of the Year for 2025 (CNN, 6 November 2025).
• The 2026 shift: at Sequoia's AI Ascent (released 29 April 2026), Karpathy separated the two ideas. Vibe coding raises the floor; agentic engineering is about preserving the quality bar of professional software. His written summary calls the agent fallible and stochastic and says the agentic engineer does not blindly accept generated code. Secondary sources report he joined Anthropic's pre-training team in May 2026, worth bearing in mind when he talks about Claude.
• Model landscape in late 2026 (from release trackers, so check vendor pages): Anthropic shipped Claude Fable 5.1 and Claude Mythos 5.1 (restricted) on 1 September, Claude Opus 5.5 on 22 September, per one tracker Claude Sonnet 5.5 on 28 September, and Claude Haiku 5.5 on 7 October. OpenAI shipped GPT-6 Astra on 3 September, GPT-6 Sol and Luna on 22 September and GPT-6.1 Sol on 29 September. Google shipped Gemini 3.8 Flash on 2 September and made Gemini 4 Argon generally available on 13 October. Open-weight options include DeepSeek V4.1, Qwen 3.8 and Mistral Large 4.
• What this means for you: frontier models change every few weeks. Learn concepts and workflows rather than model names, and read the migration guide before switching code to a new model: moving Haiku 4.5 code to Haiku 5.5, for example, breaks requests that set temperature or use assistant prefill.

Resources

Exercise: write a one-page "learning contract": three products you want to build, your weekly hours, and one rule: I never ship code I cannot get the agent to explain to me.

Ready to move on when… you can explain to a non-technical co-founder how vibe coding (prototype, accept all changes) differs from agentic engineering (write a spec, review diffs, run tests and evals).

Pitfalls: binge-watching hype videos, hopping between tools, and believing "no-code" means "no understanding needed".

Phase 1 – Computer Foundations (Weeks 1–3, ~24 hours; Module 1.4 Part B lands in Week 11)

Objectives: use the terminal on macOS or Windows/WSL; understand file systems and environment variables; install software with Homebrew or winget; work in VS Code; use Git and GitHub properly, including SSH keys, conflicts, rebase, pull request review, Issues/Projects and the GitHub CLI; understand HTTP, DNS, client/server and hosting. Prerequisites: Phase 0.

Module 1.1 – Terminal, file system, environment variables, package managers (~6 h)

Exercise: in the terminal, create ~/code/sandbox, make some files, set an environment variable, print it and add it to your shell profile. Then remove it again, and learn why secrets shouldn't live in profiles that get synced.

Module 1.2 – VS Code, Git and GitHub from zero, SSH keys (~6 h)

Module 1.3 – How the web works (~4 h)

Module 1.4 – GitHub in Depth (~8 h: Part A in Week 3, Part B in Week 11)

Objectives: resolve merge conflicts calmly, know when to merge vs rebase, tidy history with interactive rebase and recover anything with reflog; review a pull request properly, including PRs an agent wrote (read the diff, run it, comment inline, request changes, approve, squash-merge); run a project with Issues, Projects boards, labels and Closes #n automation, which becomes the task queue your agents work from; use the GitHub CLI (gh), which Claude Code itself depends on; protect main with rulesets, required checks, secret scanning and push protection; connect Claude Code to GitHub with /install-github-app, @claude in issues and PRs, automatic code review, and worktrees for running agents in parallel.

Part A – Git depth (Week 3, ~3.5 h)

Part B – GitHub as your agents' operating system (Week 11, ~4.5 h)

How the Claude–GitHub pieces fit: /install-github-app from Claude Code installs the GitHub App, stores a secret and opens a pull request with the workflow files; you need the GitHub CLI installed and authenticated first. Mentioning @claude in an issue or PR comment has Claude analyse code, implement changes and push commits; a prompt input runs it automatically on any GitHub event, including a cron schedule. Boris Cherny, who created Claude Code, listed spinning up three to five worktrees each running its own session as his top tip in February 2026.

Module 1.4 half-day exercise:

1. Conflicts and recovery. In your sandbox repo, create two branches that edit the same line. Merge one; rebase the other onto main and resolve the conflict in VS Code's merge editor. Squash the branch to a single commit with git rebase -i. Then "break" main with git reset --hard HEAD~3 and recover it from git reflog.
2. Issues as an agent queue. Create three issues, a Kanban project and labels. Have Claude Code pick up issue #1 on a branch and open a PR whose description says Closes #1. Review it yourself: leave an inline comment, request a change, approve, squash-merge, and watch the issue close.
3. Lock the door. Add a ruleset requiring a PR, one approval and a passing check before merging to main. Turn on secret scanning and push protection, then try to push a fake API key and watch it get blocked.
4. Wire in Claude. Run /install-github-app, comment @claude on an issue, and read the review Claude leaves on your next PR. Notice what it catches and what it misses.

Phase 1 project: create a repo, clone it over SSH, write a README in VS Code, then commit, push, open a PR and merge it.

Ready to move on when… you can do that without notes; explain what happens between typing a URL and seeing the page (DNS → server → HTTP response); set and read an environment variable; resolve a conflict without panic; explain merge vs rebase in one sentence each; recover a "lost" commit from reflog; review and squash-merge an agent's PR with at least one requested change; and main cannot be pushed to directly.

Pitfalls: fighting Windows instead of using WSL; committing .env files (add .gitignore first); running commands you don't understand (ask Claude to "explain each flag" first); rebasing a branch someone else has pulled; treating green CI as approval (tests check what's there, not what's missing); --force instead of --force-with-lease; and installing GitHub Apps without reading the permission list. The Claude GitHub App asks for a single permission set covering all Claude features, including read-and-write on Actions, Contents, Issues, Pull requests and Workflows, and GitHub won't let you accept a subset. For tighter scope you can build a custom app with only Contents, Issues and Pull requests, though that covers only the Action, not Code Review.

Phase 2 – Programming Foundations, Fast (Weeks 4–7, ~45 hours)

Objectives: read and debug Python and TypeScript; use virtual environments and uv/pip; call APIs and handle JSON; understand async basics; use Node.js and npm/pnpm; know just enough HTML/CSS. The aim is to read code, not memorise it. Prerequisites: Phase 1.

Module 2.1 – Python from zero (~20 h)

Exercise: write a Python script that calls a public JSON API and writes the results to a CSV. Then make an asyncio version that fetches 5 cities at once.

Module 2.2 – JavaScript/TypeScript, Node.js, npm/pnpm (~18 h)

Module 2.3 – Just-enough HTML/CSS and reading code (~7 h)

How to learn with AI here: ask "explain this line by line", "what breaks if I remove X?" and "write a failing test that shows the bug". Have it quiz you. Don't ask it to "just fix it" until you can say what's wrong.

Phase 2 project: a Python CLI and a small TypeScript script that both call the same API, each committed with a README.

Ready to move on when… you can take a 100-line file you didn't write, explain what it does, find where it reads the API key, and fix a planted bug with the AI's help while giving the explanation yourself.

Pitfalls: tutorial hell (cap this phase at about 45 hours), memorising syntax, and skipping virtual environments.

Phase 3 – How LLMs Work, Practically (Week 8, ~15 hours)

Objectives: understand tokens, context windows, embeddings, temperature, system prompts, tool calling, structured outputs, hallucination, cost, the model landscape, and prompt and context engineering. Prerequisites: Phase 2.

Cost intuition (from third-party trackers such as https://benchr.org/timeline, so verify): prices per million input/output tokens vary about 100×. GPT-6 Luna is about $0.10 / $0.50; Claude Sonnet 5.5 about $2 / $10; Claude Opus 5.5 about $4 / $20; GPT-6 Astra about $10 / $50. Send easy steps to cheap models and save frontier models for planning and review. That is the biggest cost lever in agent systems.

Exercise: send the same prompt to two vendors and ask for schema-constrained JSON. Measure tokens and cost, then overfill a small context on purpose and watch the quality drop.

Ready to move on when… you can explain what tokens are, what temperature does, why with tool calling "the model asks; your code executes", and why bloated context makes agents worse.

Pitfalls: treating models as databases of truth, ignoring cost, and chasing leaderboards.

Phase 4 – AI-Assisted Coding Tools (Weeks 2 and 9–11, ~30 hours)

Speed hack: in week 2, alongside Phase 1, do Module 4.1's first video and deploy a tiny static site to Vercel. Early wins keep you going.

Objectives: become fluent in Claude Code (CLAUDE.md, slash commands, hooks, subagents, skills, plugins, MCP, headless/CI, the Agent SDK) and know the alternatives. Prerequisites: Phase 1.

Module 4.1 – Claude Code deep dive (~20 h)

Claude Code runs in the terminal, in IDE extensions, as a desktop app and on the web. The free Claude plan does not include it.

Concepts to master, in order:

1. CLAUDE.md: short project memory covering architecture, commands and conventions.
2. Plan mode: explore → plan → code → commit.
3. Permissions and sandboxing: never use blanket "skip permissions" on a machine that holds production credentials. Allow and deny rules for MCP tools name the whole server, as in mcp__supabase__*; since Claude Code 2.1.299 (October 2026) a shorter rule no longer covers other servers whose names start the same.
4. Slash commands and Skills: stored in .claude/skills/<name>/SKILL.md.
5. Hooks: deterministic scripts that run at PreToolUse, PostToolUse or Stop, e.g. auto-format, block rm -rf, run tests. A hook always runs; a prompt is only a suggestion.
6. Subagents: separate contexts for research, review and testing, which can run in parallel.
7. MCP servers: connections to GitHub, Supabase, Playwright, Notion and so on.
8. Plugins: shareable bundles of skills, hooks, agents and MCP config.
9. Headless/CI: claude -p in scripts and GitHub Actions. Pass --permission-mode explicitly: since Claude Code 2.1.302 (October 2026) a run on a fresh install starts in default mode and waits for an approval nobody is there to give.
10. Claude Agent SDK: the same harness, as a library. Renamed from "Claude Code SDK" on 29 September 2025, alongside Claude Code 2.0. The packages are now claude-agent-sdk and @anthropic-ai/claude-agent-sdk, so older tutorials import the wrong ones. Docs: https://code.claude.com/docs/en/agent-sdk/overview and the migration guide at https://platform.claude.com/docs/en/agent-sdk/migration-guide.
11. REVIEW.md: next to each code area's CLAUDE.md, a short file telling reviewers, human or agent, what to check in that area. It is the pattern the Claude Code team describes (resource above).

Exercise: in an existing repo, set up a CLAUDE.md, a /release-notes skill, a lint-after-edit hook, a security-reviewer subagent and the Playwright MCP server. Then run a headless claude -p task from a shell script.

Module 4.2 – The alternatives: honest comparison (~10 h)

Price comparison checked 28 Sep 2026: https://www.developersdigest.tech/blog/ai-coding-tools-pricing-2026.

Recommendation: pay for one $20 primary (Claude Pro), and use a cheap Codex tier (or Antigravity CLI, if its current quota suits you) as the cross-checker. Upgrade to Max 5x only if you hit limits more than twice a week.

Ready to move on when… you can start from a fresh repo and, with only Claude Code plus your own review, ship a feature on a branch with tests, a hook-enforced lint and a PR, and explain every file that changed.

Pitfalls: clicking "accept all" on database or infrastructure commands, letting CLAUDE.md grow to 2,000 lines, installing dozens of random MCP servers (each is a supply-chain and prompt-injection risk), and tool FOMO.

Phase 5 – Building Real Apps (Weeks 12–17, ~60 hours)

Objectives: build with Next.js/React and TypeScript; use Postgres via Supabase or Neon, plus auth; take payments with Stripe; deploy to Vercel, Railway, Fly.io or Cloudflare; learn Docker basics and manage secrets; add testing, CI/CD with GitHub Actions, and monitoring; apply vibe-coding security basics; finish with a SaaS that takes real money. Prerequisites: Phases 2 and 4.

Security for vibe-coded apps (non-negotiable, ~6 h)

1. No RLS. In the Lovable case (CVE-2025-48757), Matt Palmer's statement (29 May 2025) reports that his 21 March 2025 scan found 303 endpoints across 170 of 1,645 projects (about 10.3%) with inadequate RLS settings. Fix: turn on RLS for every table, write policies based on auth.uid(), and test while logged out.
2. Leaked keys. The service_role key or API keys end up in front-end code or Git. Fix: keep them in server-only env vars, put .env in .gitignore, turn on GitHub push protection (see Module 1.4), and rotate anything that has leaked.
3. Agents with production access. This is what happened with Replit and SaaStr. Fix: separate dev and prod databases, give agents a read-only prod role, keep backups, and add a hook that blocks destructive SQL.
4. Injection. SQL injection and prompt injection through user content. Fix: use parameterised queries or an ORM, and treat everything the model reads as untrusted.
5. Unverified webhooks. Fix: verify Stripe signatures and make handlers idempotent (safe to run twice).

Monitoring: Sentry, platform logs and PostHog all have free tiers.

Capstone 1 (paid micro-SaaS): a Next.js + Supabase + Stripe app that solves a problem from your sales world, such as an account-research brief generator. It needs auth and RLS, a Stripe subscription (test mode, then live), CI on every PR with a ruleset protecting main, Sentry and a custom domain, and it launches to 10 people.

Ready to move on when… a stranger can sign up, pay, use the app and cancel; logged-out queries to every table return nothing; CI blocks a failing test; and you can draw the architecture from memory.

Pitfalls: building your own auth or payments, skipping test mode, and launching without backups.

Phase 6 – Building AI Agents (Weeks 17–22, ~60 hours)

Objectives: use the Claude and OpenAI APIs, including tool use; understand the agent loop and Anthropic's "Building effective agents" patterns; build and use MCP servers; compare agent frameworks; add RAG, memory and structured outputs; set up evals, observability, guardrails and cost control; run background agents, and know when computer-use or browser agents fit. Prerequisites: Phases 3–5.

Module 6.1 – APIs, tool use, the agent loop (~12 h)

Exercise: write an agent loop by hand in about 80 lines of Python: messages → model → tool call → your code runs it → append the result → repeat. Add a max-steps limit and a cost counter. After this, every framework makes sense.

Module 6.2 – Model Context Protocol (~10 h)

Exercise: build a read-only MCP server for your Phase 5 app and connect it to Claude Code and one other client.

Module 6.3 – Frameworks compared (~12 h)

Recommendation: start with the plain API and your own hand-written loop. Then add the Claude Agent SDK (it matches your Claude Code skills) and the Vercel AI SDK (multi-provider, which hedges vendor risk). Add LangGraph only when you need durable, branching workflows with approvals.

Module 6.4 – RAG, memory, evals, observability, guardrails, cost, background and browser agents (~26 h)

Cost controls: a budget cap per run, a max-steps limit, a cheap model for routing, prompt caching, cost logged per task, and alerts at 50%, 80% and 100% of the monthly budget.

Capstone 2 (production agent): a prospect-research agent that takes a company name, uses web search and your MCP server, and writes a structured brief to Supabase. It needs 30 eval cases, Langfuse tracing, a cost cap, and human approval before any email is sent.

Ready to move on when… the agent passes at least 90% of your evals, every run is traced with its cost, and you can show a blocked prompt-injection attempt.

Pitfalls: going multi-agent before a single agent works, skipping evals, and giving agents write access to email or the CRM on day one.

Phase 7 – Automation and Multi-Agent Business Systems (Weeks 22–25, ~30 hours)

Objectives: n8n, Make and Zapier; orchestration; connecting to email, CRM, Slack and Notion; scheduled agents; human-in-the-loop design; an "AI-run business" stack and its limits. Prerequisites: Phase 6.

The "AI-run business" reference stack

On "a company that builds companies": a realistic 2026 design is a pipeline. Each stage is a well-specified workflow with evals, and each hands off to the next.

1. An idea-research agent finds candidate ideas.
2. A validation step scores each market.
3. A landing page and waitlist go up.
4. Agents draft outreach.
5. You make the go/no-go call.
6. Claude Code builds the MVP from a spec template.
7. A launch checklist runs.

Agents can take on much of the work at each stage, but not the judgement. The Replit and Lovable incidents show what happens when the human checkpoints are removed.

Capstone 3 (multi-agent ops system): three agents (triage, research, reporting) orchestrated by n8n or LangGraph, with a shared Supabase state table, approvals posted to Slack, schedules, Langfuse traces and a monthly budget cap.

Ready to move on when… the system runs unattended for 7 days, every external action has gone through an approval, and a runbook exists.

Pitfalls: automating a process you've never done by hand, letting agents talk to customers unsupervised, and ignoring GDPR when sending personal data to model vendors.

Phase 8 – Shipping, Product and Entrepreneurship (Weeks 25–26 and ongoing, ~50 hours with capstones)

Objectives: idea validation, MVP scoping, analytics, landing pages, marketing automation, pricing, UK/EU legal basics, building in public. Your sales background is a big advantage here.

UK/EU compliance essentials

The Digital Omnibus on AI (Regulation (EU) 2026/1744, published in the Official Journal on 24 July 2026) entered into force on 27 July 2026, according to the European Commission's notice "AI Omnibus enters into force". It changed the timetable:

What this means for you: if EU users can talk to your agent, disclose that it's AI now, and avoid hiring or credit-scoring use cases for the time being.

UK: there is no UK equivalent of the AI Act. UK GDPR and ICO guidance apply: a lawful basis for processing, a privacy notice, a data processing agreement with every AI vendor, and data minimisation before anything is sent to a model. This is orientation, not legal advice. Get a solicitor to review before you process customer personal data at scale.

Capstone 4 (real launch): 20 customer conversations to validate the idea, charging from day one, a landing page with a waitlist, a public launch, and either 10 paying customers or a written decision to kill it. Capstone 3 runs operations behind it.

Week-by-Week Schedules

Part-time (~12 h/week, 26 weeks, ~324 hours)

Weeks 3 and 11 carry the two halves of Module 1.4 (GitHub in depth). If week 3 overruns, push "how the web works" into week 4. If you already know the Phase 1–2 material, expect about 20 weeks.

Accelerated full-time (6–8 h/day, ~35 h/week, ~9 weeks)

Daily rhythm: 2 hours of video/docs, 4 hours of building, 1 hour writing up and committing. Don't compress below about 8 weeks. Below that, your understanding stops keeping up with the agent's output; in Karpathy's words, you can't outsource your understanding.

Day-One Toolkit and Monthly Costs (GBP, ex-VAT estimates)

Expect about £16/month during Phases 1–4 and £30–£80/month once you are shipping (Phases 5–8). Optional Max 5x adds about £64.

GitHub Actions minutes are free on public repositories and limited on private ones; Claude Code's GitHub Action consumes those minutes plus API tokens (or your subscription if you authenticate with an OAuth token).

Staying Current

• YouTube (handles not individually checked): Karpathy, freeCodeCamp, Anthropic, OpenAI, Google for Developers, DeepLearning.AI, Sequoia Capital, GitHub (the GitHub for Beginners series), Fireship, The Modern Coder, Matt Pocock, Theo (t3.gg), IndyDevDan, Cole Medin, AI Jason, Nate Herk, Greg Isenberg, Riley Brown, Matthew Berman (news; skim), Dave Ebbelaar, Ray Fernando, Tech With Tim, Net Ninja, Traversy Media, Programming with Mosh, NetworkChuck.
• Newsletters and podcasts: Simon Willison's blog, the Anthropic Engineering blog, the GitHub Blog (tag: github-for-beginners), Latent Space, Ben's Bites, The Rundown AI, The Startup Ideas Podcast, Sequoia's "Training Data".
• Communities: the Anthropic/Claude Discord, the Hugging Face Discord (#mcp-course-questions), the n8n forum, r/ClaudeAI, r/LocalLLaMA.
• Docs that outlast the videos: https://code.claude.com/docs, https://docs.github.com, https://modelcontextprotocol.io, https://supabase.com/docs, https://docs.stripe.com.

Glossary

• Agent / agent loop: an LLM that picks tools and repeats model → tool call → execution → observation until the goal is met.
• Agentic engineering: Karpathy's 2026 term for professionally supervising coding agents.
• CLAUDE.md: a project memory file loaded automatically.
• Context engineering: choosing what goes into the model's working memory (its context window).
• Embedding / vector DB: numbers that represent meaning, and the store used to search them (RAG).
• Evals: test suites for agent quality.
• Hallucination: output that is confident but false.
• Hook: a deterministic script that runs at a lifecycle event.
• Interactive rebase: rewriting a branch's commits (reorder, squash, edit) before sharing them.
• MCP: Model Context Protocol, an open standard for tools and data (Anthropic, Nov 2024).
• Plugin: a bundle of skills, hooks, subagents and MCP config.
• Prompt injection: malicious instructions hidden in content the model reads.
• Pull request (PR): a proposed change to a branch, with a diff, discussion, review and checks before merge.
• Reflog: Git's log of where HEAD has pointed; the way back from almost any mistake.
• RLS: Postgres Row-Level Security.
• Ruleset / branch protection: GitHub rules that stop direct pushes and require reviews and checks on main.
• Skill: a SKILL.md folder loaded on demand.
• Subagent: a delegated agent with its own isolated context.
• Token: a chunk of text, and the unit of billing.
• Vibe coding: building by prompting, without reading the code (Karpathy, Feb 2025).
• Worktree: a parallel Git checkout, used to run agents side by side.

Skip List (Not Worth a Novice's Time in 2026)

1. Training or fine-tuning your own models, including Karpathy's "Zero to Hero" series. Brilliant, but come back to it later.
2. LeetCode and CS-theory courses. You need to be able to read, test and design code.
3. Prompt-engineering courses from 2023 to early 2025 built on "magic phrases". Context engineering and evals have replaced them.
4. Old "Claude Code SDK" tutorials. The SDK was renamed in September 2025.
5. Learning several IDEs or agents in depth. One primary plus one checker is enough.
6. Git submodules, GitFlow and complex branching models. Trunk-based with short-lived branches and PRs is all a one-person team with agents needs.
7. Kubernetes, microservices, AWS certifications, or building your own auth, payments or vector DBs.
8. Multi-agent frameworks before a single agent passes its evals.
9. Installing every MCP server or plugin. Each one adds attack surface.
10. Paid "AI agency" courses and Skool upsells that promise autonomous income.
11. Chasing every model release. Re-evaluate once a quarter.

Caveats and Verification Notes

• Verification limits. Resources marked ◐ are standard official URLs not opened individually. Several YouTube creators (the n8n courses, "Claude Code Worktrees in 7 Minutes") could not be confirmed, and durations taken from aggregators are approximate. The URL and date for "Building effective agents" come from prior knowledge. GitHub Skills has moved to learn.github.com and its new catalogue page did not render during research, so start from the github.com/skills repositories if the new site is awkward. No standout GitHub CLI video was found; the manual plus the exercise is the recommendation.
• Model and pricing data come mostly from third-party trackers dated September–October 2026, and they partly conflict, especially on Google's current flagship. Confirm on vendor pages.
• Incident figures. The Lovable numbers come from Matt Palmer's own "Statement on CVE-2025-48757" (29 May 2025): 170 of 1,645 apps, about 10.3%. The Replit details come from Jason Lemkin's account as reported by Tom's Hardware (July 2025). Statistics that trace back to vendor marketing have been left out deliberately.
• This field moves fast. Expect much of the tool-specific video content to date within months. Fall back on the official docs and Claude Academy. The underlying concepts will outlast every tool named here: the agent loop, context, evals, least privilege, human checkpoints, and a protected main branch with reviewed pull requests.

Sources opened during research

• Karpathy: Sequoia Ascent 2026 summary
• Claude Code GitHub Actions docs
• Claude Agent SDK migration guide
• GitHub for Beginners: Issues and Projects (2 Mar 2026)
• GitHub for Beginners series index
• Introducing GitHub Skills
• freeCodeCamp: Advanced Git (Tobias Günther)
• freeCodeCamp: Claude Code Full Course
• freeCodeCamp: Claude Code Essentials
• DeepLearning.AI: Agentic AI
• DeepLearning.AI: MCP with Anthropic
• Hugging Face MCP Course
• AI coding tools pricing comparison 2026
• Claude Code git worktrees guide (devtoollab)
• Vibe App Scanner: Lovable security / CVE-2025-48757
• Replit production database deletion (kpath.ai incident note)
• EU AI Act Digital Omnibus deadlines (Usercentrics)
• AI model release timeline (benchr)