Learn Claude from Scratch

Build practical confidence with Claude for everyday work and software engineering. Start with the right interface, complete the setup, and progress toward enterprise-grade Claude workflows.

Getting started​

Claude provides different ways of working. You do not need to complete every pathway. Select the interface and modules that match your role and objectives.

What you will learn​

• Install and verify Claude Code on your preferred operating system
• Use Claude for professional research, analysis, writing, and planning
• Navigate and understand existing codebases
• Plan, implement, test, review, and explain code changes
• Work safely with Git branches and repositories
• Connect approved tools and data sources through MCP
• Create reusable instructions, skills, hooks, and subagents
• Apply human review and enterprise governance throughout the workflow

Choose your learning path​

Choose the pathway that aligns with your current objective. You can return and complete the remaining modules later.

Installation​

Claude Code supports native installation on Windows, macOS, Linux, and Windows Subsystem for Linux.

Select your operating system or preferred interface below.

System requirements​

• Operating system: Windows 10 version 1809 or newer, macOS 13 or newer, or a supported Linux distribution
• Memory: Minimum 4 GB RAM
• Processor: x64 or ARM64
• Network: Internet connection
• Shell: Bash, Zsh, PowerShell, or Windows Command Prompt
• Windows recommendation: Git for Windows enables Claude Code to use Bash

irm https://claude.ai/install.ps1 | iex

claude --version

cd /c/path/to/your/project

claude

irm https://claude.ai/install.ps1 | iex

claude --version

cd "C:\path\to\your\project"

claude

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

claude --version

cd C:\path\to\your\project

claude

curl -fsSL https://claude.ai/install.sh | bash

claude --version

cd /path/to/your/project

claude

curl -fsSL https://claude.ai/install.sh | bash

claude --version

cd /path/to/your/project

claude

curl -fsSL https://claude.ai/install.sh | bash

claude --version

cd /path/to/your/project

claude

Verify your setup​

Run:

claude --version

A successful installation displays the installed Claude Code version.

Open a small project:

cd /path/to/your/project

Start an interactive Claude Code session:

claude

On first use, follow the authentication instructions displayed in the browser or terminal.

Claude for Work​

Claude for Work supports research, analysis, writing, planning, file-based work, Projects, Artifacts, Skills, and approved integrations. Anthropic Academy also provides role-based courses and completion certificates. 【1-9ce594】

Select a working mode​

Recommended working sequence​

1. Define the business outcome and intended audience
2. Provide only approved and relevant context
3. Ask Claude to identify assumptions or missing information
4. Request a structured first draft
5. Review factual claims, calculations, and recommendations
6. Refine the output for the target audience
7. Complete human and policy review before sharing

Example use cases​

• Summarise a long document for an executive audience
• Compare proposals against defined evaluation criteria
• Convert meeting notes into decisions and action items
• Analyse a spreadsheet or structured business report
• Draft a project plan, status update, or presentation outline
• Review a document for clarity, consistency, and missing information
• Create reusable guidance for a recurring business process

Human-review checklist​

Claude Code fundamentals​

Claude Code is an agentic development environment that can inspect files, search a repository, edit code, run commands, and verify results. Its core working loop is to gather context, take action, and validate the outcome, while allowing the user to interrupt and redirect the work. 【2-97122a】【3-505344】

Start a project session​

Open a terminal in the project root:

cd /path/to/your/project

Check the current repository state:

git status

Start Claude Code:

claude

Understand the codebase before editing​

Begin with broad exploration, then narrow the investigation to the relevant feature or issue. Anthropic’s workflow guidance recommends asking for a high-level overview before requesting deeper architectural or execution-flow analysis. 【4-f050ab】

Use requests such as:

Give me a concise overview of this codebase.

Include:
- Main directories
- Application entry points
- Architecture patterns
- Testing approach
- Build and validation commands
- Important project conventions

Do not modify any files.

Then narrow the analysis:

Identify the files involved in user authentication.

Explain:
- How the files interact
- The execution flow
- Where validation occurs
- Which tests cover this behavior

Do not make changes yet.

Use a controlled engineering workflow​

Request a plan before implementation​

Analyse the requested change and create an implementation plan.

Include:
1. Current behavior
2. Proposed behavior
3. Files that may change
4. Validation and error handling
5. Security considerations
6. Tests to add or update
7. Commands used to verify the result

Do not modify files until the plan is reviewed.

Implement with clear boundaries​

Implement the approved plan.

Requirements:
- Keep changes limited to the approved scope
- Follow existing project conventions
- Preserve backward compatibility
- Add type hints or types where applicable
- Include input validation and error handling
- Update or add tests
- Do not modify unrelated files

Give Claude verification criteria​

Claude performs more reliably when the task includes a test, build, lint command, expected output, fixture, screenshot, or another measurable completion signal. 【5-5f8b6c】【3-505344】

After implementation:

1. Run the relevant tests
2. Run linting and type checks
3. Run the production build
4. Review the complete diff
5. Report any remaining risks or assumptions

Do not claim completion if any required check fails.

Review the result​

git status
git diff

Review:

• Files changed
• Logic and edge cases
• Error handling
• Security implications
• Test coverage
• Dependency changes
• Configuration changes
• Documentation impact

Project and Git workflows​

Use Claude within the existing engineering process, not as a replacement for Git controls, code review, testing, or human approval.

Start from a safe repository state​

Before starting Claude Code:

git status
git branch --show-current
git pull

Confirm that:

• The correct repository is open
• The current branch is known
• Existing uncommitted changes are understood
• Project-specific instructions are available
• Required build and test commands are known

Create a focused feature branch​

git switch -c feature/short-description

Use a branch name that communicates the intended change.

Examples:

feature/add-token-estimator
fix/underwriting-validation
refactor/marketplace-card-data
docs/claude-learning-guide

Initialise project guidance​

Inside a Claude Code session, run:

/init

This creates a starter CLAUDE.md file for project-level guidance.

Review the generated file before keeping it. Include only stable information such as:

• Project architecture
• Important directories
• Coding conventions
• Testing commands
• Build commands
• Security requirements
• Files that must not be modified
• Definition of done

Use plan mode before large changes​

Inside Claude Code:

/plan

Then provide the requested outcome:

Analyse the requested change and prepare a scoped implementation plan.

Include:
1. Existing behavior
2. Proposed behavior
3. Files likely to change
4. Validation and error handling
5. Security considerations
6. Tests to add or update
7. Commands required for verification

Do not modify files yet.

Review and correct the plan before implementation.

Implement on the feature branch​

After approving the plan:

Implement the approved plan.

Requirements:
- Follow existing architecture and conventions
- Limit changes to the approved scope
- Preserve backward compatibility
- Validate user-controlled input
- Handle expected failure conditions
- Add or update tests
- Do not modify unrelated files

Review changes before committing​

Inside Claude Code, use:

/diff

You can also review directly through Git:

git status
git diff
git diff --stat

Check for:

• Unexpected files
• Unrelated formatting changes
• Hardcoded credentials or secrets
• Missing validation
• Debugging statements
• Weak error handling
• Unnecessary dependencies
• Missing tests
• Configuration changes

Run project validation​

Use the verification commands defined by the project.

Example:

npm test
npm run lint
npm run build

For a Python project:

python -m pytest
python -m ruff check .
python -m mypy .

Ask Claude to review the final change​

Review the complete uncommitted diff.

Check for:
- Functional defects
- Edge cases
- Security concerns
- Missing validation
- Test gaps
- Backward compatibility
- Unnecessary complexity
- Changes outside the approved scope

Do not modify files. Return findings by severity.

Claude Code also provides review-oriented commands such as:

/code-review
/security-review

Availability may depend on the installed Claude Code version and enterprise configuration.

Create a focused commit​

Stage only the intended files:

git add path/to/file1 path/to/file2

Review the staged result:

git diff --staged

Commit with a clear message:

git commit -m "feat: add token estimation workflow"

Push the feature branch:

git push -u origin feature/short-description

Pull-request checklist​

MCP integration​

Model Context Protocol, or MCP, allows Claude Code to use approved tools and data sources beyond its built-in capabilities.

An MCP server can provide controlled access to systems such as:

• Issue trackers
• Source-control platforms
• Documentation systems
• Monitoring tools
• Databases
• Internal APIs
• Design platforms
• Approved enterprise services

How MCP works​

Add an approved HTTP server​

Run MCP configuration commands in the terminal, outside the interactive Claude Code session.

General structure:

claude mcp add --transport http <server-name> <server-url>

Example using the public Claude Code documentation server:

claude mcp add --transport http claude-code-docs https://code.claude.com/docs/mcp

The server name is a local label. Use a clear name that identifies the system or purpose.

Verify the connection​

List configured servers:

claude mcp list

Check a specific server:

claude mcp get claude-code-docs

Start Claude Code:

claude

Inside the session, inspect MCP availability:

/mcp

Then test with a read-only request:

Use the Claude Code documentation MCP server to find the official guidance for plan mode.

Summarise the result and identify the source used.
Do not perform any write actions.

Remove a server​

claude mcp remove claude-code-docs

Select the correct scope​

MCP configuration may be applied at different scopes:

• Local: Available to the current user in the current project
• Project: Shared through project configuration
• User: Available to the current user across projects
• Managed: Controlled centrally by the enterprise

Use the narrowest scope that meets the requirement.

MCP security checklist​

Before using any MCP server, verify:

• The server comes from an approved and trusted source
• Authentication follows enterprise standards
• Only required permissions are granted
• Secrets are stored outside source control
• Tool descriptions and parameters are reviewed
• Write and destructive actions require approval
• External content is treated as untrusted input
• Logs do not expose credentials or restricted information
• Customer and proprietary data remain within approved boundaries
• The server can be disabled or removed safely

Prompt-injection risk​

MCP servers that retrieve external content may expose Claude to malicious or misleading instructions embedded in that content.

Reduce risk by:

1. Using approved servers and trusted data sources
2. Starting with read-only access
3. Reviewing tool requests before approval
4. Separating retrieved data from trusted project instructions
5. Preventing uncontrolled access to credentials and production systems
6. Requiring human approval for write, delete, deploy, or communication actions

Custom instructions and skills​

Claude Code provides multiple ways to customise how Claude works. Choose the narrowest option that fits the requirement.

Claude reads project instructions from CLAUDE.md during every session. Skills are better for detailed procedures because their content is loaded only when needed. 【1-53dca7】【2-bb2590】

Create project instructions​

From the project root, start Claude Code:

claude

Run:

/init

Claude creates a starter CLAUDE.md.

Review and simplify the generated content before committing it.

Recommended CLAUDE.md structure​

# Project guidance

## Architecture

- Use the existing layered architecture
- Keep business logic separate from framework-specific code
- Reuse existing components before introducing new abstractions

## Development commands

- Start: `npm run start`
- Test: `npm test`
- Lint: `npm run lint`
- Build: `npm run build`

## Engineering standards

- Validate external inputs
- Preserve backward compatibility
- Add tests for changed behavior
- Avoid unrelated refactoring
- Never hardcode credentials or environment-specific values

## Definition of done

- Required tests pass
- Linting and type checks pass
- Production build succeeds
- Final Git diff is reviewed
- Documentation is updated when required

Project and personal locations​

A common project structure is:

your-project/
├── CLAUDE.md
└── .claude/
    ├── settings.json
    ├── settings.local.json
    ├── rules/
    ├── skills/
    └── agents/

Personal configuration is stored under:

~/.claude/

On Windows, this normally resolves to:

%USERPROFILE%\.claude

Commit project-level instructions and approved shared configuration to Git. Keep personal configuration and local overrides outside shared project history unless explicitly required. 【2-bb2590】

Create a reusable skill​

Use a Skill when the same instructions, checklist, or multi-step procedure is repeatedly pasted into conversations.

Create the skill directory:

mkdir -p .claude/skills/production-readiness

Create:

.claude/skills/production-readiness/SKILL.md

Add:

---
name: production-readiness
description: Review a proposed change for production readiness
---

# Production readiness review

Review the requested change for:

1. Functional correctness
2. Input validation
3. Error handling
4. Security risks
5. Backward compatibility
6. Test coverage
7. Logging and observability
8. Configuration impact
9. Deployment risk
10. Rollback readiness

Return findings by severity.

Do not modify files unless explicitly requested.

Invoke the skill​

Inside Claude Code:

/production-readiness

Or provide a target:

/production-readiness review the current uncommitted changes

Claude may also load a skill automatically when the skill description clearly matches the task. Skills can include supporting files and can execute in the current conversation or through isolated subagent context. 【1-53dca7】【3-d519fb】

When to use each option​

• CLAUDE.md: Stable project architecture, commands, conventions, and mandatory rules
• Rules: Guidance limited to a directory, language, or file pattern
• Skills: Repeatable procedures, reference material, and structured workflows
• Personal configuration: Individual preferences that should not affect the team
• Managed settings: Enterprise-enforced controls that users cannot override

Instruction design checklist​

• Keep each instruction specific and testable
• Explain when the instruction applies
• Avoid conflicting rules
• Do not embed credentials or secrets
• Do not store temporary task details in persistent instructions
• Prefer examples for conventions that are easy to misunderstand
• Review committed instructions through the normal pull-request process
• Periodically remove obsolete guidance

Hooks and subagents​

Hooks and subagents solve different problems.

• Hooks run deterministic automation at defined lifecycle events
• Subagents perform focused tasks in isolated context and return summarised results

Use hooks for controls that must run consistently. Use subagents for work that benefits from specialised instructions, tool restrictions, or separated context. 【4-4f22c7】【5-41ef62】【6-bc4e08】

Hooks​

Hooks can run when Claude Code starts a session, requests a tool, completes a tool call, sends a notification, starts or stops a subagent, or finishes execution.

Common uses include:

• Block dangerous commands
• Prevent access to protected files
• Run formatting after file changes
• Run validation after edits
• Notify users when input is required
• Log tool usage for auditing
• Require approval for sensitive actions

Hook execution model​

Configure a project hook​

Project hooks are configured in:

.claude/settings.json

Example structure:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint"
          }
        ]
      }
    ]
  }
}

What this hook does:

• Runs after Claude uses an Edit or Write tool
• Executes the configured lint command
• Gives Claude a deterministic validation result

Inspect configured hooks​

Inside Claude Code:

/hooks

Use the hooks interface to inspect configured events and verify that the expected hook is registered. Claude Code supports command, prompt, agent, and other hook handler types, depending on the lifecycle event and configuration. 【5-41ef62】【7-24042e】

Hook safety checklist​

• Use the narrowest event and matcher
• Avoid destructive commands
• Quote file paths safely
• Validate all hook inputs
• Set reasonable time limits
• Do not expose secrets in logs
• Ensure commands return meaningful exit codes
• Keep frequently triggered hooks lightweight
• Document operating-system assumptions
• Test failure behavior before committing configuration

Subagents​

A subagent is a specialised assistant that works in its own context window.

The subagent can:

• Search many files without filling the main conversation
• Perform focused research
• Review security or test coverage
• Use a restricted tool set
• Apply a specialised system prompt
• Return only the relevant summary

Subagents are useful when a side task would otherwise fill the main session with logs, search results, or large file contents. 【6-bc4e08】【8-cb2507】

Create a custom subagent​

Create:

.claude/agents/security-reviewer.md

Add:

---
name: security-reviewer
description: Review code changes for application security risks
tools: Read, Grep, Glob
---

You are a read-only application security reviewer.

Review the requested code or Git diff for:

- Input validation weaknesses
- Authentication and authorisation defects
- Injection risks
- Secret exposure
- Unsafe file access
- Insecure network communication
- Sensitive data leakage
- Missing security tests

Do not edit files.

Return:

1. Critical findings
2. High findings
3. Medium findings
4. Low findings
5. Recommended validation steps

Ask Claude to use the subagent​

Use the security-reviewer subagent to review the current uncommitted changes.

Return only the findings and recommended validation steps.
Do not modify files.

Recommended subagents​

Keep permissions focused​

A subagent should receive only the tools required for its role.

Examples:

• A reviewer normally needs Read, Grep, and Glob
• A test runner may require Bash but not file-editing tools
• A documentation agent may need Read and Write for specific directories
• A research agent should not receive deployment or production-write access

``

Advanced workflows​

Advanced Claude workflows combine structured planning, isolated execution, verification, human approval, and controlled parallelism.

Select the right execution pattern​

Claude Code supports subagents, isolated Git worktrees, agent teams, and dynamic workflows. Worktrees isolate file changes, while subagents and agent teams coordinate specialised work. Dynamic workflows are intended for large, repeatable activities requiring many agents or independent verification. 【1-61d1f6】【2-75d13b】【3-dc043c】

Use a gated delivery workflow​

Start an isolated worktree session​

From the repository root:

claude --worktree feature-auth

Claude Code creates an isolated working directory and branch under:

.claude/worktrees/feature-auth/

Run another independent session:

claude --worktree fix-validation

Each worktree has its own files and branch while sharing the same Git repository history and remote. This allows parallel sessions to work without editing the same working directory. 【1-61d1f6】

Add the generated worktree directory to .gitignore:

.claude/worktrees/

Delegate independent reviews​

Use focused subagents after implementation:

Delegate the following independent read-only reviews:

1. Security reviewer
   - Review input validation, access control, secrets, injection risks,
     dependencies, and sensitive-data handling

2. Test analyst
   - Review test coverage, edge cases, failure paths, and regression risks

3. Maintainability reviewer
   - Review architecture, readability, duplication, complexity, and
     consistency with project conventions

Return separate findings by severity.
Do not modify files.

Cross-check the findings​

Compare the independent review findings.

For each finding:
- Confirm whether evidence exists in the code
- Identify the affected file and behavior
- Remove duplicate or unsupported findings
- Classify severity
- Recommend a focused remediation
- Identify the validation required after remediation

Do not modify files.

Manage context carefully​

Claude Code’s context includes conversation history, files read, and command output. Long debugging sessions or broad repository exploration can consume substantial context, so use focused tasks, subagents, fresh sessions, and verification commands to preserve useful context. 【3-bd8aeb】

Useful commands include:

/context

/compact

/clear

/resume

Use them as follows:

• /context: Inspect what is consuming the current context
• /compact: Summarise the conversation and release context space
• /clear: Start a fresh task while retaining project-level instructions
• /resume: Continue an earlier session

Command availability can vary by Claude Code version and enterprise configuration.

Apply permission controls​

Inside Claude Code:

/permissions

Claude Code supports allow, ask, and deny rules for controlling tool use. Deny rules take priority over ask and allow rules. Read-only operations generally require less approval than shell commands or file modification. 【4-3f41cd】

Recommended approach:

• Allow only trusted read-only operations by default
• Ask before file changes and shell commands
• Deny destructive operations and protected paths
• Require approval for database writes, deployment, and external communication
• Review saved permissions periodically
• Keep local permission overrides outside shared configuration

Production-readiness review​

Before considering work complete, verify:

• The business requirement is satisfied
• The approved plan and scope were followed
• Input validation and expected failures are handled
• Authentication and authorisation remain correct
• Secrets and restricted information are excluded
• Tests cover successful and failure scenarios
• Linting, type checks, and the production build pass
• Dependency and configuration changes are understood
• Logs and monitoring are adequate
• Deployment and rollback steps are documented
• The complete Git diff has received human review

Enterprise access​

Claude access and subscriptions are provided through the enterprise.

Users should not create independent paid subscriptions or bypass enterprise access controls for business work.

Requesting additional token capacity​

If the available capacity does not support the required workload:

1. Open AI Lens in 1C
2. Create a new workstream and raise request by describing the buisiness problem and other details
3. Describe the business problem and expected outcome
4. After the workstream is aprroved you can raise request for more tokens under that workstream
5. Provide the reason for requesting more tokens
6. Submit the workstream for enterprise review and approval

Information to include​

Responsible-use requirements​

Before using Claude for enterprise work:

• Confirm that the approved Claude environment is being used
• Follow project, customer, privacy, security, and data-handling policies
• Do not paste credentials, tokens, private keys, or passwords
• Do not submit restricted data without explicit approval
• Apply least-privilege access to MCP servers and external tools
• Review generated code and business recommendations
• Validate important facts and calculations
• Test all generated code before deployment
• Maintain human approval for consequential actions
• Report suspected data exposure or unsafe behavior through approved channels

Final learning checklist​