Get Set Up

You’ve finished the Claude 101 course, so you’ve got a feel for what Claude can do in conversation. Now we’re going to set it up where it actually matters — inside your codebase, on real code, where you can see it work.

This chapter is mostly hands-on. Budget about 2–3 hours. By the end you’ll have your tools installed, you’ll have had your first real interaction with a coding agent, and you’ll know roughly what it costs to use.

The two tools you need

We use two AI coding tools day-to-day. They overlap a bit, but they’re good at different things:

Tool	What it’s for	When to reach for it
GitHub Copilot	Autocomplete, inline chat, quick fixes	You’re already in the IDE, writing or reviewing code, and you need a suggestion or a quick answer about the file you’re looking at.
Claude Code	Deep refactors, multi-file edits, repo-wide changes, background delegation	You need something bigger — a task that touches multiple files, needs to understand your project structure, or should run commands and verify its own work.

A simple way to think about it: Copilot for in-flow work, Claude Code for everything else.

Install GitHub Copilot

Open VS Code (or Visual Studio).
Install the GitHub Copilot extension from the marketplace.
Sign in with your GitHub account. The team has Copilot Business licences, so you should be covered.
Verify it works: open any code file and start typing. You should see grey ghost-text suggestions appearing as you type.
Open Copilot Chat (Ctrl+Shift+I in VS Code) and ask it a question about whatever file you have open. Something simple like “what does this function do?” is fine.

That’s it for now. Copilot is a background companion — it works best when you’re not thinking about it too hard.

A note on Visual Studio: If you’re doing .NET work in full Visual Studio, be aware that Copilot’s agent mode in VS 2022 has a known issue where sessions hang or freeze after running commands, and VS 2026 users have reported the agent stopping mid-work. For agent-mode work (longer tasks, multi-step changes), use Claude Code in the terminal instead. Visual Studio is still the right choice for debugging, profiling, and final review.

Install Claude Code

This is the one you’ll spend the most time with. Claude Code runs as a VS Code extension (recommended) or as a standalone CLI.

VS Code extension (recommended)

Open VS Code.
Press Ctrl+Shift+X to open the Extensions view.
Search for “Claude Code” (publisher: Anthropic) and click Install. Requires VS Code 1.98.0+.
Click the ✱ Spark icon in the editor toolbar (top-right) or the status bar (bottom-right) to open the Claude Code panel.
Sign in with your Anthropic account when prompted.

That’s it. The extension bundles the CLI too, so you can run claude in VS Code’s integrated terminal if you need features like worktrees or MCP server configuration later (VS Code integration docs).

Standalone CLI (if you prefer a terminal-only workflow)

# Install Claude Code (requires Node.js 18+)
npm install -g @anthropic-ai/claude-code

# Navigate to any project directory
cd ~/projects/your-project

# Start an interactive session
claude

On first run, it’ll ask you to authenticate. Follow the prompts to connect your Anthropic account.

Full setup directions are at code.claude.com/docs/en/quickstart.

Your seat and usage limits

Everyone starts on a Claude Team Standard seat (1.25x Pro allowance). Usage isn’t unlimited — there’s a rolling 5-hour window from your first prompt and a weekly cap on top of that (Claude Team plan details). If you hit the limit, you’ll need to wait for the window to reset. Premium seats (5× the allowance) are available if you need more.

The important thing: don’t ration your usage. The whole point is to use these tools freely. But if an agent is spinning in circles — trying something, failing, trying the same thing again — kill the session. That burns allowance for nothing.

One way to stretch your allowance: not every task needs Opus. Sonnet handles the majority of day-to-day work well. Generating tests, editing files, writing boilerplate, answering questions about code — Sonnet is more than capable. Save Opus for when you need the agent to hold a lot of context or reason through something genuinely complex. Say you’re designing the approach for a refactor that touches three services, or debugging a race condition that only shows up under load. That’s Opus territory. A simple rule of thumb: if you’re writing a long, detailed prompt because the task has a lot of nuance, reach for Opus. If you can describe what you need in a sentence or two, Sonnet will do fine.

And if you do hit a limit mid-task, you’ve still got GitHub Copilot — inline suggestions and Copilot Chat both work. It’s not the same as a full Claude Code session, but it keeps you moving.

We’re still figuring out how much usage each person needs, and it’ll vary depending on what you’re working on. If you’re regularly hitting limits during normal hours, tell your lead early. Don’t wait until you’re blocked. We’d rather upgrade a seat proactively than have someone stuck.

The essentials

Four things to know before your first session. Everything else can wait.

It reads your project. Claude Code reads files, runs terminal commands, and edits code — all within your terminal session. It will ask permission before making changes, and you can approve (y) or reject (n) each action.
CLAUDE.md is its instruction file. If there’s a CLAUDE.md in your project root, Claude reads it at the start of every session. You’ll write your own in the Context Files chapter — for now, just know it exists.
Start new sessions often. One task per session is a good default. If the agent starts repeating itself or going in circles, the conversation has gotten too long for it to hold everything in memory. Don’t try to fix it. Just start fresh.
Escape to interrupt. Press Escape to stop Claude mid-response if it’s heading in the wrong direction. Press Escape twice to rewind and jump back to a previous point in the conversation.

More Claude Code tips (come back later)

These will click once you’ve used the tool a few times. Skim them now if you want, but don’t worry about memorising anything.

/help — shows all available commands.
/compact — summarises the conversation to reclaim context space when a session gets long. You can guide it: /compact focus on the authentication changes.
/clear — wipes the conversation entirely. Use it when you’re switching to a completely different task in the same project.
/cost — shows how much the current session has consumed. Good for building awareness of which tasks are expensive.
@filename — pulls a specific file into the conversation without Claude having to search for it.
Screenshots — Ctrl+V pastes a screenshot into the conversation. Useful for showing Claude a UI bug or a design to match.
Plan mode (Shift+Tab twice) — tells Claude to research and plan before making changes. Good for complex tasks where you want to review the approach first.
Think harder — phrases like “think about” or “ultra think about” trigger extended reasoning. Useful for tricky logic or architecture decisions.

Copilot tips (come back later)

You’ll pick most of these up naturally. Having a list to scan when you think “there must be a faster way” is the point.

Inline chat (Ctrl+I) — select some code, hit Ctrl+I, type what you want changed. Great for quick in-place refactors without leaving the editor.
Slash commands — /fix (fix a problem), /explain (explain selected code), /tests (generate tests). Faster than typing the full request.
#filename — pulls a specific file into Copilot Chat as context (the equivalent of @filename in Claude Code).
@workspace — tells Copilot to search across your whole workspace for context before answering, rather than just using the open file.
@terminal — ask Copilot about terminal errors. Useful when you get an error and want a quick explanation.
Partial accept (Ctrl+→) — accept ghost-text suggestions word-by-word instead of all-or-nothing. Handy when the start of a suggestion is right but the rest isn’t.
Integrated browser — Copilot can open a browser panel inside VS Code. Useful for giving chat visual context of your UI when debugging layout or styling issues.
Custom agents — you can build reusable agents with specific instructions, tools, and knowledge scoped to a task (e.g., a “code reviewer” agent or a “test writer” agent). These live in .github/agents/ and can be shared across the team via the repo (VS Code custom agents docs).
Model selection — Copilot Chat lets you switch between models (including Claude). If you hit your Claude seat limit, you can still get Claude-quality answers through Copilot. Note: when using Claude via Copilot, you’re using Claude the LLM through Copilot’s tooling — it won’t read your CLAUDE.md or .claude/ configuration. Those are specific to Claude Code. Copilot has its own instruction system (.github/copilot-instructions.md).

What happens to our code?

A fair question, and worth covering early. When you use Claude Code or Copilot, code from your project gets sent to external APIs for processing. Here’s the short version:

On our plans, neither Anthropic nor GitHub trains on your code. Anthropic processes it for the session and doesn’t retain it afterward (usage policy, privacy policy). GitHub’s Copilot Business plan works the same way (Copilot trust centre).

So what does this mean day-to-day? Mostly: use the tools normally, but be thoughtful about what you put in. Don’t paste secrets, credentials, or connection strings into prompts (the Risks and Hard Rules chapter goes deeper on this). For most client work, standard AI-assisted development is fine and our contracts cover it. But if a client has strict data residency or IP requirements, check with the lead before using AI tools on their repo. When in doubt, ask rather than guessing.

Enable LSP for Claude Code

You know how your editor can jump to a function definition, or show you all the places something is used? That’s powered by a language server. Without one, Claude Code falls back to text search — which works, but means more false matches and the occasional hallucinated method name. With LSP enabled, the agent uses the same code intelligence your IDE does. Fewer mistakes, better navigation. It’s optional, but it makes a noticeable difference.

Step 1 — Install the language server binary. The plugin needs a language server installed on your machine:

Language	Install
TypeScript / JavaScript	`npm install -g typescript-language-server typescript`
C# / .NET	Install csharp-ls or OmniSharp — see each repo’s README. If you’re not sure which, start with csharp-ls (lighter weight).

Step 2 — Install the plugin. In a Claude Code session, run:

/plugin install typescript-lsp@claude-plugins-official

Or interactively: type /plugin, go to the Discover tab, and search for your language. Installing the plugin automatically enables the LSP tool — no environment variables or extra configuration needed.

For languages not in the official marketplace (e.g., Astro, GraphQL), you can configure a custom language server using a .lsp.json file — see the LSP plugin docs for the format.

Step 3 — Verify. In a Claude Code session, ask: “What tools do you have?” — you should see LSP operations like goToDefinition, findReferences, hover, diagnostics, and codeActions in the list.

Your .NET setup

Not working in .NET? Skip to the next section. This is specific to our C# and Optimizely projects.

We do a lot of C# and Optimizely work, so a couple of things are worth setting up early.

The compiler is your best friend here. C#‘s type system means dotnet build catches a whole class of agent mistakes for free — hallucinated methods, wrong types, missing usings. The agent sees the compiler error, fixes it, and moves on. Matt Eland’s “16 Tips for Writing AI-Ready C# Code” has practical advice for making this even tighter: treat warnings as errors, use GlobalUsings.cs to prevent the “missing using statement” problem, and add analysers like StyleCop.

Two-IDE workflow. Many .NET developers — us included — now keep two environments open:

Visual Studio: debugging, profiling, complex refactors where you need the full IDE.
VS Code + Copilot + Claude Code: AI-assisted development, code generation, agent workflows.

You don’t have to use both from day one. But as you get more comfortable with Claude Code, you’ll naturally find yourself reaching for VS Code more and Visual Studio less for day-to-day coding.

dotnet-skills. Aaron Stannard maintains an open-source collection of specialised Claude Code configurations covering C# coding standards, EF Core patterns, testing strategies, and more (GitHub). We’ll evaluate incorporating relevant pieces into our own CLAUDE.md files as part of the Context Files chapter.

What gets committed?

After you run /init in the exercise below, Claude will generate a CLAUDE.md file. Naturally, you’ll wonder: does this go in the repo? What about the .claude/ directory it creates? Here’s our convention:

File/directory	Commit?	Why
`CLAUDE.md` (project root)	Yes	Shared team instructions. Everyone benefits from this.
`CLAUDE.local.md`	No	Personal preferences (your editor setup, your shortcuts). Add to `.gitignore`.
`.claude/` directory	Mostly no	Contains session history, local settings. Add to `.gitignore`.
`.claude/commands/`	Yes	Custom commands are shared team tools. Commit these.
`.github/copilot-instructions.md`	Yes	Copilot’s equivalent of CLAUDE.md. Shared.
`.github/agents/`	Yes	Custom Copilot agents. Shared.

If you’re not sure, the rule is: shared instructions and commands get committed; personal settings and session data don’t. Make sure your .gitignore includes .claude/ (except .claude/commands/), CLAUDE.local.md, and any other local-only files.

Cost awareness

AI tools aren’t free. You don’t need to think about cost on every prompt, but it helps to have a rough sense of the numbers so you can spot waste when it happens.

Tool	Cost model	What it costs us
GitHub Copilot	Business subscription	Monthly fee per seat — no marginal cost per use
Claude Code (interactive)	Team Standard seat	Monthly fee per seat ($25/month; Premium at $125/month available on request)
Claude Code GitHub Action	API usage (per token)	Roughly $0.001–$0.01 per PR with Sonnet — the range depends on how much code the agent needs to read and how many iterations it takes (claude-code-action)

Prompt caching (enabled by default) reduces costs for repeated context, so the effective cost is usually lower than the headline numbers. The takeaway: use the tools freely. But if you notice an agent stuck in a loop — trying something, failing, trying the same thing — kill the session. That’s wasted tokens and wasted time.

Exercise 01 — First contact

Your first real conversation with a coding agent. The goal isn’t to build anything important — it’s to make sure everything works and get a feel for what the experience is like.

Practice repo: Clone (or fork privately) the Rokkit200 Next.js site — github.com/Rokkit200/Rokkit200.Website

What to do: Open the repo in VS Code, start a Claude Code session, and run /init. Watch what it does — it’ll analyse the codebase and generate a CLAUDE.md file. Read the output. Then give it a small, well-scoped task: ask it to generate tests for an existing component or utility function. Something with low stakes.
What to look for: Does the /init output make sense? Does it capture the project’s structure and purpose accurately? For the test generation — are the test names descriptive? Does it mock the right dependencies? Does it run the tests and verify they pass?
Common pitfalls: Starting with something too ambitious. This isn’t the time for a big refactor. Pick something small, watch the process, get comfortable with approving and rejecting actions.
Reflection prompt: What surprised you about how Claude Code approached the task? Was there a moment where you thought “I wouldn’t have done it that way”?

Stretch goals (if you want to push further):

Ask Claude Code to refactor a small module and evaluate whether its approach is sound. Don’t accept or reject immediately — read the plan it proposes and think about whether you’d have made the same choices.
Try the same task with Sonnet, then switch to Opus. Can you feel the difference? When is the extra reasoning worth it?
Run /cost after your session and note the total. This builds intuition for how much different types of tasks consume.

What’s next

Tools are installed. You’ve had your first conversation with an agent. You’ve seen it read your code, propose changes, and (hopefully) run the tests. That’s the foundation.

Next up: how to give agents good work. The spec-first workflow is where the real difference happens — between useful output and confident garbage. But before you start the next chapter, complete the Claude Code in Action course if you haven’t already. It goes deep on context management, custom commands, hooks, and MCP servers. The Core Skills chapters build directly on what you’ll learn there.

☁ Course: Claude Code in Action — anthropic.skilljar.com/claude-code-in-action