AI is your employee. Be the better boss.

Yes, the paradigm has changed, is undeniable. Programming doesn’t look anything like what it used to five years ago, let alone ten or twenty. AI tools are everywhere: from our command line to the cloud. And they’re meant to be used.

But you need to know how to use them.

I know this isn’t news to you, but bear with me. The real challenge, and the people who will win this race, are those who learn how to use AI efficiently and responsibly. You don’t want to be the person who doesn’t understand what AI is generating.

Why? Simple: bugs will flow, and things will spiral out of control very quickly.

So how do you stay in control and remain the captain of the ship? Here’s the four-step workflow that’s been working for me.

This is simple: you still need to be a programmer. You still need to do your job.

If you don’t understand how something works, don’t expect AI to guide you safely through it. It’s no secret that a single prompt to modern LLMs can generate hundreds, or even thousands, of lines of code. That’s powerful, and it’s part of why we use these tools.

But you must understand what the model is giving you.

The criteria you use to judge AI-generated code is, at the end of the day, the new value proposition developers bring. Without that judgment, AI would most definitely replace our jobs.

The good news is that AI is also very good at teaching new concepts and technologies. Still, nothing beats going to the source. Direct documentation from the tech stack you’re using is one of your most valuable resources.

Use it.

Most people know how to prompt an AI. Very few know how to do it well.

Here are a few principles I rely on.

Nowadays, most AI agents allow you to define files, folders, or rules that are sent to the model with every prompt. These are incredibly powerful tools, and when used correctly, they dramatically improve results.

I like to break this setup into three parts:

These are the basics you should provide before asking the model to generate code.

Rules are constraints the model must follow. For example:

If your team follows specific style guides or architectural rules, this is where they belong.

Context is what the model needs to know about your codebase:

Include project structure, key files, and architectural decisions. The better the model understands your environment, the better its output will be.

Tools are scripts or commands the model can use to verify its work. One of my favorites is bundling all common checks into a single script, for example, tests:ai, which runs linting, unit tests, and TypeScript checks.

This allows the model to test its own output, iterate, and fix issues until everything passes.

I don’t have much advice here beyond the basics: be clear, concise, and specific.

The more precise you are about what you want, the better the results will be. Examples help a lot. And if you’ve set up rules, context, and tools properly, you’re already giving the model most of what it needs to succeed.

If you give AI the tools to test, make sure it actually uses them.

In every prompt, explicitly require the model to run the tests after generating code. A simple instruction like:

“Run the tests after generating the code and fix any failures.”

goes a long way.

This step alone dramatically improves quality. I can’t stress enough how much better the results are when the model is forced to validate its own work on every iteration.

If you understand the fundamentals, you can review results. This step is straightforward, but it’s also critical and unskippable.

You cannot blindly trust AI output. Even with great prompts and strong models, AI still hallucinates or takes shortcuts, which can introduce bad practices or long-term maintenance issues.

Use review tools aggressively. Open pull requests, inspect diffs, and read every line. Make sure you understand the decisions the AI made and why they make sense.

You can even use other AI tools to help with reviews, they often catch issues you might miss. But remember: more eyes help, and you’re still responsible for the final result.

You still need to do your job.

If you’re working on a new feature or refactor and the AI completely derails from what you want, don’t be afraid to delete everything.

Code is cheap now. You can always generate it again.

What matters is the outcome, not how you got there. If the model isn’t cooperating, start over. Change the prompt. Add more context. Adjust the rules.

Sometimes that’s faster, and cleaner, than trying to force the AI to fix code it already fixated on.

AI can be stubborn like that.

AI doesn’t replace developers who understand their craft. It replaces developers who surrender control.

Stay critical. Stay in charge.