What Is Agentic Coding?
What Is Agentic Coding?
So far, you have mostly used AI in a chat: you ask a question, the AI answers. If you have it write code that way, you copy the code from the chat into a file, try it out, and send the error message back. You are the messenger between the AI and the computer.
With agentic coding, that messenger role disappears. A coding agent works directly in your project folder: it reads files, writes code, runs commands, starts tests, and fixes its own mistakes. You describe what you want and check what comes out.
That sounds like "the AI programs, I lean back". It is not that simple. In this masterclass, you learn how to guide a coding agent so that the result is useful, secure software. The guiding principle for the whole course is:
Three Levels of AI Support
AI can support you with programming in three ways. The boundaries are fluid, but the way you work differs a lot:
How it works: You describe in a chat what you need. The AI delivers code as text. You copy it into a file and test it yourself.
What the AI sees: only what you paste into the chat.
Good for: short scripts, explanations, single formulas.
How it works: The AI is built into a code editor. It suggests the next lines while you type or changes a selected section on request.
What the AI sees: the open file and often a few neighboring files.
Good for: people who program themselves and want to be faster.
How it works: You give a task. The agent finds the files it needs, plans, changes several files, runs commands, and checks the result. It keeps working step by step until it considers the task done or asks you something.
What the AI sees: everything in the project folder that it opens, plus the output of the commands it runs.
Good for: complete features, debugging across several files, small applications from scratch.
For this masterclass, only the third level matters. Well-known coding agents include Claude Code, OpenAI Codex, Gemini CLI, Grok Build, Cursor, and the agent in GitHub Copilot. They differ in operation and price, but work according to the same principles. These principles are what you learn here. How to operate a specific tool is shown in the matching tool course.
How a Coding Agent Works
A coding agent is a language model that is allowed to use tools. Typical tools are:
- Reading files and searching the project
- Creating and changing files
- Running commands, for example starting tests or installing a program
- depending on the tool: searching the web, opening a web page in the browser, accessing external services
With these tools, the agent works in a loop, the agent loop:
- Plan: What is the goal, what is the next sensible step?
- Act: use a tool, for example open a file or start a test.
- Observe: read the result, such as the file content or an error message.
- Evaluate: Have I made progress? Is the goal reached? Do I need to correct something?
Then the loop starts again. A single task can trigger dozens of steps without you intervening.
You write: "The total time of the hike is calculated incorrectly. Find the bug and fix it."
The agent searches the project for the calculation (act), reads the file it found (observe), suspects a bug in the descents (evaluate), starts the tests (act), sees a failing test that confirms its suspicion (observe), changes one line (act), starts the tests again, and all are green. Then it reports: "Bug fixed."
You wrote one message. The agent took eight steps. But you do not yet know whether the fix is really correct. You learn how to check that in the lessons "Verify, Don't Trust" and "Git as a Safety Net".
Your New Role
With agentic coding, you hardly write any code yourself. Your work shifts to four tasks that no agent takes off your hands:
- Client: You decide what gets built and describe it in a way that can be checked.
- Architect: You set the rules: which technology, which style, what is forbidden.
- Supervisor: You decide what the agent may do without asking and where it has to stop.
- Acceptance: You check the result and approve it, or not.
A helpful picture: the agent is an extremely fast, hard-working employee who never gets tired, but sometimes talks nonsense with great confidence. You give such an employee clear tasks and tight limits, and you check the work before it goes to the customer.
What Works Well and What Doesn't
- unclear goals: the agent fills gaps with its own assumptions
- big architecture decisions with consequences for years
- security, payments, personal data
- anything that happens directly in a live system
- long sessions in which the agent loses track
- clearly defined tasks with a checkable result
- prototypes and small internal tools
- routine work: forms, tables, renaming, adding tests
- explaining unfamiliar code and narrowing down bugs
- writing documentation
"Vibe Coding": When It's Enough and When It Isn't
In February 2025, AI researcher Andrej Karpathy (co-founder of OpenAI, formerly head of AI at Tesla) coined the term vibe coding. He used it to describe how he built software by just telling the AI what he wanted, accepting changes without reading them, and simply pasting error messages back. He hardly looked at the code itself anymore. He added that for throwaway weekend projects, this was not too bad.
The term has spread, often without this limitation. For you, the distinction matters:
A website with a contact form, a tool with customer data, anything with payments or login, anything other people use. Here you must know what you are delivering.
A throwaway prototype to test an idea. A game for yourself. A demo without real data. If it breaks, nothing is lost.
Agentic coding as you learn it here is the opposite of blind acceptance: you use the agent's speed but keep control over goal, rules, and result.
What Awaits You in This Masterclass
The 12 lessons follow the flow of a real project:
- Prepare: workspace, good tasks, context and project rules (lessons 2–4)
- Implement: plan, develop step by step, work with existing code (lessons 5–7)
- Secure: verify, Git as a safety net, security and permissions (lessons 8–10)
- Move forward: reusable workflows, from prototype to production (lessons 11–12)
From lesson 2 on, you work with a small practice project, the Hike Planner, a planner for hikes. For this you need a coding agent of your choice. Most providers require a paid subscription. How to set up your tool is shown in the matching tool course.
Before you start with the tool, think about your own work. Write down three things you would like to build or improve with a coding agent, for example a form, an analysis of Excel data, or a small internal tool.
Classify each of them:
- Is it a prototype (just for you, throwaway) or something productive (others use it, real data)?
- What data does it process? Does it include personal data or business secrets?
- How would you notice that it works correctly?
Keep the list. It will become your final project in lesson 12.
- A coding agent reads, writes, and tests code on its own in your project folder, in a loop of planning, acting, observing, and evaluating.
- Your role: client, architect, supervisor, and acceptance. The agent writes the code; you remain responsible.
- Agents are strong at clear, checkable tasks and weak at unclear goals, security, and live systems.
- Perceived speed is deceptive. Check results, not impressions.
- Vibe coding is enough for throwaway prototypes, not for software other people use.
This lesson is part of a course with final exam and certificate. View the course "Agentic Coding"