Qlaudia

← All courses

Claude Code

  • Artificial Intelligence
  • Technology & Computing

Claude Code is an agentic AI assistant that executes multi-step engineering tasks autonomously in your terminal—reading and writing files, running commands, searching codebases, and iterating on output based on natural language instructions. It shifts the paradigm from question-answering to task completion, letting you describe desired outcomes while the model figures out and executes the necessary steps.

Sign in to enroll$1033 lessons

What you'll learn

  • Agentic Task ExecutionA multi-step looping process where Claude Code receives a high-level goal, breaks it into tool calls, observes the results, and adjusts iteratively until the task is complete.
  • Interactive REPL ModeA persistent conversational terminal session where developers and Claude Code take turns exchanging messages and executing tasks in real time.
  • Context Window ManagementThe system for tracking how much of Claude Code's maximum working memory is consumed by conversation history, file contents, tool outputs, and system configuration during a session.
  • Permission and Approval ModelA safeguard that requires explicit human approval before Claude Code performs state-modifying actions like writing files, executing commands, or making network requests.
  • Security Best PracticesProtecting systems and credentials requires keeping secrets out of prompts and instead referencing them through environment variables or secret managers.
  • CI/CD Pipeline IntegrationA non-interactive, programmatic way to invoke Claude Code as part of automated workflows to perform tasks like code review, test generation, and security scanning on every commit or pull request.
  • Bash Command ExecutionThe ability for Claude Code to run shell commands directly on your machine, including package managers, test runners, build tools, and arbitrary scripts, to interact with your project's toolchain.
  • Settings and Configuration FilesClaude Code stores configuration in plain JSON files organized into user and project scopes that control allowed shell commands, loaded servers, and environment variables.
  • Non-Interactive (Headless) ModeA mode of operation where Claude Code runs with a single prompt from start to finish without waiting for user interaction, designed for integration into scripts and CI/CD pipelines.
  • CLI InvocationThe terminal command interface for Claude Code, invoked with the claude command in either interactive REPL mode or single-prompt non-interactive mode.
  • CLAUDE.md Project MemoryA version-controlled markdown file at the repository root that stores persistent project-specific instructions, conventions, and contextual knowledge for Claude Code sessions across all team members.
  • User-Level Memory (~/.claude)A personal configuration file at ~/.claude/CLAUDE.md that automatically loads your developer preferences, communication style, and habits across all projects and sessions.
  • Output and Artifact ReviewThe practice of examining Claude Code's generated files, modifications, and proposed commands before accepting them to catch misunderstandings, bugs, or unintended side effects.
  • Multi-Agent OrchestrationA pattern where one Claude instance acts as an orchestrator to decompose large or complex tasks into subtasks, delegate them to specialized sub-agents running concurrently or sequentially, and integrate their results.
  • Prompt Engineering for Claude CodeWell-structured prompts that explicitly define outcomes and constraints lead to correct, properly scoped code on the first attempt.
  • Trust and Allow-ListsPre-approved permissions for specific tools, commands, or directories that let Claude Code operate autonomously without interrupting you for approval on every action.
  • MCP Server IntegrationA connection standard that enables Claude Code to access external servers exposing tools, resources, and prompts without building those capabilities directly into Claude.
  • Cost and Token Usage MonitoringThe measurement and tracking of API token consumption across input and output during Claude Code sessions to control expenses.
  • Git IntegrationClaude Code's awareness of version control, allowing it to read commit history, inspect diffs, create branches, stage changes, and make work reviewable through git operations.
  • API Key ConfigurationA secret string issued by Anthropic that identifies your account and authorizes Claude Code to make requests, which is set via environment variable and managed independently per project or environment.
  • Environment Variable PassthroughA mechanism that explicitly forwards selected environment variables from your shell into Claude Code's execution environment by declaring them in the settings file under the `env` key.
  • File Reading and EditingThe capability for Claude Code to read file contents and modify them through targeted edits of specific sections or full rewrites of entire files.
  • Third-Party Model ProvidersThe ability to route Claude Code requests through AWS Bedrock or Google Vertex AI instead of Anthropic's API to meet data residency, billing, access control, or networking requirements.
  • Codebase ExplorationThe process by which Claude Code analyzes project structure, directory layouts, naming conventions, and existing code to understand context before making changes.
  • Running TestsClaude Code can execute test suites, interpret failure output, identify root causes, and iteratively fix failing tests without manual intervention.
  • Custom Slash CommandsMarkdown files stored in `.claude/commands/` that define reusable `/command-name` shortcuts, each containing a predefined prompt that Claude receives when the command is invoked.
  • Installation and SetupThe process of installing the Claude Code npm package and authenticating it with an Anthropic account to enable the command-line tool.
  • Model SelectionA choice among different Anthropic Claude models that trade off response speed, cost per token, and reasoning capability to suit the demands of specific tasks.
  • File CreationThe ability for Claude Code to write new files and directory structures to disk at appropriate locations based on your project's conventions.
  • Task Interruption and Course CorrectionA safety mechanism that allows you to halt an agentic task mid-execution, provide corrective feedback, and redirect Claude Code without restarting from scratch.
  • MCP Server ConfigurationJSON-based settings that declare how Claude Code connects to Model Context Protocol servers and what environment each server requires.
  • GitHub CLI IntegrationA feature that allows Claude Code to interact with GitHub repositories through the GitHub CLI tool to create pull requests, comment on issues, and inspect CI status.
  • Slash CommandsBuilt-in shortcuts prefixed with slash characters trigger deterministic actions like clearing conversation context or displaying memory files without invoking the language model.

About this course

Claude Code Overview

Claude Code is an agentic AI coding assistant that runs directly in your terminal, built by Anthropic on top of the Claude family of large language models. Unlike chat-based AI tools that simply answer questions, Claude Code can autonomously execute multi-step engineering tasks: it reads and writes files, runs shell commands, searches codebases, calls external tools, and iterates on its own output — all in response to natural language instructions you give it.

This document maps the territory of Claude Code as a whole, giving you a mental model of what it is, what it can do, and how its parts fit together before you dive into individual features.


What Problem Does Claude Code Solve?

Engineering work involves long chains of small, tedious decisions: finding the right file, understanding an unfamiliar codebase, writing boilerplate, running tests, interpreting errors, and making corrections. Traditionally, a developer manages every link in that chain manually. Claude Code acts as a capable delegate — you describe the outcome you want in plain English, and Claude Code figures out and executes the steps needed to get there.

The key shift is from question-answering to task completion. You are not asking Claude Code "how do I refactor this function?" — you are telling it "refactor this function to use async/await and make sure the tests still pass," and it does it.


Core Architecture: Agentic Tool Use

Claude Code is built around a tool-use loop. At each step, the model decides which tool (if any) to invoke, executes it, observes the result, and then decides on the next action. This continues until the task is complete or the model determines it needs your input.

Your Prompt (natural lang.) Claude Model (reasoning) Tools read/write/run… Observation (tool output) Result / Ask you ← repeats until done →

The agentic tool-use loop: Claude reasons about your prompt, calls tools, observes results, and loops until the task is complete or it needs clarification.


Key Capabilities

Codebase understanding — Claude Code can index and search large repositories, read relevant files, and build a contextual understanding of unfamiliar code before making changes. You do not need to manually paste code into a chat window.

File editing — It writes, creates, and deletes files directly on disk. Changes are made in your actual working directory, so they are immediately usable.

Command execution — Claude Code can run shell commands: compiling code, running test suites, executing linters, calling CLIs, and inspecting output. It interprets the results and adjusts its approach accordingly.

Multi-step task planning — For complex requests, it decomposes the work into steps, executes them in sequence, and handles errors mid-task without requiring you to intervene at every step.

Natural language interaction — You communicate in plain English (or other natural languages). No special syntax, flags, or prompt templates are required.


Two Primary Modes of Operation

Claude Code supports two main usage patterns:

  1. Interactive (REPL) mode — You launch a persistent session and converse with Claude Code turn-by-turn, refining tasks and reviewing outputs in a back-and-forth dialogue. This is the most common mode for day-to-day development work.
  1. Non-interactive (headless) mode — You pass a single prompt on the command line and Claude Code runs to completion without any human interaction. This is designed for automation, scripts, and CI/CD pipelines.

Both modes share the same underlying model and tool-use capabilities; the difference is only in how input is delivered and whether human feedback is expected during execution.


Where Claude Code Lives in Your Workflow

Claude Code is a terminal application installed globally via npm. It integrates naturally into a developer's existing environment:

  • It runs in the directory you point it at, respecting your project's file structure.
  • It is aware of your shell environment, so it can use tools (like git, npm, pytest, cargo) that are already installed.
  • It does not require a separate IDE plugin or browser extension — the terminal is the interface.

Because it operates on real files and runs real commands, Claude Code produces actual changes, not just suggestions. This makes it more powerful than a chat assistant but also means you should review its outputs, especially for large or high-stakes changes.


Practical Scope: What Claude Code Is Good At

  • Implementing a feature described in a ticket or comment
  • Refactoring a module to meet new requirements
  • Writing and running tests for existing code
  • Debugging a failing test or build error
  • Setting up boilerplate for a new project or service
  • Explaining an unfamiliar codebase section-by-section
  • Automating repetitive code transformation tasks across many files

Claude Code is less suited for tasks that require live interaction with a running UI, tasks that need real-time data outside its tools, or tasks where the requirements are so ambiguous that no autonomous action is safe.


Getting Started

The entry points from here are:

  • Installation and Setup — installing the npm package and authenticating with your Anthropic account
  • CLI Invocation — the exact commands to start sessions or run one-off prompts
  • Interactive REPL Mode — how the turn-by-turn session works
  • Non-Interactive Mode — running Claude Code from scripts and pipelines

Each of these topics has its own dedicated document.

Claude Code — Qlaudia