Skip to content

Claude Code — Full Course (Setup, Autonomous Goals, MCP & VS Code)

Overview

This article distills the 60-minute "Claude Code Full Course – Autonomous Goals, MCP, and VS Code Integration" by Eric (a former senior software engineer at Amazon and Microsoft, and founder of the startup bookisero.ai, which he built end-to-end with Claude Code). The course is designed for absolute beginners with no developer experience — the only prerequisites are a working laptop and a Claude subscription.

The curriculum covers, in order:

  1. Installing Claude Code on a local machine
  2. VS Code environment basics (files, folders, themes)
  3. Core usage: permission modes, sessions, slash commands
  4. Files Claude Code generates in a project
  5. CLAUDE.md vs AGENTS.md (memory / system prompts)
  6. Skills — packaged workflows that teach Claude Code how to do things
  7. Autonomous task execution with /goal
  8. Version control with Git and GitHub (branches, commits, reverts)
  9. The Model Context Protocol (MCP) and when to prefer CLI tools
  10. FAQ: frameworks vs models, CLI vs desktop vs VS Code, and whether Git is needed

[!NOTE] Source: YouTube — "Claude Code Full Course – Autonomous Goals, MCP, and VS Code Integration" — https://www.youtube.com/watch?v=7l6bXLAKyEI (60 min). Transcript is auto-captioned; tool names have been normalized (e.g. "Claw Code" → Claude Code).

Related: for an under-the-hood look at the agent harness, see Claude Code — How It Actually Works (Agent Harness Deep Dive).

Prerequisites

  • A working laptop — no technical or developer background required.
  • A Claude subscription — required to follow along (the video's own prerequisite).
  • VS Code — the course uses the VS Code integration as its primary interface (VS Code desktop app + Claude Code extension/session).

Setup & Environment

1. Installing Claude Code

The course starts by installing Claude Code onto the local machine, then launching it inside VS Code. The standard install is the npm CLI package:

npm install -g @anthropic-ai/claude-code

After install, authenticate with your Claude account, then open a Claude Code session inside VS Code (via the integrated terminal or the Claude Code extension).

[!NOTE] The video's install section is demo-based; if your install path differs (e.g. native installer or Homebrew), follow the official setup for your platform — the rest of the course is identical regardless.

2. VS Code Basics

Before the Claude Code session starts, the course covers the minimal VS Code file operations you need:

  • Create files/folders inside the workspace — they are mirrored on your real machine.
  • Save with Cmd+S (Ctrl+S on Windows/Linux); content persists when the file is reopened.
  • Delete a file via Cmd+Delete or right-click → Delete.
  • Change themes: gear icon → Themes → Color Themes (the instructor's preference is Solarized Light).

The key point: whatever you modify in the VS Code file tree is reflected on your actual machine, and vice versa.

3. Starting a Claude Code Session

Open a Claude Code session inside VS Code and start prompting. Session state lives in the conversation context — see the slash commands below for resetting it (/clear) or summarizing it (/compact).

Core Concepts

Permission Modes (Cycle with Shift+Tab)

Claude Code has three interactive modes that you cycle through with Shift+Tab. They control how much the agent may do without asking you:

Mode Behavior Best for
Plan mode Plans before executing. No edits to files, no scripts run — it reads the project and proposes a plan that you approve first. Complex refactors, code reviews, designing a new application from scratch
Accept edits Can create/edit files, but requires your permission to run commands (e.g. npm install, build scripts). Day-to-day development where you want oversight on executions
Auto mode Automatically accepts edits and proceeds with minimal prompting. Fast, well-understood tasks where you trust the agent

There is also a fourth permission level, entered from the terminal:

claude --dangerously-skip-permissions

Bypass permissions skips permission prompts entirely — powerful for batch/CI use, but it disables the human-in-the-loop guardrail, so only use it when you know what the agent will touch.

[!WARNING] Start in plan mode for anything destructive or architectural. Auto mode and --dangerously-skip-permissions trade safety for speed — they are not defaults for a reason.

Memory Files: CLAUDE.md vs AGENTS.md

These markdown files act as persistent system prompts / project memory loaded into every Claude Code session:

File Scope Use for
CLAUDE.md Claude Code only Rules specific to Claude Code (coding style, conventions, workflows)
AGENTS.md Universal — every AI agent framework Rules you want any agent (Claude Code, Codex, Gemini CLI, etc.) to follow

The distinction is practical: put Claude-Code-specific rules in CLAUDE.md, and put cross-tool rules in AGENTS.md so they carry over to whatever agent you use in the future.

[!TIP] The video's demo: adding the line "respond in emojis going forward" to AGENTS.md immediately changed every agent response. Remove the line and the behavior stops — the file is read on every prompt, so edits take effect on the next message.

Slash Commands

Slash commands are built-in shortcuts or user-defined triggers starting with /:

Command What it does
/clear Wipe the conversation context and start a fresh session
/compact Summarize older conversation to free context window space
/model Switch the underlying model (Opus / Sonnet / Haiku) mid-session
/skills List and manage installed skills
/mcp Manage Model Context Protocol connections
/reload plugins Apply newly installed skills/plugins to the current session

Skills: Workflows as Reusable Instructions

A skill is a workflow, guide, or SOP — a markdown/plugin package that instructs Claude Code (or any LLM) on exactly how to perform a task. Think of it as teaching the agent a procedure once, then triggering it on demand.

Example from the course — the "fix ticket" skill: a 9-step pipeline that automates the entire bug-fix flow:

  1. Read the ticket (Jira / Linear / GitHub)
  2. QA via Playwright browser automation — open the app and reproduce the issue
  3. Spin up multiple research agents on the root cause
  4. …through to fix, test, and close-out

Installing a skill (e.g. a "front-end design" skill):

# inside the Claude Code session
/skills            # browse installable skills
/reload plugins    # apply after install
  • You can install for the current project only or for all collaborators (installed at the repository level so everyone who clones the repo gets it).
  • Triggering: either in natural language ("re-renovate this app using the front-end design skill") or explicitly with the skill's slash trigger (/front-end design).

[!TIP] Skills are the closest thing to "SOPs for your AI" — package your team's bug pipeline, code review checklist, or deployment runbook into a skill and the agent follows it consistently.

Autonomous Tasks with /goal

The /goal (slash goal) command is the course's flagship feature: give Claude Code a high-level goal in natural language, and it plans, asks clarifying questions, and executes the whole build autonomously.

Demo from the course — building a tier-list web app from scratch:

  1. User states the goal (build the app; reference an existing design).
  2. Claude Code reverse-engineers the reference app and asks targeted questions:
  3. Tech stack: NestJS + React / vanilla clone / NestJS + SortableJS (file structure preview shown for each option)
  4. Email gate: keep the client-only version or include the email-subscription backend
  5. Content: which data the tier list should use
  6. Fidelity: how closely to match the reference
  7. After answers, Claude Code scaffolds the project, builds the application, and creates an eval/ folder to verify the result against the requirements.

[!NOTE] The eval/ folder is a temporary artifact created by /goal runs to validate the app meets spec — it can be deleted once the job is complete (and is a normal candidate for Git removal; see Version Control below).

Files Claude Code Generates

When Claude Code scaffolds a project, expect this structure (typical for the course's stack):

Path Purpose
.gitignore Files excluded from version control (e.g. node_modules)
node_modules/ Installed dependency libraries — don't touch
lib/ Reusable code the app needs (shared functions, config helpers)
components/ Small UI components you see rendered in the app
eval/ Temporary evaluation output from /goal runs (deletable)
CLAUDE.md / AGENTS.md System prompts / memory (see above)
package.json, .env, dot-files Standard project config — .env holds secrets, handle carefully

Version Control with Git & GitHub

Version control is covered through the VS Code Source Control panel, which Claude Code works with directly:

  • Diffs: green sections = added lines, red sections = deleted lines; a rich diff view renders markdown changes nicely.
  • Branches: create feature branches (e.g. beta or v2) from main and commit on top of them.
  • Commits & history: every change is recorded — the full historical record lets many users edit simultaneously without overwriting each other.
  • Collaborators: add more contributors per-repository via Settings → Collaborators.

Reverting with Claude Code — the workflow the course highlights:

  1. In the Source Control panel, find the commit you want to go back to.
  2. Copy the commit ID and paste it into the Claude Code session:

    "I want to revert back to this change."

  3. Claude Code performs the revert to that exact commit.
# equivalent manual flow, if you prefer raw git
git log --oneline            # find the commit ID
git revert <commit-id>       # or: git checkout <commit-id> -- .

[!TIP] You don't need to memorize Git commands — Claude Code can drive the whole flow from a commit ID you paste. But keep the repo on GitHub so reverts and history survive across machines.

MCP vs CLI Tools

The course compares the two ways of connecting Claude Code to external capabilities:

Dimension CLI tools MCP (Model Context Protocol)
What it is Agent executes shell commands in your terminal Standardized, secure bridge between the AI and remote tools/data
Token cost Low — highly token-efficient Higher — tool schemas are constantly loaded into the context window
Security Depends on what the shell can reach Strong — you control exactly which tools the agent can access
Governance Limited Auth boundaries + audit trails per request (it's a server)
Team fit Single user / fast iterations Best for teams — manage access and track usage per member

When to use which:

  • Speed / token efficiency → CLI tools. Ideal for quick, local, single-user work.
  • Security / team / multi-tenant → MCP. Ideal when you must control tool access, set authentication boundaries, and keep audit trails (e.g. a team of builders sharing one agent setup).

FAQ Highlights (from the course)

Are Claude Code, Codex, and Gemini CLIs frameworks or models? Frameworks. The model is the engine that powers the framework — and frameworks can be pointed at different models (including via OpenRouter or local models, a common "run Claude Code for free" trick).

Which framework is best? The instructor's take: Claude Code, because it ships more features than competitors — dynamic workflows, full orchestration, and a much larger plugin ecosystem.

CLI, desktop app, or VS Code? A dedicated chapter covers the trade-offs; the course itself demonstrates the VS Code integration end-to-end.

Do I need Git or GitHub? Yes, if the project will be maintained: version control enables rollback to any past state, which Claude Code can do from a commit ID.

Key Takeaways

  1. No dev experience needed — install the CLI, open a session in VS Code, and start prompting.
  2. Pick the right permission mode — Plan (think first), Accept edits (oversight), Auto (speed); escalate to bypass permissions only deliberately.
  3. CLAUDE.md / AGENTS.md are your project memory — Claude-specific vs universal agent rules.
  4. Skills encode your workflows — install, /reload plugins, then trigger by name or natural language.
  5. /goal turns goals into apps — Claude Code asks clarifying questions (stack, scope, fidelity), builds, and verifies via an eval/ folder.
  6. Git via Claude Code is trivial — paste a commit ID to revert; use GitHub for history and collaboration.
  7. CLI for token efficiency, MCP for security and teams — choose per use case.