01 — What Is Claude Code? — An Agent That Lives in the Terminal

"Autocomplete but bigger" was how I first understood Claude Code, and the phrase hid the actual mechanism. The model that held: Claude Code is a large language model put inside a loop, with tools that can touch my real files and shell. [1] Once I could see the loop, "AI coding tool" stopped being a vague category and became a specific shape with specific failure modes.

The framing that clicked is the contrast with autocomplete. The suggestions I get while typing in an editor predict the next few tokens from the lines above. They never run, never read a second file, never recover from their own mistakes. Claude Code is a different artifact entirely: it sits in my terminal, holds a goal across many rounds, calls tools to act on the project, and only stops when the goal is met or I tell it to [1][2]. The jump is not "smarter text" — it's agency, the ability to act and observe the result before deciding the next step.

Vibe coding: the cultural frame, not the technology

The roadmap leads with a term that's worth pinning down because it gets thrown around loosely: vibe coding. Coined by Andrej Karpathy, it's a style of development where the human writes natural-language prompts and an AI agent generates, builds, and iterates the application — the focus is the overall intent (the "vibe"), often with rapid prototyping and minimal manual line-editing [3].

I keep this separate from "what Claude Code is" because they answer different questions. Vibe coding is a workflow humans adopt; Claude Code is a tool that enables it. You can use the tool without vibe coding (I do — most of my sessions are careful, review-heavy edits), and you can vibe code with other tools. Conflating them is how people end up disappointed: they expect the tool to magically produce a working app from a vague prompt, when what it actually does is run an agentic loop whose quality depends entirely on how precisely I steer each turn.

A coding agent, not a chatbot

The next rung of clarity was seeing Claude Code as a coding agent — an AI entity designed to autonomously write, test, and debug code to solve a task [4]. "Autonomously" is the load-bearing word, and I had to be careful with it. It doesn't mean "unsupervised." It means: within a turn, the agent decides its own sequence of actions — which files to read, which commands to run, which edits to make — instead of waiting for me to spell out each one.

The difference shows up the moment I issue a prompt. A chat assistant would describe what to do ("you should open lib/auth.ts, check the token refresh logic, and…"). An agent does it: it reads the file, runs the typechecker, sees the error, edits, re-runs. I stop being the relay between thought and action. That's the qualitative change, and it's also where the new risks live — because the agent's mistakes are no longer text on a screen, they're actions in my actual repository [4].

The agentic loop: the one shape to remember

Everything above reduces to one mechanism: the agentic loop [5]. The agent continuously cycles through perception, planning, and action. It observes its surroundings (the goal, plus whatever the last tool returned), decides on a course of action based on its goals and current state, executes that action, and then observes the results to inform the next decision. This iterative process is what lets it adapt when a command fails or a file looks different than expected.

The reason this matters: acting changes the world the model sees next. A chat answer is frozen the moment it's written. In the loop, the round-three answer can be shaped by what a tool returned in round two — a real error, a real file's contents, a real test failure. The model isn't predicting in a vacuum; it's reacting to ground truth it just produced [5].

Setting it up

The mechanics are deliberately boring — that's a feature. One install command, one login, and it runs [6]. On macOS, Linux, or WSL:

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

Windows users run the PowerShell equivalent (irm https://claude.ai/install.ps1 | iex). Then I cd into any project and type claude. The first launch triggers a one-time login — either a Claude account (Pro/Max subscription) or an Anthropic Console API key. After that, the tool is ready immediately [6]. There's no separate plugin to install in my editor unless I want the IDE integration; the terminal is the canonical surface.

How I use this

The habit these notes left me with is a single check before I open a session: does this task need a loop, or a turn? If the next step depends on the result of the last — read the error, fix it, re-run — the agent earns its keep. If it's a one-shot explanation, plain chat is cheaper and safer. Seeing Claude Code as a loop with hands (not a smarter autocomplete, not a magic app-generator) is what made my sessions predictable: I steer the loop, I scope the tools, I watch the actions, and I stop it when it drifts.

References

[1] Anthropic, "Claude Code overview," Claude Code Docs, 2025. [Online]. Available: https://code.claude.com/docs/en/overview

[2] Anthropic, "How Claude Code works," Claude Code Docs, 2025. [Online]. Available: https://code.claude.com/docs/en/how-claude-code-works

[3] IBM, "What is vibe coding?," IBM Think Topics, 2025. [Online]. Available: https://www.ibm.com/think/topics/vibe-coding

[4] IBM, "What are AI agents?," IBM Think Topics, 2024. [Online]. Available: https://www.ibm.com/think/topics/ai-agents

[5] Hugging Face, "What is an Agent Loop?," Agents Course, 2025. [Online]. Available: https://huggingface.co/learn/agents-course/en/unit1/agent-steps-and-structure

[6] Anthropic, "Getting started with Claude Code," Claude Code Docs, 2025. [Online]. Available: https://code.claude.com/docs/en/quickstart