"AI" everywhere. And now?

• Open LinkedIn: AI
• Open the news feed: AI
• Your manager sends a link about AI
• The company announces an AI “strategy”
• Your colleague is already using three different tools and you still don’t fully understand any of them.

If you feel like this, you’re not alone. The speed at which new tools, frameworks, and buzzwords appear is genuinely overwhelming. “Agentic coding,” “vibe coding,” “prompt engineering,” “MCP servers”… for someone just trying to do their job and ship working code, all this noise can be paralyzing. The result? Many people simply don’t start.

Or they start in the worst possible way: pasting code into ChatGPT and hoping whatever comes back actually works.

This article is for you if you’re at that point. No unnecessary buzzwords, no abstract theory. We’re going to look at a concrete tool, Claude Code, and how it can change the way you work day to day. And more importantly: we’ll see how to get started, step by step.

You copy a traceback, paste it into a chat window, get a fix that breaks something else in a file the AI didn’t even know existed. You explain the project structure, the context gets lost halfway through, you open a new conversation and you’re back to square one.

Sound familiar? It’s not you. It’s the interaction model. Chat-based tools don’t see your project, can’t run your tests, and forget everything when the context window fills up. The result? All the integration work falls on you: copying code between windows, re-explaining the project, reviewing output you don’t fully trust.

There’s a different way to work.

Claude Code is an agent-based coding tool created by Anthropic that runs directly in your terminal (and beyond). Unlike traditional chatbots, it reads your files, edits them directly, runs tests, identifies errors, fixes them, and manages Git. All within your actual project.

The key difference: instead of you acting as the go-between for the AI and your codebase, the agent works within the codebase. It understands the structure of your files, the dependencies, and the full context of the project.

Claude Code is available on the terminal (CLI), in VS Code, Cursor, Google Antigravity, JetBrains IDEs (IntelliJ, PyCharm, WebStorm), as a desktop app, and even in a web version at [claude.ai/code.] (https://claude.ai/code) It supports the Claude Opus 4.6 and Sonnet 4.6 models, with up to 1M tokens of context.

One of the most common barriers to entry is installation. Here are all the available methods. Choose the one that suits your setup.

Native Installation (Recommended) The most straightforward method, with automatic background updates.

• macOS / Linux / WSL:
• Windows PowerShell:
• Windows CMD:

Note for Windows: You need Git for Windows installed beforehand. If you see an error regarding &&, you are likely in PowerShell rather than CMD. Use the PowerShell command above.

• Via Homebrew (macOS/Linux)
• Via WinGet (Windows)
• Via npm (for those who already have Node.js)

Translated with DeepL.com (free version)

If you don’t want to install anything locally, you can use Claude Code directly in your browser at claude.ai/code. It works with GitHub repositories without you needing to have cloned them locally.

IDE Extensions If you prefer to work within your editor:

• VS Code / Cursor: search for “Claude Code” in the extensions marketplace
• Google Antigravity: as a fork of VS Code, Antigravity is 100% compatible with VS Code extensions. Simply install the “Claude Code” extension in the same way. If you already use Antigravity as your main IDE (with Gemini 3 Pro included for free), you can combine the best of both worlds: Antigravity agents for certain tasks and Claude Code for your SDLC workflow
• JetBrains (IntelliJ, PyCharm, WebStorm): install the ‘Claude Code’ plugin from the JetBrains Marketplace

Desktop App Available for direct download:

macOS (Intel and Apple Silicon) : Download

Windows x64 : Download

The most powerful feature of Claude Code is the CLAUDE.md file. Placed in the root directory of your project, it acts as a persistent ‘briefing’ that the agent automatically reads at the start of each session.

Here you define:

• Project architecture: technology stack, folder structure
• Useful commands: how to run the dev server, tests, and the linter
• Team conventions: ‘always use interfaces instead of types’, ‘write tests before code’, ‘every PR needs an updated docstring’
• Accumulated learnings: lessons learnt that the agent must take into account

One of the most common mistakes when working with AI is asking it to implement things straight away. Claude Code has a Plan Mode that separates planning from execution.

The agent analyses the codebase, identifies the affected files, proposes an approach with clear steps, and waits for your approval before touching a single line of code. You review, adjust, and only then give the green light.

This is transformative: instead of receiving code you don’t understand, you participate in the architectural decision and then let the agent execute the approved plan.

Claude Code lets you create slash commands, custom commands that define reusable workflows. You save .md files in .claude/commands/ and use them with /command-name.

Now, every time you type /feature Add CSV export endpoint, the agent follows this entire workflow in a structured manner.

The workflow is flexible. Use your common sense:

• Typo correction > Correct directly
• Simple bug > Research ? Implement ? Review
• Medium-sized feature > Discover ? Research ? Plan ? Implement ? Review
• Large feature > All 10 phases
• Emergency > /hotfix (Research ? Fix ? Review ? Deploy compressed)

Context is the most valuable resource when working with AI agents. Some best practices:

• Up to 50% of context used: works freely
• 50–70%: starts paying attention to what you ask
• 70–90%: use /compact to compress the context
• 90%+: you must use /clear and start again

Claude Code has native commands for this. /compact compresses the conversation whilst retaining the essential points, /clear clears everything, and /context shows how much of the window is already occupied.

Whether you’re in a consulting team or a product squad, these practices make all the difference:

Share the CLAUDE.md file in the repository. The whole team benefits from the same conventions, and the bot behaves consistently for everyone.

Use Plan Mode for architectural decisions. Before implementing complex features, review the plan as a team. The bot documents the approach, and the team validates it before execution.

Create slash commands for the team’s workflows. If your process is “branch ? implement ? test ? PR ? code review”, code that into a command. It reduces friction and ensures consistency.

Record learnings in CLAUDE.md. Every sprint, every retrospective, add a line to the file. The agent gets progressively better at your project.

Always review the generated code. Claude Code is a powerful tool, but the responsibility for quality remains yours. Use the agent to accelerate, not to replace human judgement.

The transition from ‘AI chat’ to ‘terminal agent’ fundamentally changes the way you work:

You are no longer a messenger. The agent reads and writes directly to your project.

Context persists. CLAUDE.md ensures that the agent knows how your project works, session after session.

The workflow is reproducible. Slash commands turn processes into automated routines.

Review is about quality, not integration. Instead of spending time pasting code and checking if it fits, you focus on validating the logic and architecture.

The system improves over time. With every /retro, lessons learnt feed into the next features. The agent becomes progressively better calibrated to your project.