What is agentic coding? A practical guide for developers

Agentic coding is a way of building software where an AI agent plans the work, edits code, runs tools, and checks its own results. You set the goal, supply the context, and verify the outcome. Claude Code, Codex, and Cursor’s agent mode all work this way.

The shift sounds small, but it changes your daily work. You write less code by hand and spend more time on instructions, context, and review. In this article, I explain what agentic coding is, how it differs from chatting with an AI, and which fundamentals keep working when the tools change.

How is agentic coding different from using a chat assistant?

An autocomplete tool suggests the next line and waits. A chat assistant answers a question and waits. An agent keeps going: it reads files, runs a command, looks at the output, and decides on the next step until it thinks the task is done.

In a chat, you copy context in and copy code out. With an agent, it gathers its own context and applies its own changes. That makes it faster, but it also moves the risk. You no longer see every line while it is written, so the quality of the result depends on what the agent reads, what it is told, and how its work is checked.

What are the three fundamentals of agentic coding?

Tools and models change every few months. These three parts keep applying, whichever agent you use:

1. Context.
   What the agent can see while it works. Too little and it guesses. Too much and it gets slower, more expensive, and less accurate. Read more in context engineering for coding agents.
2. Instructions.
   What the agent is told to do and not to do, usually in a file like AGENTS.md. Instructions are suggestions unless something enforces them. See how to write an AGENTS.md.
3. Validation loops.
   Automated checks that tell you and the agent whether the result is correct. See validation loops for agent-written code.

Once your work gets bigger, a fourth topic shows up: using several agents together. I cover that in subagent orchestration.

Why do the fundamentals matter more than the tool?

Tool-specific advice expires quickly, because settings and features change with every release. The fundamentals describe how an agent works, not which product you use. That is why they transfer when you switch tools.

They also explain where your money goes. I analyzed 1,674 of my own agent sessions, and 94.2% of all tokens were cache reads. That is old context re-sent on every call. Only 0.6% of the tokens were the agent’s actual replies. So guarding what the agent reads matters far more than asking for shorter answers. You can find the full numbers in my token usage analysis on SwiftLee.

What do you still own as a developer?

You still own the judgment. You decide what to build, you review what ships, and you are responsible for risk and tech debt. The agent writes the code, but that does not make it accountable for the result.

I noticed that reviewing agent code feels exactly like reviewing the pull requests of colleagues back at WeTransfer. The same rule applies. When I leave the same comment two or three times, I stop commenting and turn it into a lint rule or a formatting config. I would also rather spend more time reviewing the plan before the agent executes it than reviewing all the code afterwards. Preventing a mistake is a lot cheaper than correcting it.

Conclusion

Agentic coding means you work with an agent that plans, builds, and checks, while you stay in control of the context, the instructions, and the validation. The tools will keep changing, but those three fundamentals will not.

A good first step is the free token cleanup prompt. It has your agent analyze its own recent sessions and shows where your tokens go. If you want the whole system in one clear order, join the waitlist for the AI Fundamentals course. Feel free to contact me or tweet me on Twitter if you have any additional tips or feedback.

Thanks!