What Agentic Coding Actually Means

Prologue · Series: Agentic Coding with Claude Code

Anyone reading tech newsletters, conference keynotes, and tool landing pages this year runs into two terms sold with identical promises: Vibe Coding and Agentic Coding. The future of programming, they say. Natural language instead of code. The developer as conductor, articulating intent while the model handles the details. Ten-times productivity, lower barriers to entry, the end of laborious craft.

What stands out: whether you read a Cursor tweet, watch a Claude Code demo clip, or follow a conference keynote on “AI-driven development” — the impression stays the same. All of this is one movement, one trend, essentially one thing. Different logos, similar message. The terms travel through the same texts, get named in the same breath, and nobody seems to think it worth distinguishing them.

This series does that — not out of pedantry, but because the difference has practical consequences. Anyone who treats Vibe Coding and Agentic Coding as the same thing will hit a wall on certain projects and only then understand why. I show, through a concrete project, what Agentic Coding with Claude Code actually looks like: with a workflow, clear tools, and the discipline required to end up with a codebase you can still touch three months later. The test case is byhaushalt — an interactive web application for the Bavarian state budget 2026/27, with code openly available on Codeberg.

What Vibe Coding Is — and Why It Falls Short

Andrej Karpathy coined the term in February 2025. The developer opens a chat window, types a wish, takes whatever the model delivers, types the next wish. No spec, no tests, no thought about architecture. The work feels productive — and for an evening it is. For anything that lives longer than a weekend, the real problem then begins.

Vibe Coding is not a bad intention. It is a natural reaction to tools that suddenly produce usable code from simple requests. The problem is structural: code grows. Requirements change. Whoever writes without discipline today debugs without context tomorrow. That holds for humans, and it holds just as much for AI agents working in codebases.

What Agentic Coding Is

If Agentic Coding is not Vibe Coding and not a replacement for developing — then the positive answer is: it is software development with clearly distributed roles between human and tool. The human provides the spec, makes decisions, and reviews results. The agent executes, verifies, corrects, and reports back. Neither does the agent take control, nor does the human type every line themselves. The space in between is the point.

In practice the workflow looks like this: we write a spec — what is to be built, what counts as success, what constraints apply. This can emerge directly as a CLAUDE.md or as a plan the agent elaborates in Plan Mode and which we then review and approve. The agent then implements: it reads files, writes code, runs commands, runs tests. After each relevant step comes verification — tests must be green, lint must not complain, type checks must pass. If something fails, the agent corrects itself or asks. Only when everything fits does it move to the next task. We intervene where decisions are made — not where typing happens.

What distinguishes this workflow from an ordinary LLM session is not the strength of the model but the discipline of the structure. Hooks that enforce tests before code is committed. Spec files that make explicit what success means — so the agent executes rather than interprets. Subagents that take on subtasks without flooding the main context. Worktrees that allow parallel experiments without endangering the current state. No single one of these tools is decisive — together they turn a session into a traceable, reproducible process that is still readable days later.

For byhaushalt that means concretely: the spec describes what is to be extracted from the budget data. The agent builds the parser, tests verify sum consistency against the overall budget, and Hooks prevent untested code from reaching the branch. Every step is traceable in Git and in the build log.

One final point that matters to us: no Agentic Coding workflow needs to be complete on day one. What counts is that the discipline is anchored in tools rather than in willpower. Willpower alone can only be relied on until it cannot. Whoever sets up Hooks and writes tests has the discipline automatically — even on a bad day.

What Agentic Coding Is Not

Before we get into the tools, a clarification: Agentic Coding does not replace developing. Whoever cannot read and assess Python, TypeScript, or Bash themselves can neither steer the agent meaningfully nor check its results. The agent is a faster coder and a more thorough reviewer than the human — but it is not a substitute for someone who understands what is being written. Whoever starts without that foundation builds trust on output they cannot evaluate. That is precisely the trap many fall into, lured by the sweeping promises of marketing departments.

What Sets an Agent Apart from a Chatbot

A language model that only responds to prompts is a text generator. An agent only emerges when three things come together.

The first is tool use: the model calls functions instead of just writing text. It reads files, runs terminal commands, searches documentation. It does not write about code — it interacts with a real environment.

The second is the loop: after each tool result, the model decides what comes next. It reads the output of a command, evaluates it, chooses the next step. No one-shot prompt that prescribes a complete plan — but a loop that orients itself on results.

The third is verification: the system checks whether the result is correct. Tests fail or pass. A lint run reports errors or does not. Without verification every loop stays blind — the agent cannot distinguish whether it is making progress or going in circles.

Vibe Coding is essentially tool use without a loop and without verification. The human takes the output manually — in the browser, in the editor — and if they do not look carefully, they take the errors along with it.

Spec-First, Not Prompt-First

The decisive step before any agent run is a spec. Not in the sense of a twenty-page requirements document — but a concise, precise description of what is to be built, what constraints apply, what assumptions are made explicit. Claude Code has a dedicated mode for this: Plan Mode only plans, writes no code. The agent drafts an architecture, proposes file paths, names dependencies — and the human decides before a single line is written.

This is not a formality. Whoever sends the agent off directly gets a solution to the problem as the model understood it. That is not always the problem as it was meant.

The second pillar is CLAUDE.md files: Markdown files in the repo that the agent reads automatically at startup. You write into them what the agent needs to know — project structure, conventions, which commands exist, what it should not touch. The model has no memory across sessions; CLAUDE.md is the memory the human writes. Without this file you explain to the agent at every run from scratch how the project is structured.

What This Series Covers

The ten main articles follow an arc from the first project setup to a production deploy. We show how to write a CLAUDE.md that actually steers the agent — not just reassures it. We show how Hooks work: shell scripts tied to specific events in the agent loop that automatically trigger validation, formatting, or tests. We show how to deploy Subagents for bounded subtasks and how Git Worktrees help keep parallel experiments clean.

Added to that are Slash Commands and Skills — reusable workflows the agent executes on demand — as well as MCP, the Model Context Protocol, which connects the agent to external services. Each of these tools is introduced in the context of a real problem: with the configuration we actually used, with the errors that came up, and with the code that came out at the end.

What the series does not show: how to write code. Claude Code already assumes that. What it shows is how to set up an agent so that it works reliably in a growing codebase — not just on the first run.

byhaushalt as Test Case

In 2015 I already visualized the Bavarian state budgets 2012-2016 — as an open data project for the Bavarian Piratenpartei, with the data subsequently handed over to openspending.org. Ten years later you open the Free State’s website: the budget 2026/27 appears — as it did back then — as a PDF. No API, no machine-readable table, no open data structure. Whoever wants to work with the numbers starts from zero.

2015 and Today

What has changed is not the Free State’s willingness — that has stayed at exactly zero. What has changed is the effort on my side.

In 2015, PDF parsing was a RegEx battle: table rows wrapping across pages, column headers shifting slightly from chapter to chapter, thousands of budget line items in slightly different formats depending on department and print template. I wrote heuristics, checked column widths, cursed missing Unicode characters, and in the end had a CSV file that still had to be validated by hand — simply because there were arithmetic errors in Söder’s budget. That was the state of the tools back then.

Today a language model can take over that part — not because it has fundamentally solved the problem, but because it can fold extraction, validation, and error correction into a loop that orients itself on real results. But only if you use it correctly. Whoever feeds a model a PDF file and pastes the output directly into the application gets Vibe Coding: it looks like progress, and it is — for an hour. After that the cleanup begins.

The project byhaushalt — an interactive web application that makes the Bavarian state budget 2026/27 (draft) navigable. No map application, no gamified citizen app: a direct visualization of the budget data, with filtering by individual plans, chapters, and titles, and with the ability to look up amounts and changes compared to the previous year.

The code is public, all steps are documented, and whoever wants to clone the project and run it locally should be able to do so without having to ask. That was the goal in 2015 as well — with a different infrastructure back then and without the tools we have today.

Agentic Coding shifts the work; it does not replace it. The human designs, reviews, decides. The agent types, executes, iterates. Whoever inverts that — whoever lets the agent design and executes themselves — has Vibe Coding with more steps in between. The difference does not lie in the tool; it lies in the discipline.

In the next article we write CLAUDE.md for byhaushalt — the first memory file that pins down what Claude Code has to follow.