Setting Up Your Agent Toolkit

Setting Up Your Agent Toolkit

Enough theory. Let us get your hands dirty. In this lesson, you will install the essential AI coding agent tools, authenticate them, run your first agent interaction, and have a clear roadmap for the rest of this course.

By the end of this lesson, you will have a working development environment with at least two AI coding agents ready to go.

Step 1: Install Claude Code

Claude Code is the primary tool for this course. It is a terminal-based AI coding agent built by Anthropic that runs directly in your shell.

Installation Options

macOS (Homebrew -- recommended):

brew install claude-code

macOS / Linux (curl):

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

Windows (WinGet):

winget install Anthropic.ClaudeCode

npm (all platforms):

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

Verify the installation:

claude --version
# Should output something like: claude-code 1.x.x

Authentication

Claude Code needs an Anthropic account. You have several options:

To authenticate:

claude
# First run will open your browser for authentication
# Log in with your Anthropic account

If you want to use an API key instead:

export ANTHROPIC_API_KEY="sk-ant-your-key-here"
claude

Step 2: Install a Secondary IDE Tool

While Claude Code is our primary tool, you should also have an IDE-integrated agent for daily coding. Pick one:

Option A: GitHub Copilot (VS Code)

# Install the VS Code extension
code --install-extension GitHub.copilot
code --install-extension GitHub.copilot-chat

Then sign in with your GitHub account in VS Code. Enable Agent Mode in Copilot Chat settings.

Option B: Cursor

Download from cursor.com↗. It is a standalone editor based on VS Code, so all your extensions and settings transfer:

# macOS
brew install --cask cursor

# Or download directly from cursor.com

Option C: Cline (Open Source, VS Code)

code --install-extension saoudrizwan.claude-dev

Then configure your API key in the extension settings. Cline works with Claude, GPT, Gemini, or local models.

Step 3: Optional -- Install Codex CLI

OpenAI's Codex CLI is useful as a complementary cloud agent:

npm install -g @openai/codex

Authenticate with your OpenAI account:

export OPENAI_API_KEY="sk-your-key-here"
codex

Step 4: Your First Agent Interaction

Now let us run your first real agent session. Open your terminal and navigate to any project directory (or create a test project):

# Create a test project if you do not have one handy
mkdir ~/agent-playground && cd ~/agent-playground
git init
echo '# Agent Playground' > README.md
git add . && git commit -m "Initial commit"

Now launch Claude Code:

claude

You will see the Claude Code interface. Type your first prompt:

Create a simple Node.js Express API with three endpoints:
1. GET /health - returns status ok
2. GET /api/time - returns current server time
3. POST /api/echo - returns whatever JSON body is sent

Include proper error handling and a package.json with scripts.

Watch what happens. The agent will:

1. Create package.json with Express as a dependency
2. Create server.js (or index.js) with the three endpoints
3. Run npm install to install dependencies
4. Possibly create a test file
5. Possibly run the server to verify it starts correctly

This is the agent loop in action. It is not just generating code -- it is building a working project.

Step 5: Explore the Interface

While in a Claude Code session, try these essential interactions:

Keyboard shortcuts:

• Shift+Tab -- Toggle plan mode (agent plans but does not act)
• Ctrl+C -- Cancel current generation
• Escape -- Clear input / exit menus
• Ctrl+L -- Clear conversation display

Slash commands:

/help          # Show all available commands
/model         # Switch the AI model
/clear         # Clear conversation and free context
/compact       # Summarize conversation to save context
/status        # Show session info and token usage
/cost          # Show session costs
/permissions   # Manage tool permissions

Try plan mode: Press Shift+Tab and then ask: "What would you change to add rate limiting to this API?" The agent will analyze your code and create a detailed plan without making any changes. This is incredibly useful for understanding what an agent would do before letting it act.

Step 6: Verify Your Setup

Let us make sure everything is working. Run through this checklist:

# Check Claude Code
claude --version
claude -p "What is 2 + 2?" --output-format text
# Should output: 4 (or a response containing 4)

# Check your IDE tool
# For Copilot: Open VS Code, check the Copilot icon in the status bar
# For Cursor: Open Cursor, check that AI features are active
# For Cline: Open VS Code, check the Cline panel

# Check Node.js (needed for many exercises)
node --version    # Should be 18+
npm --version     # Should be 9+

# Check Git (essential for agent workflows)
git --version     # Should be 2.30+

# Check Python (optional, useful for some exercises)
python3 --version # Should be 3.10+

The Claude Code Surfaces

One thing that makes Claude Code unique is that it runs on multiple surfaces -- not just the terminal:

All surfaces share the same underlying agent engine. Your CLAUDE.md files, skills, and settings work across all of them.

Course Roadmap

Here is what you will learn in the rest of this course:

Chapter 2: Understanding AI Coding Agents -- Deep dive into how agents work internally: the agent loop, tool use, context windows, memory, sandboxing, and choosing the right model.

Chapter 3: The Agent Skills Open Standard -- Master the SKILL.md format, build custom skills, understand discovery and activation, work with scripts, and test skills effectively.

Chapter 4: Claude Code Field Guide -- Become a Claude Code power user: CLI commands, CLAUDE.md configuration, plan mode, extended thinking, context management, and productivity workflows.

Chapter 5: Advanced Agent Workflows -- Multi-agent orchestration, hooks system, MCP servers, CI/CD integration, and building autonomous pipelines.

Chapter 6: Building Production Skills -- Real-world skill development: deployment skills, code review, testing, documentation generation, and publishing to the community.

Chapter 7: The Future of Agentic Development -- Where this technology is heading, how to stay current, and building your career around AI-assisted development.

Each chapter builds on the previous one. The exercises get progressively more complex. By Chapter 5, you will be building multi-agent systems that can handle entire development workflows autonomously.