How to Become a Good AI Developer: Stay in the Driver’s Seat Instead of Being a Passenger — Principles You Need to Know
Over the past two years, my job as a software developer has changed dramatically. What used to be the essential skill of a good human developer is now something machines can do: writing code.
Yet many developers confuse the most mechanical part of our work with what our job is really about: making well-informed decisions based on a solid understanding of the problem domain, while incorporating our technical expertise (Renegade Bit, 2026).
In the AI era, I see many developers struggling with this shift. Some fight it in vain. Others go the opposite way and hand over the wheel entirely, letting AI drive while they sit in the passenger seat. Neither is inevitable. Staying in the driver’s seat is a choice, and I’d argue it’s our responsibility.
Don’t be a vibe coder who generates code without understanding how it’s structured or why it works. That is what makes a developer replaceable. What makes you valuable is staying in control of every line that ends up in your codebase, no matter who or what wrote it (Knight, 2025).
Developers vs. Vibe Coders
Software developers design computer applications and programs; programmers turn those designs into instructions a computer can execute (U.S. Bureau of Labor Statistics [BLS], 2026a, 2026b). Much of a programmer’s traditional work can increasingly be handled by AI, as it deals largely with what Brooks (1987) called the accidental difficulties of software development. What we still need are people who systematically plan and design applications, drawing on a deep understanding of the problem domain (Renegade Bit, 2026), its customers, edge cases, team decisions (Zhang, 2026), and target environments, in other words, the essential difficulties (Brooks, 1987). In the end, these people must define the requirements and make the decisions, and they bear responsibility for them.
Vibe coders do the opposite. They skip the plan and prompt whatever comes to mind. They don’t read the code line by line, don’t verify what the AI produces, and have no grip on the architecture. That’s fine for a weekend project, but not for professional software. Don’t let the hammer decide where the nails are going.
5 Principles That Keep You in Control
Here are the principles that matter most:
Start with a plan, not with a prompt
Write down the big picture: custom instructions as standing orders
Shrink the blast radius
Stay in the loop
Decide the architecture yourself
Start with a plan, not with a prompt
I often see vague requirements being fed to AI models without any plan behind them. If you don’t know exactly what to build, AI will simply help you build the wrong thing faster.
It also makes it harder for you as a developer to judge the AI’s output (aitechnologysimplified, 2026). If you aren’t clear about which requirements need to be implemented, or how edge cases and errors should be handled, it may be too early to prompt your AI model of choice (Zhang, 2026). This way of working can become expensive in two ways: token usage goes up because wrong assumptions have to be fixed iteratively afterwards (Knight, 2025), and hard-to-find bugs can creep into your software, which then require time-consuming debugging (Zhang, 2026).
When prompts aren’t specific enough, the AI has to make assumptions, and those won’t always match your expectations, assuming you have any. After all, the AI doesn’t know your users, the edge cases in your product environment, or the development patterns your team has agreed on. It fills the gaps in your requirements with the most conventional assumptions (Zhang, 2026). If they go unnoticed, those assumptions can become costly for your company later on.
“AI rewards clever thinking more than clever prompting.” (Zhang, 2026)
That’s why it is so important to make a plan up front. Think through the requirements yourself first: How do the changes affect your data models? Which software components and services are affected? Then give the AI a clearly defined scope to work within.
Say you want to add team management to Kaderblick, a hobby project of mine for tracking the performance of soccer players. A prompt like this won’t get you far:

Instead, write a specification first and point the AI to it in your prompt. (We’ll look at how to make this context permanent in the next section.)

And then reference the written specification.

If you’re wondering how best to structure your prompts, I’m afraid I have to disappoint you: there is no one-size-fits-all recipe. That said, the following template adapted from Knight (2025) might be a helpful starting point.
Implement (function/class/endpoint) to (goal) using (lib/framework).
Work in (files/paths) only.
Respect (style/tests/rules).
Provide (tests/docs/migration).
If assumptions are needed, list them first.Write down the big picture: custom instructions as standing orders
Almost every AI coding tool lets you define persistent context (memory) that carries over across sessions, in addition to the volatile, temporary context (working memory). The working memory only lasts as long as the context window stays open, i.e., until the session ends.
To set up persistent memory, you use files such as AGENTS.md, CLAUDE.md, or rule files (in .claude/rules/). In these files, you describe the project’s constraints and decisions in natural language to give the AI a sense of the big picture. Keep in mind that these files are not static: you should keep updating them as the project evolves, especially when you notice that earlier decisions lead to unwanted results in the generated code.

As a software developer, your plan consists of fundamental decisions about the architecture (e.g., programming language, frameworks, data models, folder structure), hardware, user journeys, API versioning, coding guidelines, design patterns, business rules, invariants, and much more. These decisions should be recorded globally or per project, and they form the context the AI works with (aitechnologysimplified, 2026).
When you then write a prompt to implement a feature, the AI takes this context into account. When prompting, make sure the feature’s business rules and invariants are either described precisely in the prompt or stored in the AI’s long-term memory, depending on whether they are needed across different contexts. An invariant that only exists in one context window won’t automatically be considered for features implemented in another. This is how subtle bugs and inaccuracies creep into the implementation.

Tip: Let your AI tool help you create rules and instructions.
Shrink the blast radius
When working with AI, it is especially important to keep each step small. AI is an amplifier in every respect: it can massively amplify the strengths of a well-functioning organization, but just as much its dysfunctions.
“Give it [AI] a vision and it builds it faster. Give it emptiness, and it will build emptiness faster.” (Renegade Bit, 2026, 11:15)
Because of this amplifying effect, the error surface can grow rapidly. This is what is meant by the blast radius. Every wrong assumption or overlooked mistake in the early steps multiplies across a chain of steps, calculations, or automated processes (Zhang, 2026).
The figure below illustrates the problem. If you let AI agents work through large chunks of work in one go, a single wrong assumption can shape the agent’s next decision, then the one after that, and every decision that builds on that decision. In the end, the wrong assumption runs through the entire work package, and you face extensive rework, or worse, the errors only surface in production at the customer’s site.

The less carefully individual steps are checked, the worse the consequences can be. If you catch 95% of the mistakes in each step instead of 99%, the overall correctness of a 20-step work package drops from roughly 82% to 36%. That is a massive difference. The best way to prevent this is to work in small increments, read and review the output, and invest in testing and QA.

Stay in the loop
The previous section should have made it clear why you, as a developer, are still needed in the development cycle. To keep the blast radius small, you need to stay actively involved in the feedback loop (Zhang, 2026). In practice, this means reading every diff before you accept it, asking the AI to explain changes you don’t fully understand, and committing in small, reviewable steps.
It also pays off to shift testing left (Knight, 2026). In other words, you specify the feature test-first: you write the tests and then let the AI implement the code until they turn green. Each test is a form of specification (specification by example) and also makes it easier to verify the generated code afterwards. The goal is to build the right product (Adzic, 2011, p. 5) in smaller chunks. Small chunks mean small mistakes and small mistakes are easier to catch (aitechnologysimplified, 2026).
Watch out for one trap: when an AI agent can’t get a test to pass, it may quietly change the test instead of the code. The tests are your specification, so any change to them needs your approval.
AI models handle tests written in natural language very well. Unfortunately, natural language is often ambiguous. Acceptance criteria expressed as tests remove much of that ambiguity and lead to better output from AI models. Another benefit is that these test cases can be automated: the AI writes the glue code and the implementation, while the specification comes from a human. The specification also serves as context for the AI and can be taken into account when implementing further features. If a regression occurs, the AI can see it and fix it.
Here’s an example from Kaderblick:

Without this test, the AI would most likely assume that shirt numbers must be unique, the conventional rule in most football apps, and add a validation that rejects duplicates. In Kaderblick, however, players can share a number, because youth teams often share kits. The test turns an implicit assumption into an explicit rule that no prompt can accidentally override.
Decide the architecture yourself
The last principle, but perhaps the most important one: preserve and protect your architectural judgment. You are the architect; the AI is merely the builder (Zhang, 2026). What ultimately keeps you behind the wheel and out of the passenger seat is that you continue to define and shape the business logic, data models, API contracts, frameworks, and much more. Don’t hand over full control to the AI here. Owning these decisions makes it easier to really understand the generated code, debug your applications quickly when something goes wrong, pinpoint errors fast, and assess their risk.
Architecture is king.

Conclusion
AI hasn’t made software developers obsolete. It has made the parts of our job that were always the hardest more important than ever: understanding the problem, making decisions, and owning their consequences. Writing code was never the real job. It was just the most visible part of it.
The five principles in this article all come down to the same idea. You plan before you prompt, so the AI knows where to go. You write down the big picture, so it doesn’t have to guess. You keep each step small, so a wrong turn costs minutes rather than days. You stay in the loop, so nothing ends up in your codebase that you don’t understand. And you keep the architecture in your own hands, because that is what lets you steer at all.
None of this means using AI less. It means using it deliberately. The developers who will thrive are not the ones who type the fastest prompts, but the ones who still know where they are going.
Sources
Adzic, G. (2011). Specification by example: How successful teams deliver the right software. Manning.
aitechnologysimplified. (2026, May 13). How to control AI when coding — 10 tips [Video]. YouTube. https://www.youtube.com/watch?v=K4Hz-NSai4g
Brooks, F. P., Jr. (1987). No silver bullet: Essence and accidents of software engineering. Computer, 20(4), 10–19. https://doi.org/10.1109/MC.1987.1663532
Knight, F. [ForrestKnight]. (2025, October 15). Everything you need to know about coding with AI // NOT vibe coding [Video]. YouTube. https://www.youtube.com/watch?v=5fhcklZe-qE
Knight, F. [ForrestKnight]. (2026, November 9). I looked into how devs are actually using AI [Video]. YouTube. https://www.youtube.com/watch?v=qCheZDyFX2U
Renegade Bit. (2026, November 10). The art of programming isn’t dead [Video]. YouTube. https://www.youtube.com/watch?v=jZeI0tM_HfI
U.S. Bureau of Labor Statistics. (2026a, August 27). Computer programmers. In Occupational outlook handbook. U.S. Department of Labor. https://www.bls.gov/ooh/computer-and-information-technology/computer-programmers.htm
U.S. Bureau of Labor Statistics. (2026b, August 27). Software developers, quality assurance analysts, and testers. In Occupational outlook handbook. U.S. Department of Labor. https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm
Zhang, M. [Maddy Zhang]. (2026, June 30). How I use AI as a senior software engineer and 5 principles of AI explained in 10 minutes [Video]. YouTube. https://www.youtube.com/watch?v=wQ46lax_ya0
Originally published on Medium.









Kommentare