Skip to main content
•11 min read•By Nathan Ibgui, fractional CIO

Claude Code: Getting Started for a Technical Team

Installation, available surfaces, guardrails and first projects: how to get your team using Claude Code without ever exposing your production codebase.

Developers at work at multi-screen workstations in an open-plan office.
Claude Code fits into the existing workstation: terminal, editor, browser. Photo: SAMHSA — public domain, via Wikimedia Commons.

The 30-second answer

Claude Code is not an assistant that suggests code: it’s a tool that reads your repository, edits files and runs commands.

That difference shapes the entire training. A completion tool is judged on the relevance of its suggestions; a tool that acts on the disk is judged first on what you allow it to do and how you review its work. The skill to pass on is scoping and review, not prompt phrasing.

6

Available surfaces: terminal, VS Code, JetBrains, desktop app, browser, mobile.

1

command line is all it takes to install it — and the tool updates itself after that.

0

lines of code should ever reach production without being reviewed by a human.

Commands and scope checked on August 31, 2026 in the official Claude Code documentation.

Installing: three commands depending on the machine

The native install is the recommended route. It places the executable in your environment and keeps it up to date in the background, with no intervention.

macOS, Linux and WSL

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

Windows, in PowerShell

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

With Homebrew

brew install --cask claude-code

Two classic pitfalls on Windows

The message “The token '&&' is not a valid statement separator” means you’re in PowerShell but typed the command meant for the classic Command Prompt — and “'irm' is not recognized” means the opposite. A simple tell: your prompt shows PS C:\ in PowerShell, and C:\ without the PS in the classic Command Prompt. Also, on a native Windows machine, install Git for Windows: without it, Claude Code falls back to PowerShell instead of a full shell. WSL machines don’t need it.

Where it runs, and which one to choose

Choose the surface by the moment, not by preference While you code Terminal (CLI) VS Code · JetBrains The project context is already open For a long task Desktop app Browser You launch, you leave, you review when you’re back To keep track Mobile Browser extension Check in, follow up, not decide Serious work gets reviewed on a big screen. Mobile is for keeping track, never for approving a merge.

In training, introduce onlyone surface on day one: the terminal if the team is comfortable with it, the editor extension otherwise. Multiplying entry points on day one spreads learning across interface differences instead of the working method, which is the same everywhere.

Note also that the command line and the VS Code and JetBrains extensions accept third-party providers — flexibility that matters if your engineering leadership has already decided where its models are hosted.

Permission modes: the setting that matters

This is the first topic to cover with a team, before the very first task. The tool isn’t all-or-nothing: there are several permission regimes, and the mode a session starts in depends on your plan, the surface used and your organization’s settings.

From most cautious to most autonomous Manual mode Starts read-only Asks before writing, testing or running Writes only in the launch folder The training mode Accept edits Auto-approves file edits in the working folder Everything else still asks Once trust is there Auto mode A classifier model decides for you and blocks what’s dangerous Your explicit rules always apply Can be disabled by the organization Train in manual mode. Loosen permissions only once the team knows how to review.

Three details worth knowing, and which usefully reassure a worried engineering leadership.

The working-directory boundary. In manual mode, the tool only writes to the folder it was launched from and its subfolders: it doesn’t modify a parent directory without explicit permission, and it asks even before it will read outside that boundary. It’s the most effective answer to the fear that “it’ll wander all over the machine.”

Network commands aren’t approved by default. Commands that fetch content from the web get no automatic approval by default: they ask, like any other non-trivial command. This limits one of the classic vectors for prompt injection through outside content.

A sandbox exists. It isolates commands from the file system and the network, which, paradoxically, lets you reduce the number of permission prompts while staying safer: you define a zone where the tool works freely but can’t leave.

The line to remember from the official documentation

The tool only has the permissions you grant it, and it’s up to you to review the proposed code and commands before approving them. In other words, technical guardrails don’t transfer responsibility: they make it manageable.

The instructions file: what makes the tool reproducible

Every session starts with a blank context window. Without a memory mechanism, your developers re-explain the same conventions every morning — and get different results depending on who started the session.

Two complementary mechanisms exist, and the distinction matters in training. The project instructions file is written by you: it holds the rules and conventions. The automatic memory is written by the tool: it records what it learns from your corrections. The first is reviewed and versioned in the repository; the second is inspected and corrected.

What to put in the project file, in order of payoff:

  • The actual commands to install, test, build and run. This is what saves the most back-and-forth, and it’s almost always forgotten.
  • The conventions nobody could guess: naming, folder structure, commit message style, required or banned libraries.
  • The areas not to touch: generated files, past migrations, code under regulatory constraints.
  • The minimum business context: what the product does and for whom, in three lines. A tool that doesn’t know the purpose produces code that is technically correct and functionally off the mark.

For a growing team, rules can apply to certain paths only, and an organization can deploy a shared instructions file across all its repositories. That’s the route to favor as soon as several teams work in parallel: knowledge stops living in the head of whoever set up their machine first.

The nuance that prevents a costly misunderstanding

The documentation is explicit: these files are treated as context, not as enforced configuration. Writing “never touch the production folder” makes the action unlikely, not impossible. To truly forbid an action no matter what, you need an interception mechanism that runs before the tool — not a sentence in an instructions file. Say this clearly in training, or you’ll create a false sense of security.

Guardrails are the real content of the training

A tool that runs commands on a development machine must be governed accordingly. Three rules are enough, and they can be taught in half an hour.

Always on a branch, never on main. It’s the most effective and least costly protection: everything produced stays isolated and is reviewed in a merge request, exactly like the work of a temporary contractor.

Write the project instructions in the repository. A context file at the root — naming conventions, test commands, what not to touch — saves re-explaining the same thing every session and makes the tool’s behavior reproducible from one developer to the next. It’s the first team habit to establish.

Review the diffs, not the conversation. The classic beginner mistake is judging the work by the quality of the exchange. What counts is the diff. A change that looks reasonable in the conversation may have touched a configuration file along the way.

The rule that sums up all three

Treat the tool’s output exactly like that of a developer who just joined: competent, fast, but with no knowledge of your internal practices or the history of your decisions. You wouldn’t merge their work without reading it — the rule doesn’t change here.

Where to start, and what to avoid

Good first projects

  • Writing missing tests for existing code
  • Understanding and documenting a module nobody knows anymore
  • Repetitive migrations: renaming everywhere, changing a signature
  • Reproducing a bug from an incident report
  • Tooling chores: scripts, continuous integration configuration

What not to hand over right away

  • A foundational architecture decision
  • Security or payment code without expert review
  • A direct intervention in production
  • A business domain nobody on the team has mastered — you won’t be able to judge the answer

The last point deserves emphasis, because it’s counterintuitive. The temptation is to use the tool where the team is weak: that’s precisely where it’s riskiest, since you can’t evaluate what it delivers. The gain is greatest where you’re competent but slow — not where you’re in the dark.

This trade-off mirrors the one we describe for agents in general in our guide to AI agents in business. For scoping access and the usage policy, see our guide to getting started with Claude in business.

Nathan Ibgui, IT & AI consultant

Written by

Nathan Ibgui

Independent consultant and fractional CIO, I help small and mid-sized businesses with IT strategy, artificial intelligence, automation and cybersecurity — from assessment to execution.

Ready to transform your business?

Describe your needs in a few lines: I reply within 24 hours with an initial analysis and concrete recommendations.