Training Engineers for AI Without Turning Them into Prompt Monkeys

So, let's start with something very, very important nowadays and I believe it's exactly that, how we should train our engineers for AI without turning them into really prompt monkeys. This talk is basically something which I experienced by my first hand because I needed to implement AI in more than 300 people in our company. I understand that usually it's very hard to train people to use AI in a proper way, just because AI can make engineers really capable, but also it's not meaning they are not dependent in the end of AI.

As much as possible they use AI, they rely on it, and also it's hard to convince them that the way they're using AI is wrong. So, I prepared for you some different things and techniques which I use in my job basically to be able to teach my people to use AI in a proper way. And here's the agenda today, a little bit more information about me and we'll go to some problems which I hit when I try to implement AI. Also, we'll talk about something which I believe is more and more important nowadays and that is dry principle.

And later on, we'll see some rules and standards implementing AI and training people. And we'll continue with key takeaways and of course Q&A session, where you can ask whatever you want about implementing AI in your teams. So, about me, I'm a Docker captain, cursor ambassador, speaker, book author, and person with a lot of experience in tech. My role is principal. As a principal, I need to implement the whole AI system in our company, but also how we use AI. It's not just tools. It's not just you can use cursor, for example, or code, and that is enough. But also how to use the tool in a proper way.

And we are sure that if we join a new member in our team, the code quality will remain absolutely good and also we'll try to teach him to use the same standards. So, this is the big, big problem. Many, many companies nowadays try to basically teach people how to write good prompts, but not how to think and write good code with AI.

So, what we expect nowadays, just because AI is very good and models are really strong nowadays, what we see is basically fast output. It's meaning I can type anything in the terminal of the code editor and this execution with some AI will be really fast. But also it's meaning, do I understand the whole code which AI generated? AI can generate a ton, a massive code in seconds. But later on, many developers are lazy. They don't review this code. They are not interested in a way to understand the whole code base.

But rather than that, they are just interested to finish their tasks. Which is leading to a fragile system. So, the code itself is already built, it's there. Someone decided to push it and it's already in our code system. But we don't know exactly what this code is doing. The developer itself, later on, will try usually what they do and love to do, is saying AI is the problem. It was AI. The ownership nowadays is a very strange thing.

Usually my developers really complain that AI is shit, AI can do good code. But also, if some security issues happen, they don't say it's my fault, I will try to fix it immediately. They are saying that AI is not good enough. But I believe, strongly believe that the AI is not a problem. The person behind the AI is the problem.

What we need to do is basically try to teach our developers some principles and rules. First principle, which I believe is more and more important nowadays in the era of AI, is DRY. So don't repeat yourself. What is happening is if you ask AI to create some task, usually we'll start and directly create the task and implement the similar functions, the similar utilities, and we'll duplicate pretty much everything just because you never told the AI to scan your code base or to try to reuse something which you already have.

So in the end, we have a lot of duplications in the code. My personal experience is that I review one code, like a project, and unfortunately I find five places doing the same exact thing. It was utility, the utility was duplicated in five places, and later on, we have an issue which we need to fix exactly in this utility. And unfortunately, the developer fixed it in only one place. So the issues remain. And I was asking him, OK, why is the reason you're using five utility functions for a similar thing? Why you don't reuse one? Why you don't use the DRY principle?

I was asking AI to do the job, but in the end I realized that it's very good on repeating the code rather than to reusing the code. Unfortunately or not, what usually engineers need to do in working with AI is basically a few things. Many developers do this first thing. They paste some prompt, get the result, and put it in the code. Nowadays, editors like cursor or quote can understand your context well, but if you don't validate what is generated or use one mode, the output will be subpar. So, you need to consider your system as a whole to understand it.

Personally, I scan the entire application with AI. If something seems unclear, I ask AI to explain why it was implemented that way. When I notice duplications, I optimize them using utilities, hooks, and different methods to adhere to the principles shown earlier. AI is powerful, but blindly telling developers it will save them time without proper teaching leads to poor results. Setting and following standards and rules for AI implementation is crucial.

My advice is to treat AI documentation like project documentation. Update rules, skills, and documentation when making changes. Global rules encompass company specifics like security checks, code editing tools, package versions, and architecture choices. Project-specific rules, on the other hand, set standards for the project itself, dictating aspects like React.js version, linters, Git practices, performance guidelines, etc. Developers should implement global standards and project-specific rules to ensure the best practices are followed in each project.

And also, if you set these kind of rules, you should follow them. My advice to everyone here is to treat the rules or the documentation of AI like real documentation in your project. If you change something in your code, update the documentation, update the rules, update the skills. Just because later on, someone else will join and he will be not able to work.

We have two different types of rules. First rules are global rules which mean your company specifics like security checks, code editing tools, package versions, and architecture choices. Global rules set the standards for the whole company. Project-specific rules, on the other hand, set standards for the project itself, dictating aspects like React.js version, linters, Git practices, performance guidelines, etc.

Developers should implement global standards and project-specific rules to ensure the best practices are followed in each project. Create files which AI understands and establish standards within your project. Provide as much context as possible for your specific project to ensure positive outcomes. Utilize agents effectively, treating them as specialized individuals to assist in various aspects of development.

So, if you have global rules like a standard for everything, each developer should implement in the project, project-specific rules to follow the best standards possible. Here are some rules and practices I believe will help you. Firstly, create files that AI understands. In my company, we typically use cursor, which aligns with advanced AI editors using AMD files with set standards and logic. Lack of consistent rules among developers can lead to issues. Creating a clear architecture and sharing project standards is crucial for team cohesion.

Context is paramount in AI utilization, as it greatly impacts outcomes. Providing detailed context for your project is essential. Leveraging agents effectively can enhance development processes. Agents should be treated as valuable team members specializing in different areas like QA, security, and documentation. Documenting rule changes and context is vital to feeding AI effectively for optimal results.

Simple rules should be followed: define your goal clearly to guide AI effectively. Context is key in enabling AI to understand and implement tasks correctly. Executing the code is crucial, but skipping the review stage can be detrimental. Emphasize the importance of reviewing code before and after generation to enhance skills through AI utilization.

Agents are powerful tools that can mimic human roles in the development process. By treating agents as specialized team members like QA, security, and documentation experts, you can enhance project efficiency. Documenting rule changes and context is essential for feeding AI with relevant information. Defining clear goals, providing context, and reviewing code are vital steps in leveraging AI effectively.

Implementing best practices involves creating a central repository for project rules and constantly updating them. Utilizing a CI pipeline with agents to automate documentation updates ensures global rule consistency. Decision records are crucial for tracking changes that influence AI behavior and functionality. Without a historical record of decisions, understanding AI behavior and troubleshooting becomes challenging.

What is your goal? What do you want to achieve? Also, just simple goal like, do me a button will not do what you want or what it is needed to be done. You need to provide context. I said that the context is the king and I truly believe it, just because if you provide context then the AI will be able to understand and also to validate that your understanding of the task is correct and later on to implement properly.

What is happening usually, it's a third step. The agent executes the code. The code is looking good, but we're skipping the review. The review also is a very important step, just because what I believe we should do like developers and teaching our people is before and after generating the code, you should think how to improve your skills using AI. Not just to generate the code, but also to try to improve yourself like a code developer because nowadays I believe the job of developer is not only to write a code, but also to try to really navigate between different systems.

You should be the owner of the whole system and also architect of the AI. After review is basically integration and it's your own responsibility to say that this code is good enough to go to production. Here are some really good best practices which I love to share with you. This is practices which we already implemented in my company. First of all, we created the prompt library. This is Git repository. All of our rules, which is meaning global rules, company rules are living there. We try to update them constantly.

What we did and find really useful is that first of all, we update these rules when we write a code, but second, when we push the code, we have a CI pipeline with agents who are responsible to update the documentation on fire. This is very useful just because people are really cautious to update the rules locally and later on, they forgot to update it globally. But if you update the documentation, later on, you will have a context which is good enough to write a good code. Next, we have decision records. This is meaning each decision which is really changing the behavior of AI or how the AI should work in your company should be recorded in some specific file and later on should be used like a resource for information. If you don't have this kind of history, in the end, what you'll find is that you don't know why your AI is acting like that and who decide to do this exact task. It's very important to have documentation. AI-specific lending. So use AI not just to write code, use AI to validate the code, use AI to explain the code. Just because AI is writing good code, it's not meaning it's not explaining well.

So AI should explain you why you did this code in this specific way and also how to change it later on to be better. This is prompt healing. This technique is very popular nowadays and I believe it will be more and more important just because if you are good on writing good prompts, later on, your result will be good. Context engineering is crucial; provide context quickly and effectively for optimal AI utilization. Treat rules and skills as documentation to avoid discrepancies. Measure engineers' abilities to think and use AI effectively, not just their speed.

Teaching engineers the right way is a continuous process. Share knowledge, assign tasks, give awards, and provide constructive feedback. Technical leaders should prioritize setting AI standards and investing in people's skills and knowledge. Building a supportive environment for AI adaptation is essential in a rapidly changing technological landscape. Focus on quality over speed, educate continuously, and create mechanisms to evaluate AI proficiency.

Self-education is paramount for success with AI. Invest in personal growth first, then extend that investment to others. Establish a culture of learning and improvement to navigate the evolving AI landscape effectively. Measure success not only by speed but by the quality of AI interactions. Empower individuals to learn and improve by providing guidance and constructive feedback. Prioritize self-improvement and share knowledge to enhance overall AI proficiency.

Invest in people, knowledge, and skills to adapt to the changing AI landscape. Educate yourself and share knowledge to enhance overall proficiency. Focus on quality and improvement rather than just speed metrics. Build a supportive environment for learning and growth in AI utilization.

Measure the quality of AI interactions and prioritize standards and skills development. Encourage self-education and invest in personal growth. Celebrate quality outcomes over output speed and emphasize the importance of setting AI standards. Share knowledge and resources to facilitate adaptation to new AI technologies.

Key takeaways: AI complements and improves skills, so use it wisely. Emphasize the importance of following the right principles and setting global standards. Avoid relying solely on AI for code repetition and prioritize maintaining standards and rules for effective AI utilization.

You can write a prompt to AI each time when you ask something in the terminal to give you score, like from 0 to 10, how good was my prompt, what I need to improve. So self-education is something which I highly believe it's important and you should invest in yourself first, later on in the rest.

What we do like a mistakes? We are celebrating only output speed rather than the quality. We pretend that we already validate the code and it's generated like five thousands of line and in two minutes we say that the code is good just because we ask AI do the code is good and never open the file to review it.

What we do also is we push our developers to use AI without setting any kind of standards. Usually what we do is new journey is coming and we say okay we use cursor, good luck. But that is not the way. We should provide to him what we have like resources, what we have like documentation and let him to adapt to our system and then we should expect the results.

Also many developers, seniors nowadays because it's hard to adapt to the new things in AI, they believe that it's needed just to adapt and later on not to share the knowledge. Because if I know it, you can ask and learn also why I need to share the knowledge. But this is not so true to be honest. Just because if you saw something or want something new, you should provide the information to the rest of the people.

Then we have a group of people who are really on top of the age of AI and also know how to use it properly.

Key takeaways: AI, it improves your skills, not replaces them so use it wisely. The right principle is so important nowadays. Don't believe AI will be smart enough to not repeat code. Set standards, set global rules, set agents, something which will remain and also will be used by everyone. Agents unlock new productivity, use them wisely.

Second, set standards, set global rules, set agents, something which will remain and also will be used by everyone. Agents unlock new productivity, use them wisely, which is meaning create front-end developer, create QA and back-end developers, anything which will help you to finish your work in time and quality will remain. Train your engineers for AI, not just blame them. And quality, ownership and the fundamentals about your code are something you are responsible for. Many developers blame AI, but we don't need to do that. What we need to do is adapt and think like AI is a tool helping us to write good code, not something which is replacing us exactly and we need to blame it.

That being said, here is some promo code for my books. If somebody here wants to read about Docker or React.js, you can grab this code and you will receive a 50% discount. And of course, I will be really happy if you people connect with me on LinkedIn, you can scan this QR code and directly we will go to LinkedIn. Yes. Thank you, guys.

Questions from our audience. What have we got? First one. How do you mitigate context drop? With more context, LLM is likely to neglect each piece of the requirements and context. That is a very, very good question. Just because context is everything about LLMs and I believe what we love to do is setting different agents like if we hit the agent limit, you have a lot of context and the agent is starting simulating a lot. What we love to do is switching to a new session or trying to summarize the context it is and later on to provide summarized context and then this is working. By the way, cursor introduced something which is simultaneously learning models like agents. This is very good to manipulate and follow the context itself. So highly advise you to use them. One quick technique I will add on that is intermediate documents that capture your core context so that as your agent rots context, you keep routing it back to that intermediate document to keep it fresh.

How do you ensure that the global rules remain current, relevant and synchronized in all repositories? So basically what we did, this is a very serious problem I hit in many, many projects. What we did is implementing the pipeline in CI-CD process which is updating the context of the project itself when you're running the pipeline. So imagine we have something like build, scan and test and then we have a document. So this specific pipeline is responsible for updating the context for each project when we add new code to it. Yes. All right. So next up, how are you evaluating quality? What are the metrics for the code, the prompts, etc.? This is kind of a very hard question just because we don't have proper tools to evaluate your skills and abilities. But again, what I personally do for myself is when I'm writing something to AI, I try to tell AI that I need to have a score system. So based on the score itself, I see how good I am with interacting with AI.

From the beginning, I was thinking that I'm really good just because I use AI for everything. But I realize that AI is not working in that way. If you believe you are good, it's not meaning you are. This is just belief system. So later on when I implement my own qualification like from zero to 10, I realize that I highly get six, everything it was five. Just because I was rushing. I was trying to tell AI do the job fast rather than providing the context. So yeah, try to implement something like validation of the system for you.

Next question. Have you noticed a reduction in technical debt by implementing these principles? Yes. So basically what I found is that if you have good skills, if you have good tools and agents and people are aware of them and you know how to use them properly and update them, of course, the technical debt is less and also the code quality is improved. But if you leave your people without rules, skills, and anything to write the same exact code, they will receive exactly different results, which is annoying. We know that this AI is very good at doing duplications and also different results on the same exact prompt. So usually, again, try to set the systems for your developers. Don't blindly push them to use cursor code or whatever is allowed in your company. You should be able and responsible to provide them the skill sets and also the agents which they will use later on to deliver a good quality of code.

There's two questions on here. We don't have time for both and they're pretty overlapped. So I'm just going to pick one. Do you have any tips or techniques for getting agents to consult or ignore for that matter particular advice reliably? Yes. So what we did is basically we create the agent, which is warning agent, and you can ask a question and we'll explain directly. But the best on the context of your specific project. So it's easy. If you ask AI what this function is doing, we'll explain the function and also we'll explain what is going on, but not in the context of your specific project. So we created the agent which is aware of our project and explains how this function is related to the rest of the project and also what needs to be changed or improved on it based on the whole project.