All roadmaps

Claude Code

An AI teammate in your terminal - used properly.

From install to advanced workflows: effective prompting, project memory, skills and hooks, MCP connections and headless automation - getting senior-engineer leverage from an agentic CLI.

Your progress0/35 topics · 0%

Progress is saved in this browser.

5 stages35 topics₹0 to follow
Skill certification coming soon

Filled nodes are the focus for this track; outlined ones can wait. Tap a topic to open it and mark it done, learning or skipped.

Claude Code in 2026Related roadmapsVibe Coding roadmapAI Engineer roadmapGit and GitHub roadmapProve it as you goReading is half of it. The free, scoredAI Engineer certification covers theground this roadmap leads to, and theFull-Stack Engineer job simulation putsit to work on real tickets - evidence arecruiter can check. Mark topics done,learning or skipped as you go; yourprogress carries into the classic view.AI Engineer certificationJob simulationClassic viewKnow the demand before thesyntaxClaude Code in 2026What to learn in 2026Specify, draft,checkMemory filesand skillsAgents in the terminalWhich roles use itEvery developerFounders andbuildersFresher vs switcherWhat companies expectThe hiring barWhat interviewstestProof they verifyWhat gets you hiredA 90-day planProjects thatget readCertification and proofInstalled, oriented, productivein an hour.Getting StartedWhat Claude Code isSetup & first sessionPermissions modelDrive it like a senior pair.Core WorkflowEffective task promptsPlan mode & big changesContext managementTest-driven loopsMake it yours - and yourteam's.CustomisationCLAUDE.md project memorySkills & slash commandsHooksMCP serversBeyond the interactive session.Automation & ScaleHeadless & CI usageSubagents & parallel workJudgement & limitsFresher or experienced?Both tracks hold every topic. On the Fresher track thefoundations are filled and the later stages are outlined - dothem when a project needs them. On the Experienced track thefoundations are outlined and the later stages are filled. The2026 section at the top applies to both.Prefer a list?The classic view shows the same 4 stages as a sequentialchecklist with time estimates. Your marks are shared betweenthe two views.Open the classic view

Everything on this roadmap

Every stage and topic on the map, in reading order. Click any topic to open it.

1.Know the demand before the syntax

2.Installed, oriented, productive in an hour.

3.Drive it like a senior pair.

4.Make it yours - and your team's.

5.Beyond the interactive session.

The Claude Code roadmap, topic by topic

Every topic on the map in reading order, with what to learn and the resources we recommend. Main topics are open; open any subtopic to read it. Select a topic name to open it in the topic panel, where you can track your progress.

  1. 1. Know the demand before the syntax

    Claude Code in 2026

    2026

    Agentic coding tools changed what one developer can do, and Claude Code is one of the most used of them: a terminal and editor agent that reads a whole codebase, plans, edits, runs tests and explains itself. Anthropic's Economic Index for January 2026 found coding and software development accounting for 35 percent of Claude.ai conversations, with fixing errors in existing software the single most common task; GitHub reports 80 percent of new developers using Copilot in their first week; the Stack Overflow 2025 survey has 80 percent of developers using AI tools and 46 percent distrusting their accuracy. The four nodes answer what to learn, which roles use it, what companies expect and what gets you hired.

    What to learn in 2026

    Learn the working loop - specify, let the agent draft, check the diff and the tests, own the result - then the setup that makes the agent reliable: memory files, skills, hooks and tool connections; then how to run agents in the terminal and in the cloud on real backlogs. The sub-nodes order the three.

    Specify, draft, check

    The loop is the skill: specify the change with the acceptance test stated, let the agent plan and draft, read the diff line by line, run the tests and the result, and own the commit as yours. Anthropic's January 2026 Economic Index found correcting errors in software the most common single task people bring to Claude, and the Stack Overflow 2025 survey found 45 percent of developers losing time debugging AI-written code - both are what happens when the check step is skipped. The AI Engineer roadmap names the four steps specify, draft, check, own; practise them on a real repository until they are a habit.

    Memory files and skills

    An agent is only as good as what it knows about your project: a memory file that states the stack, the conventions, the commands and the things never to do; skills that package repeatable workflows; hooks that run checks before and after actions; and connections to the tools and data it needs through the Model Context Protocol. This is the configuration layer most developers skip and the one that turns an occasionally useful assistant into a reliable teammate. Octoverse 2025's finding that most new developers start with an assistant in week one means this setup is now a basic engineering skill.

    Agents in the terminal

    AI

    Agents in the terminal and in the cloud work through a backlog while you do something else: a well-written task with its acceptance criteria, an agent that plans, edits, runs the tests and opens a pull request, and a human review before the merge. Several agents in parallel on independent tasks is the 2026 workflow for small teams and founders. The Stack Overflow 2025 survey's 46 percent distrust figure is the rule: nothing merges on green tests alone, and the review is where the engineer's value now sits.

    Which roles use it

    Every developer now works with an agent; founders and solo builders use one as their team. The sub-nodes name both groups and lay out the fresher and switcher routes.

    Every developer

    Frontend, backend, full stack, data and infrastructure engineers all work with an agent now; GitHub's Octoverse 2025 found 80 percent of new developers using Copilot in their first week, and the Stack Overflow 2025 survey has 80 percent of all developers using AI tools with 52 percent reporting a productivity gain. The difference between engineers is no longer whether they use an agent but how well they brief it, review it and bound it - which is what teams interview for and what this roadmap teaches.

    Founders and builders

    Founders and solo builders use an agent as the engineering team: it builds the product, maintains it, writes the tests and explains the code they did not write. The Startup roadmap's build stage assumes exactly this, and Anthropic's Economic Index found software development the largest category of Claude use. The skill for a founder is the same loop with more at stake - specify precisely, review anything that touches money, data or authentication, and keep a log of what was generated for the day a buyer or an investor asks.

    Fresher vs switcher

    A fresher should learn the language and the fundamentals first and the agent second, because the review step requires knowing what good code looks like; HackerRank's 2025 report found early-career hiring the hardest hit, and the fresher who can explain agent-written code is the one who gets hired. An experienced developer should start with the memory file and the loop on their own codebase and expect a week of friction before the gain. On this map freshers get the basics filled and the advanced automation stages outlined; experienced learners get the reverse.

    What companies expect

    Companies expect agents used for speed and engineers accountable for every merged line: small reviewed changes, tests the agent wrote and you read, and the judgement to know when the draft is wrong. The sub-nodes cover the bar, the interview and what gets verified.

    The hiring bar

    The bar is agent-assisted work a senior would merge: small changes with clear messages, tests the agent wrote and you read, a project memory file that keeps it on the rails, and the ability to explain every line in a pull request as your own. The Work Trend Index found 66 percent of leaders unwilling to hire without AI skills and 71 percent preferring a less experienced candidate who has them; the candidate who shows the loop on a real repository is the one those leaders mean.

    What interviews test

    Expect a practical task with the agent allowed - build or fix something in a small codebase while the interviewer watches how you brief, review and test - plus questions about a change the agent got wrong and how you caught it, and about how you set up a project for agent work. HackerRank's 2025 report says practical assessments are now the standard. The strongest candidates narrate the check step out loud.

    Proof they verify

    Reviewers read the history: a repository with agent-assisted commits that are small and explained, a memory file, tests, and a readme that states what the agent drafted and what you changed beats any claim of AI fluency. Pair it with a verified OneRoadmap certification in your language and a project that is in use.

    What gets you hired

    A repository with agent-assisted history you can explain, a project memory file that shows how you work, and a clear account of what the agent drafted and what you changed. The sub-nodes give the ninety-day plan, the projects that get read and the proof that counts.

    A 90-day plan

    Month one: the loop on an existing project of yours - ten reviewed changes, each with a test, each explained in its commit message. Month two: a memory file, two skills for repeatable workflows, a hook that runs checks, and one tool connection; the agent working a backlog of well-written tasks in the cloud while you review. Month three: a new feature shipped end to end with the agent and documented, the log of what was drafted and changed, a verified certification in your language, and twenty targeted applications a week.

    Projects that get read

    Projects that get read show the workflow: a repository where the memory file, the skills and the hooks are visible and the history shows small reviewed agent-assisted changes; a feature built in parallel by several agents with your reviews recorded; a write-up of a change the agent got wrong, how the test caught it and what you fixed. Octoverse 2025's one new developer per second all have the tool; the ones with a visible method stand out.

    Certification and proof

    Proof is a repository that shows the method: agent-assisted history you can explain, configuration that shows how you work, tests, a project in use and a verified certification. The Stack Overflow 2025 survey's 46 percent distrust figure is why reviewers look for the check step - show it and you are ahead of most applicants.

  2. 2. Installed, oriented, productive in an hour.

    Getting Started

    Installed, oriented, productive in an hour.

    Time: about 2-3 days. Topics: What Claude Code is · Setup & first session · Permissions model.

    What Claude Code is

    Optional on the Experienced track

    An agentic coding CLI that reads, edits, runs and tests your codebase - a collaborator, not an autocomplete.

    Setup & first session

    Optional on the Experienced track

    Install, authenticate, open a repo and ship a first small fix end to end.

    Permissions model

    Optional on the Experienced track

    Approve-by-default tool calls, allowlists and modes - speed and safety as an explicit dial.

  3. 3. Drive it like a senior pair.

    Core Workflow

    Drive it like a senior pair.

    Time: about 1 week. Topics: Effective task prompts · Plan mode & big changes · Context management · Test-driven loops.

    Effective task prompts

    Goal, constraints, definition of done - task briefs that produce mergeable diffs on the first pass.

    Plan mode & big changes

    Reviewing a plan before edits for multi-file work - alignment before action.

    Context management

    What's in context, /clear, and pointing at files - feeding the right code, not all the code.

    Test-driven loops

    Have it write/run tests and iterate to green - verification built into the workflow.

  4. 4. Make it yours - and your team's.

    Customisation

    Make it yours - and your team's.

    Time: about 1 week. Topics: CLAUDE.md project memory · Skills & slash commands · Hooks · MCP servers.

    CLAUDE.md project memory

    Conventions, commands and gotchas the agent reads every session - onboarding docs that execute.

    Skills & slash commands

    Packaged instructions for repeatable workflows - your team's playbooks, invocable.

    Hooks

    Scripts on tool events (format on edit, guard on bash) - determinism where you need it.

    MCP servers

    Connecting databases, browsers and internal APIs as tools - the agent's reach, extended safely.

  5. 5. Beyond the interactive session.

    Automation & Scale

    Beyond the interactive session.

    Time: about 1 week. Topics: Headless & CI usage · Subagents & parallel work · Judgement & limits.

    Build: Adopt it on a real repo. Write a CLAUDE.md, add one hook and one custom command, and ship three real fixes through the agent.

    Headless & CI usage

    Optional on the Fresher track

    Scripted runs for triage, review and codemods - the agent as infrastructure.

    Subagents & parallel work

    Optional on the Fresher track

    Fanning out exploration and checks - more contexts, faster answers, bounded cost.

    Judgement & limits

    Optional on the Fresher track

    Review everything, own what ships - where agentic coding shines and where it misleads.

Prove it as you go

Reading is half of it. The free, scored AI Engineer certification covers the ground this roadmap leads to, and the Full-Stack Engineer job simulation puts it to work on real tickets - evidence a recruiter can check. Mark topics done, learning or skipped as you go; your progress carries into the classic view.

Fresher or experienced?

Both tracks hold every topic. On the Fresher track the foundations are filled and the later stages are outlined - do them when a project needs them. On the Experienced track the foundations are outlined and the later stages are filled. The 2026 section at the top applies to both.

Prefer a list?

The classic view shows the same 4 stages as a sequential checklist with time estimates. Your marks are shared between the two views.

Frequently asked questions

What is Claude Code?

Anthropic's agentic coding tool: it runs in your terminal and in editors such as VS Code and JetBrains, reads your whole codebase, plans a change, edits files, runs commands and tests, and explains what it did. Anthropic's Economic Index for January 2026 found coding the largest category of Claude use, with fixing errors in existing software the single most common task.

Do I need to know how to code to use it?

To direct it well, you need to read code - enough to see what a change does and whether it is wrong. Founders and non-developers build real products with it, and the Vibe Coding roadmap covers that path; the review step is where the knowledge matters, and this roadmap teaches the loop that makes the review a habit.

How is it different from Copilot or Cursor?

They overlap. Copilot is the incumbent assistant with completions, chat and an agent inside the editor and GitHub; Cursor is an editor built around AI; Claude Code is an agent in the terminal and editor that plans, edits, runs and explains across a whole codebase. Many developers use more than one; the working loop is the same for all of them.

What is a memory file and why does it matter?

A file in the project that tells the agent the stack, the conventions, the commands and the things never to do, so every session starts informed. With skills for repeatable workflows, hooks that run checks, and tool connections through the Model Context Protocol, it is the configuration layer that turns an occasionally useful assistant into a reliable teammate.

Is it safe to let the agent run unsupervised?

On a bounded task with tests, in a branch, with review before merge - yes, and running several in parallel on a backlog is the 2026 workflow. On anything touching payments, authentication, data migrations or production, no: the Stack Overflow 2025 survey's 46 percent distrust figure is the rule, and nothing merges on green tests alone.

How long does it take to get good with it?

A week of friction and then a steady gain, for a developer who already knows the codebase and the language. The loop - specify, draft, check, own - is learned in ten reviewed changes; the configuration takes an afternoon; the judgement about what to delegate comes with use. Nobody can promise a timeline.

Will agentic coding tools replace developers?

They replaced the typing and raised what one developer can ship. GitHub's Octoverse 2025 found 80 percent of new developers using an assistant in their first week, and the Stack Overflow survey found 45 percent of developers losing time to debugging AI-written code - the difference between those two numbers is the review. The developer who can brief, review and bound an agent is the hire.

How do I prove I work well with agentic tools?

A repository whose history shows it: small, reviewed, agent-assisted commits with messages that say why, a memory file and skills that show how you work, tests the agent wrote and you read, and a write-up of a change the agent got wrong, how the test caught it and what you fixed. Pair it with a verified OneRoadmap certification in your language.