AgenticAI – anil.org.in

A complete training curriculum. Reflects Claude Code as of mid-2026. Claude Code ships changes weekly — when in doubt, ask it about itself (“can you do X?”) and it will fetch its own current docs.

Part 0 — The philosophy (why it’s built this way)

Claude Code is an agentic coding tool that lives where you already work (terminal, IDE, desktop, web, CI), not another chat window. Four design commitments explain almost every feature:

Meet developers in their environment. It edits files, runs commands, makes commits, and reads your real repo — instead of you copy-pasting snippets into a browser. Action over conversation.
Unix philosophy: composable and scriptable. Because it’s a CLI, it pipes. tail -f app.log | claude -p "alert me on anomalies" works. Your CI can run it headless. It’s a building block, not a walled garden.
Low-level and unopinionated by default. Anthropic deliberately ships a flexible, close-to-the-model harness rather than forcing one workflow. You compose the workflow you want from primitives (memory, permissions, skills, subagents, hooks).
Safety through visibility and control, not handcuffs. You see what it’s about to do, approve or deny it, and can rewind. Capability scales with the trust you grant.

The mental model that makes you good at it

Everything reduces to managing three levers:

Context — what Claude can see (your files, CLAUDE.md, tool outputs, conversation history). Context is finite and is the product. Garbage or bloat in ? worse output.
Permissions — what Claude is allowed to do (read, edit, run bash, hit the network).
Verification — how Claude checks its own work (tests, type-checks, linters, the app actually running).

Master those three and the rest is detail.

The agentic loop (what’s actually happening)

A “turn” is: Claude reads context ? decides on a tool call (read a file, run a command, edit code) ? gets the result ? reasons ? repeats ? stops when done. It is not predicting your code in one shot; it is working iteratively. This is why giving it something to verify against (a failing test, a typecheck) dramatically improves results — it can tell whether it’s succeeding and self-correct.

Part 1 — Beginner: get productive in an hour

Install & start

Prereqs: Node.js 18+, and a Claude (Pro/Max/Team/Enterprise) or Anthropic Console account.
Install, then in any project directory run claude. Log in when prompted.
Run /init once in a repo — Claude explores the codebase and drafts a starter CLAUDE.md.

The first-session habits

Just talk to it. “What does this service do?”, “Where is auth handled?”, “Add a --dry-run flag to the import script.” Plain English is the interface.
It’s a conversation, not a vending machine. Interrupt (Esc), correct, and steer mid-task. Course-correcting early beats letting it run 10 minutes the wrong way.
Be specific upfront. “Fix the bug” is weak. “Users with apostrophes in their name get a 500 on signup — reproduce it, then fix it” is strong.

Essential commands to memorize first

Command	What it does
`/init`	Generate/refresh project `CLAUDE.md`
`/clear`	Wipe the conversation context (use between unrelated tasks)
`/compact`	Summarize history to reclaim context without losing the thread
`/memory`	View/edit what Claude remembers
`/usage`	See your token/cost and rate-limit status
`Esc`	Interrupt Claude immediately
`Esc Esc` / rewind	Jump back to an earlier point (checkpoints)
`#` prefix	Quickly add a line to memory
`!` prefix	Run a raw shell command yourself
`@path`	Reference a specific file/dir in your prompt

The single most important beginner habit

Run one task per conversation, then /clear. Stale context from a previous task is the #1 cause of confused output. Fresh task ? fresh context.

Part 2 — Core workflows (the daily bread)

These are the canonical patterns Claude Code is optimized for:

Understand a new codebase. “Give me a high-level overview”, then drill down. Ask for the request lifecycle, where state lives, how tests run.
Fix bugs. Paste the error or describe the repro. Best results: ask it to reproduce first, then fix, then verify the repro is gone.
Refactor. Point at the smell, state the target (“extract this into a hook, no behavior change”), and give it the test suite as a guardrail.
Work with tests. “Write tests for this module, then make them pass.” Tests are also Claude’s verification signal — doubly valuable.
Create pull requests. It can stage, commit with a sensible message, and open the PR.
Handle docs, release notes, changelogs — tedious-but-structured work it excels at.
Work with images. Drag in a screenshot of a bug or a design mock; it can read them.

The golden three-step rhythm

Explore >> Plan >> Code.
Have Claude read and understand first (explore), then propose an approach (plan), then implement (code). Skipping straight to code on anything non-trivial is the most common cause of wrong-but-confident output.

Part 3 — Context & memory (the highest-leverage skill)

CLAUDE.md — your project’s standing instructions

A CLAUDE.md file is auto-loaded into context every session. Put durable, project-wide truths here:

How to build/test/typecheck/lint (exact commands).
Architecture in a sentence or two; domain vocabulary.
Conventions and anti-patterns (“DO NOT…”) — negative rules are surprisingly effective.
A pointer/index to key docs.

Keep it lean. Every line costs context on every turn. If it’s getting big:

Split with imports (@docs/architecture.md) so the main file stays a focused index.
Use .claude/rules/ for modular and path-specific rules (e.g. rules that only apply under packages/api/).
In large monorepos, layer CLAUDE.md per directory so Claude only loads what’s relevant to where it’s working.

CLAUDE.md exists at multiple scopes — user-level (you, across all projects), project-level (committed, shared with the team), and per-directory. Teams can deploy org-wide CLAUDE.md.

Auto memory

Separately from CLAUDE.md, Claude Code can automatically remember things it learns across sessions. You can audit and edit this (/memory), and enable/disable it. CLAUDE.md = the rules you write; auto memory = what it picked up.

Context hygiene (the muscle that separates pros)

/clear between unrelated tasks — non-negotiable.
/compact when a long, single task fills the window — keeps the thread, drops the bloat.
Watch the context window indicator; don’t let it silently fill. When it does, things degrade.
Block reads of generated/vendored code so Claude doesn’t waste context on dist/, lockfiles, etc.
Offload bulky investigation to subagents (below) so their noise never enters your main context.

Part 4 — Permissions & safety (control without friction)

Claude asks before doing risky things. You tune how much it asks via permission modes:

Mode	Behavior	Use when
Plan mode	Analyzes and proposes; makes no edits until you approve a plan	Anything non-trivial, unfamiliar code, big refactors
acceptEdits	Auto-approves file edits, still gates other actions	You trust the direction and want flow
dontAsk	Only pre-approved tools run; everything else is blocked (not prompted)	Tightly scoped autonomous runs
auto mode	A classifier judges safety and eliminates most prompts	Trusted infra, you’ve configured boundaries
bypassPermissions	Skips checks entirely	Sandboxes/throwaway environments only — be careful

Permission rules let you allow/deny specific tools and even specific bash commands or paths with wildcards — encode “never touch prod config” once.
Protected paths keep sensitive files off-limits.
Sandboxing (filesystem + network isolation, OS-enforced) lets you grant more autonomy safely — the right answer when you want speed without risk.

Checkpoints / rewind — your undo button

Claude Code automatically checkpoints your files as it works. If a change goes wrong, rewind to a prior state (or just summarize what changed). Caveat: it tracks file edits, not bash side-effects or external changes, and it is not a substitute for git. Commit often anyway.

Part 5 — Intermediate: the force-multipliers

Plan mode (use it constantly)

Forces explore-and-propose before any edit. Review the plan, refine it, then let it execute. You can set plan mode as your default. This one habit prevents most “it confidently did the wrong thing” moments.

Skills

Skills are reusable, model-invoked capabilities — a folder with a SKILL.md (instructions + optional scripts/files) that Claude pulls in only when relevant. They’re how you teach Claude a repeatable procedure (“how we cut a release”, “how to scaffold a new service”) without bloating CLAUDE.md. Key advantage: progressive disclosure — the skill’s detail loads on demand, keeping baseline context cheap. Skills can be project-, user-, or plugin-scoped, run in subagents, and pre-approve their own tools.

Subagents

A subagent is a separate Claude instance with its own context window, its own tool restrictions, and a focused job. Why they matter:

Context isolation — a noisy task (reading 40 files to find something) happens in the subagent; only the answer returns to your main thread.
Parallelization — fan out research or reviews concurrently.
Specialization — a “code-reviewer” or “debugger” agent with its own instructions.
Built-in ones exist; you create custom ones with /agents. You can also fork the current conversation to explore a tangent without derailing the main line.

MCP (Model Context Protocol)

MCP connects Claude Code to external systems — GitHub, Sentry, Postgres, Figma, Slack, Google Drive, your internal tooling. It can read your design docs, query your DB, file your tickets. Servers are added at local/project/user scope (.mcp.json for team-shared). For big tool sets, MCP Tool Search defers tool loading so dozens of servers don’t flood context. MCP is the difference between “Claude that knows your code” and “Claude that knows your whole stack.”

Hooks

Hooks run your own commands at lifecycle events — deterministic automation around the agent. The catalog is large (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, PreCompact, and many more). Classic uses:

Auto-format code after every edit.
Block edits to protected files.
Run tests automatically after changes.
Re-inject context after a compaction so Claude doesn’t “forget.”
Notify you (sound/Slack) when Claude needs input.
Hooks turn conventions into guarantees instead of hopes.

Plugins & marketplaces

Plugins bundle skills, agents, hooks, MCP servers, and settings into one installable unit, distributed via marketplaces (Anthropic’s official one, community ones, or your team’s private one). This is how you package and standardize a whole team’s Claude Code setup.

Part 6 — Advanced: scale, autonomy, and surfaces

Run it everywhere

CLI — the core.
VS Code / JetBrains extensions — inline, with checkpoints and diff review.
Desktop app — parallel sessions, diff view, preview servers, optional computer use.
Claude Code on the web — cloud sandboxes that work GitHub issues/PRs and can auto-fix PRs.
Slack, Chrome (browser automation: test local apps, scrape, fill forms), mobile / Remote Control (drive a session from your phone).

Parallelism done right

Git worktrees — run multiple Claude sessions on the same repo in isolated working trees, no branch-switching collisions. The canonical way to do several things at once.
Agent view — monitor and steer many background sessions from one place.
Agent teams — multiple coordinating agents (a “lead” delegating to teammates) for genuinely parallel work like competing-hypothesis investigations or parallel reviews. Powerful and token-expensive — size tasks and team appropriately.

Automation & headless

Headless / non-interactive: claude -p "…" for scripts, pipelines, and CI. Supports streaming, structured (JSON) output, auto-approved tools, and custom system prompts.
CI/CD: first-class GitHub Actions and GitLab CI/CD integrations — Claude responds to @claude, turns issues into PRs/MRs, reviews diffs.
Scheduling: /loop (run a prompt on an interval), /schedule, routines (schedule/API/GitHub-triggered runs on the web), and desktop scheduled tasks.
Goal-driven runs: /goal keeps a session working until a condition you define is met.

Models, effort, and reasoning

Pick models via aliases; opusplan uses a stronger model for planning and a faster one for execution. There’s also Fable 5 support.
Effort levels trade speed for depth; ultrathink triggers deep one-off reasoning for a hard problem.
Fast mode prioritizes latency; an advisor model can be consulted for second opinions.
Automatic model fallback keeps you working through capacity limits.

Review & quality at scale

/review and ultrareview for deeper automated review; Code Review on PRs with severity levels and inline comments.
The automatic security review plugin checks edits/commits for vulnerabilities as you go.
Add an adversarial review step — have a second agent try to poke holes in the first’s work. Underused, high-value.

The Agent SDK

When you want to build your own agentic apps on the same harness, the Agent SDK (TypeScript & Python) exposes the loop, tools, subagents, hooks, permissions, sessions, MCP, custom tools, and structured outputs. This is Claude Code’s engine, available as a library.

Part 7 — Patterns & power tips

Context

One task per conversation; /clear religiously.
/compact long single tasks instead of letting the window overflow.
Keep CLAUDE.md lean; push detail into skills and .claude/rules/.
Send rich context: paste errors, screenshots, logs, exact file refs (@).

Verification (the highest-ROI habit)

Always give Claude something to check against: a failing test, a typecheck, a linter, the running app. It self-corrects when it can measure success.
For risky work, add a hook that runs tests automatically after edits.

Control

Default to plan mode for anything non-trivial; approve the plan, then let it run.
Use sandboxing to grant more autonomy safely rather than babysitting prompts.
Encode hard rules as permission rules and hooks, not as hopes in prose.

Scale

Delegate, don’t dictate. Describe the goal and constraints; let Claude find the path. Over-specifying every step wastes its strength.
Offload investigation to subagents so your main context stays clean.
Use worktrees for parallelism; agent teams only when the task truly fans out (mind the cost).
Let Claude interview you — ask it to ask you clarifying questions before a big task.

Self-service

Ask Claude about itself (“does Claude Code have hooks? how do I write one?”) — it fetches its own live docs and answers current truth.

Part 8 — Anti-patterns (what makes people fail)

Letting context rot — one giant never-cleared conversation. The top cause of bad output.
Skipping explore/plan — jumping straight to code on unfamiliar or complex work.
No verification target — asking for code with nothing for Claude to check against.
A bloated CLAUDE.md — turning standing instructions into a 500-line dumping ground.
Treating checkpoints as version control — they’re an undo, not git. Commit often.
Over-dictating — micromanaging steps instead of stating the goal.
Granting blanket autonomy without a sandbox — speed at the cost of safety.
Ignoring cost — agent teams and verbose MCP servers burn tokens; watch /usage.

Part 9 — A suggested progression

Week 1 (Beginner): Install. /init. Do real tasks. Learn /clear, /compact, Esc, @, plan mode. Build the one-task-per-conversation habit.
Week 2 (Solid user): Write a real CLAUDE.md. Configure permissions. Connect one MCP server you actually use. Get verification loops going (tests/typecheck).
Week 3 (Intermediate): Create your first skill and first subagent. Add a hook (auto-format or auto-test). Try worktrees for parallel work.
Week 4 (Advanced): Headless mode in a script. A CI integration (GitHub Actions / GitLab). An adversarial review step. Explore agent teams on a fan-out task.
Ongoing (Expert): Package your team’s setup as a plugin + private marketplace. Tune sandboxing and managed settings. Build something on the Agent SDK. Measure ROI with analytics.

The one-paragraph summary

Claude Code is an agent that works inside your real environment by looping over read ? act ? verify. You get good by managing three levers — context (CLAUDE.md, /clear, skills, subagents), permissions (modes, rules, sandboxing, checkpoints), and verification (tests, types, review). Beginners just talk to it and keep context clean; experts compose skills, subagents, hooks, MCP, and plugins into autonomous, verifiable, parallel workflows — and wire it into CI so it works while they sleep.