top of page

How to Become a Good AI Developer: Stay in the Driver’s Seat Instead of Being a Passenger — Principles You Need to Know

vor 2 Tagen
8 Min. Lesezeit

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:

  1. Start with a plan, not with a prompt

  2. Write down the big picture: custom instructions as standing orders

  3. Shrink the blast radius

  4. Stay in the loop

  5. 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:

Prompt: Add team management to the Kaderblick app
Prompt without plan and context

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.)

Kaderblick.md specification for team management
Specification for Kaderblick App

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.

Diagram: your plan and architecture shape the custom instructions file, which governs your prompts and the AI output
Adapted from aitechnologysimplified (2026)

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.

.claude/rules/fastify.md rule file
Example rule for persistent context

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.

One big prompt versus small, verified steps: a wrong assumption either spreads through all six parts or is caught at the first review
Illustrative: What are compounding errors?

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.

Line chart: chance that all steps are right versus number of dependent steps, for 99%, 95% and 90% accuracy per step
Illustrative: Resulting Effect based on Accuracy per Step and Number of Dependent Steps

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:

players.feature: Players may share a shirt number
A test that turns an implicit rule into an explicit one

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.

Painting of King Gustav III of Sweden and his brothers studying a plan
King Gustav III of Sweden and his Brothers, Alexander Roslin, 1771. Oil on canvas, 162 × 203 cm. Nationalmuseum, Stockholm.

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


Schreibt mir, ich freue mich auf euer Feedback

Vielen Dank für das Einreichen!

© 2025 me.kirchnerd.de. Erstellt mit Wix.com

bottom of page