As we move from traditional coding into agentic coding, there’s a real learning curve. To truly elevate our code quality and get the best outcomes from the agentic experience, we have to change our processes and how we think.
Level 1 - Vibe coding
Level 1 is where we all start, pasting in a request and letting AI build the request, accepting that, as long as it works, that the code is probably Ok.
This can work with small, one line changes, or other very small changes, but at a larger scale, it doesn't work.
The end result is often unwieldy code, code that is hard to understand, often filled with either security issues or bugs.
It's also where we often say "AI wrote that".
Moving away from thinking in those terms is the first level up you can do, stop considering it as AI writing it, and consider it as being written by you with the help of a tool.
Ultimately, you are responsible for the code that AI writes under your watch, and there is never a moment where "but AI wrote it" is an acceptable reason for something being wrong.
Level 2 - Prompting
Prompting is a somewhat misleading level, it feels like a significant upgrade because you're giving AI more to work with, and the results are noticeably better. For small, contained changes, this can genuinely be enough.
But the trap is that AI is still doing the architecting. When you write code by hand, you're always thinking ahead; next steps, missed steps, how this fits into what already exists. Prompting doesn't change that dynamic, it just gives AI more material to work with while it still makes those decisions itself.
The result? Code that's often perfectly valid in isolation, but doesn't fit the task as intended, or doesn't belong in the codebase it's being written into. And because it looks reasonable, it's easy to miss.
Level 3 - Planning
Level 3 is what should be the bare minimum requirement for agentic coding. This is where the developer moves from a bystander to an architect.
Planning the request with AI, actually reading the plan prior to any code being written. Does the plan adhere to existing code standards? Does the plan actually resolve the task? Is AI asking good follow up clarifying questions that help the developer know that AI is on the right track with the task?
The importance of spending time in a planning mode cannot be overstated. It's your guard against poor code, code that doesn't fit the task , missed security measures etc.
During this planning stage, consider if AI is flagging assumptions in order to gain a better understanding of the task, or is it making assumptions and needs a bit of a prod to help it task better questions.
Essentially, you are reviewing the thinking before a line of code is written, which is much easier than trying to code review a large code diff afterwards. Only allowing it to build the code once the plan has been properly vetted and checked and agreed upon.
Level 4 - Full Architect
Level 4 adds onto level 3, but brings processes into play. Adding AI self verification processes after the code has been written, before humans look at the code.
Being more fine grained with the planning, instead of just creating a plan, create a plan that is sliced into small manageable parts (vertical slicing), and sub tasks for AI to check off as it goes through each slice. It gives AI a great reference to build from, there are no longer assumptions, AI will know exactly how to build the task.
Splitting up the build like this allows more incremental code reviews, It's easier to pick up issues in slice 1 , than it is when all 5 slices are complete. Flagging issue early means that the plan can be adjusted before going too far.
Letting AI review its own code before you look at it is a great way to pick up the obvious mistakes without overloading the developer brain along the way, It doesn't replace the human code review, but it helps the human code review.
Aim high
No matter where you are at with your agentic journey, strive for the next level. This is no different than your developer journey, we start out knowing very little, making many mistakes, and aiming to level up your code quality.
With agentic coding, it's the same. We are responsible for the code written, and learning new things in order to provide better , more consistent code is the goal.
It could be by trying to improve planning, or verification stages, or advancing into building custom skills to give you the tooling you need to produce quality code.
Let AI learn from its mistakes
It's very easy to slip back into old ways of coding by hand, that mistake AI made, it's only one line, easy to fix yourself. However, long term, you are not helping yourself by making that change. AI learns from its mistakes, Learnings from mistakes can go into MD files for long term noting of specific issues . They can be written into memories for easy recall.
If the developer fixes the issue themselves by hand, it's a missed opportunity for a learning. By fixing it yourself, short term you save time, its often faster to fix it yourself then it is to let AI fix it, but AI is going to keep on making that mistake until it learns about the mistake and adjusts.
Final thoughts
Negotiating the transition from traditional coding to agentic coding isn't straightforward. The sense of satisfaction you get from writing code by hand goes away, as you transition from a coder to an architect, and this can be a struggle for developers. Working through that transition doesn't happen overnight.
Once you move your thinking from developer to architect, there is a realisation that there are things to be proud of still, it's a different kind of pride, but you will find things to be genuinely excited about in the process.
Being an architect gives you a much wider sense of what's possible when you stop being limited by what you personally know how to write by hand. It becomes more about building solutions to fix specific problems, and seeing the results much earlier than before. Developer skills translate over into other programming languages, and AI processes are much the same no matter what language you are writing in.
Learning AI is a critical part of being a developer in 2026, just like learning CSS, JS, and all the technologies that were not around when we first started coding needed to be learned. By not learning the tools, you end up being left behind.
Top comments (0)