Claude Code is Anthropic's agentic development tool, built for the terminal before it was built for an editor: it reads the code, plans a change, edits files, runs commands, and uses git inside a session that keeps going until the task is done, or until the agent stops to ask for confirmation.
In the Italian market, this exact phrase drives close to 50,000 searches a month on its own, more than five times "github copilot" and seven times "cursor ai": the highest volume in this whole niche after the category name itself. Most of what shows up for that search today is official documentation, in English, or generic roundups that stop at "here's how you install it." This piece explains the tool in full, and only in the last stretch gets to the question that coverage skips: what actually stays on disk once the session is over.
What is Claude Code, and what is it for?
Claude Code is Anthropic's agentic software development product. It runs in several places: from the command line in a terminal, inside a separate desktop app, as an extension for VS Code and JetBrains IDEs, or in the browser at claude.ai/code with nothing installed locally. In every one of those surfaces it does the same thing: it reads the project files it needs, understands the structure of the code without you pasting it in by hand, proposes and makes changes across multiple files coherently, runs build and test commands, and uses git to create branches, commits, and pull requests. You use it by describing a goal in plain language, not a technical prompt: "add input validation to the registration form" or "there's a bug where the form submits empty, fix it" are both normal requests. It requires a Claude subscription, Pro, Max, Team, or Enterprise, or an Anthropic Console account with prepaid credit: without one of the two, the tool won't start.
How do you install it, and how does working with it actually look?
On macOS, Linux, and WSL, installation is a single line:
curl -fsSL https://claude.ai/install.sh | bash
On Windows, from PowerShell:
irm https://claude.ai/install.ps1 | iex
brew install --cask claude-code on Homebrew and winget install Anthropic.ClaudeCode on Windows also work. Once installation finishes, claude --version confirms the tool is set up; cd into the project folder and run claude to open the first interactive session, with login happening in the browser on first launch, or by setting an API key directly as an environment variable.
Working with it for real means talking to it the way you'd talk to a colleague who already has the project open: you give it a goal, it explores the code, proposes a plan for a large task, and starts editing files and running commands. On recent versions, the default starting mode for interactive sessions is auto mode: instead of asking you to confirm every single step, a classifier reviews each action and lets most edits and commands go through on their own, pausing only above a risk threshold. You can always switch modes on the fly with a keyboard shortcut, and you can always resume a previous session instead of starting over.
What happens inside a session?
At every launch, Claude Code reads the project's CLAUDE.md file, if one exists: instructions someone wrote once, build commands, conventions, architectural decisions, loaded into every session by anyone working on that repository. It doesn't read the rest of the codebase upfront: it opens files as the task needs them, the way a person would. From there the loop stays the same: read, plan, edit, run, verify, repeat until the task is considered done. Along the way it can also write notes to itself, things learned from your corrections that carry over into the next session on the same project. Everything that happens, every file read, every command run, every output received, passes through the session and ends up, somewhere, written to disk.
What actually stays on disk once the session ends?
Not all of it the same way. The CLAUDE.md file stays exactly where you put it, in the repository: it's yours, you version it with git, it survives indefinitely. Auto memory, the notes Claude writes about itself, lives in a local folder per project and never gets cleaned up as long as it keeps getting used. The full session record, every message, every command, every command result, is written instead to a plain-text log file on the machine that ran the session, unencrypted: useful for picking the work back up the next day, but deleted automatically by default after roughly thirty days, unless you change that setting.
| What | What it holds | Does it survive the session? |
|---|---|---|
| CLAUDE.md | Instructions a person wrote for the project | Yes, it's a repository file, lasts as long as the repo |
| Auto memory | Notes Claude writes about itself across sessions | Yes, per project, until you clear it |
| Session transcript | Every message, command, and result, in plain text | Locally, around 30 days by default, then deleted |
| Signature on what was accepted | — | Doesn't exist: the tool doesn't produce one |
What the table leaves out is the part that matters for work done under contract: that log is built for whoever ran the session, on that one machine, for those thirty days. It isn't built to last, to travel anywhere else, or to tell someone else what was actually authorized.
What does it take, if the code is going to a client?
For personal use, what Claude Code keeps locally is more than enough: you resume the session, you look at what happened yesterday, nothing else is needed. For a software house delivering code to multiple clients, the same stack of files has three limits that turn concrete the moment someone asks about a specific change: it disappears on its own after a month unless someone exports it, it stays on the machine that ran the session instead of following the delivery, and it doesn't export if the team switches tools, the same way it doesn't for Cursor or any other coding agent on the market today. The same holds for Claude Code skills: a shared instruction file changes how the agent works, it doesn't record what it actually did in one specific session.
None of these three limits is a flaw in the tool: Claude Code wasn't built to keep a delivery record, it was built to write code faster, and at that it's very good. The record that survives past thirty days, that follows the delivery instead of the laptop, and that carries a human signature on what was approved, is the layer that has to sit above the agent, whichever agent happened to write the code that week. Detent, the end-to-end delivery system (detent-ai.com), keeps intent, authorized context, execution, and signature together on every delivery: it's exactly the object missing from the last row of the table above.