← Back to search
From Vibe Coder to AI Engineer: The Complete Roadmap
Leon van Zyl · 2026-11-10 · 37 min
Show full episode description
Learn more about your ad choices. Visit megaphone.fm/adchoices
✨ Episode Outline — click any point to jump to it in the episode
Problem solved
Vibe coders ship AI-built apps without understanding the stack or owning security, while skeptical engineers avoid agents; the AI engineer roadmap brings both to a reliable coding-agent workflow.
Benefits
- Take accountability for security and reliability of agent-built software
- Use the coding agent as a patient teacher to explain any codebase at your level
- Build a personal knowledge base of tech-stack building blocks
- Write your own agent skills instead of copying from skills.sh
- Portfolio of GitHub projects to show employers and get community feedback
Use cases
- Clone the Hermes Agent GitHub repo and have the agent explain its agent loop, memory system, and tech stack
- Recreate a favorite app with a coding agent using the building blocks noted from step one
- 'Start an app' skill that gathers requirements, then installs the standard stack (AI SDK, OpenRouter, Better Auth)
- 'Review an app' skill checking security issues, feature drift from the original vision, and SEO
- Build apps for friends, family, or local businesses to gain coding-agent experience
KPIs / results
- Hermes Agent has over 250,000 GitHub stars
- Speaker has nearly 20 years of software engineering experience, mostly enterprise finance
Tools / build
- Custom 'start an app' agent skill with reference folder (AI.md, auth)
- 'Review an app' agent skill for security, drift, and SEO checks
- Personal skills repository on GitHub
- Tech-stack notes knowledge base (Notion/notepad)
- Claude Code desktop app as the coding agent
Hey everyone at the AI Practitioner Summit and a warm welcome from sunny South Africa. I'm really honored to be here. In this session, I am going to give you the roadmap that you need to go from being a Vibe Coder to thinking more like an AI engineer. And if you're an experienced engineer trying to get more out of coding agents, this session is for you too. But first, let me introduce myself. I'm Leon van Zyl. I'm a software engineer with nearly 20 years of industry experience. And the majority of my career was spent working at large enterprises in the financial sector, where things like performance, reliable code, working in teams, and security actually matter. I've been interested in AI and machine learning from my university days, and it's really when GPT2 was released that it sparked my interest in getting my hands into the stuff again. While most people were playing with the chat GPT interface and generating posts and lyrics and stuff like that, I really wanted to dig into the APIs to see how this technology can be used in business use cases. It was because of my passion for this technology and my love of teaching others that I created my YouTube channel that I think a lot of you might have seen. This is where I create detailed tutorials that show you the fundamentals of working with coding agents to building advanced stuff like software factories and custom coding harnesses. I also run an exclusive community where people can ask me questions. We have live workshops where we dive into the nitty gritty of building really cool stuff with AI. Now enough about the community and YouTube. This is what we'll focus on in this session. And this really is my mission. There are basically two types of developers. On the one hand of the spectrum, we've got five coders. These are people who don't really care about the underlying tech stack. They rely on the AI agents to code the entire solution for them and sometimes even deploy the solution and maintain it in production. But there are issues with that approach. On the other side of the spectrum, we've got skeptical developers. Yes, I've worked with a ton of developers in the past and I still find it shocking that even today in 2026, so many experienced developers haven't fully embraced the agent decoding it. They're still extremely skeptical about all sorts of things, about AI agents taking their jobs to, I don't know, messing up the code or just being unreliable. I've just heard it all. My goal is to take your white coders and your skeptical engineers and sort of bring them towards the middle. And this is a role I call an AI engineer. Now in this role, you are not expected to write any code yourself. But, and this is very important, you do have an understanding of the underlying tech stack and how everything fits together. You do not have to be technical to do this, by the way. And I will give you some pointers during the session. As an AI engineer, you're able to work with not just one coding agent, but multiple coding agents across multiple projects. And you have a solid workflow for ensuring that the code is actually performant, it's scalable, scalable, and of course it is secure. Now by show of hands, how many people in this audience consider themselves to be vibe coders? In other words, they just ask the agent to build something for them, and they never really care about what the underlying tech stack is. The agent should just build it, it should look like it's working, and the agent should just deploy it. Of course, I can't see any of you, but I bet you a couple of hands were raised. We live in a super interesting time where anyone can build anything they want. You don't have to be technical at all. I've seen non-technical people, in fact, people who are far removed from being technical, build really cool and practical stuff. They can just put it up in the Claude Code desktop app, they can ask Claude to just build something, and Claude will even figure out how to deploy the app to production, and everything just works, right? Now that approach could be fine if you are building toy apps, or if you are building little proof of concepts, but this is not good enough if you plan to put software in front of real users. Just imagine building an app that collects information from real users, and there's a critical security vulnerability within your application. Of course, you didn't write a code, Claude did. Claude even deployed it, and all you did was share the link with your users. Your app started to grow, users started to use it, and something happens. There's a security breach. Your users' information was compromised. Who is responsible in that instance? And that's something I really try to teach people in my community and on my YouTube channel as well. You decided to build the app, you charge your users a fee, and of course, you are still accountable. Your agent was simply a developer that you contracted to do the work. You were still responsible to ensure that some kind of security audit was done, and that audit should be done on a regular basis. And of course, the tech stack that you chose is reliable as well. That simple action of taking accountability is what's going to take you from being a vibe coder to someone who can build reliable software applications using coding agents. So in this session, I am going to show you my workflow for working with coding agents. We'll start off easy by covering the fundamentals, and then we'll ramp up the complexity where we'll discuss things like software factories, as well as harness engineering. Starting with probably the most important thing you need to know when working with coding agents. Your coding agent is probably the most patient teacher you will ever have. Don't be afraid to ask your agent to explain what an application does at a level that you will understand. Of course, this is going to be different based on your experience. If you're a non-technical vibe coder, you probably don't want all the technical terms. Simply tell your agent to explain it to you in very simple language. Or if you're a software engineer or a software architect, ask the agent to explain it in a way that you will understand. A lot of popular projects have GitHub repositories. For example, Hermes Agent, which is an extremely popular AI assistant tool that's got over 250,000 stars at the moment. A lot of people use it, but very few people actually understand how it works behind the scenes. What tech stack is involved, what the actual agent loop looks like, how the memory system works. Guess what? You don't have to read through this code yourself. I encourage you to grab the GitHub repository of a project that you actually like and ask your agent to clone it and then explain the entire system to you in a nutshell. One thing I like to do is to make a note of the underlying tech stack. What did they use to build the front end? Did they use any component libraries? What did they use for the back end? What auth system did they use? How did they include payment integration? Things like that. Ask your agent questions about an application and how it works. Now, don't just leave all of this information sitting in the agent session. I promise you by tomorrow, you would have forgotten what all those details were. Make notes of everything. So have a look at the tech stack. If something stands out for you, open a Notion page or notepad or whatever you want and just note down exactly what that application used for things like the front end, the database, whatever else. By doing this, you're actually creating a little knowledge base with all the building blocks you might need to build your next project. And this takes me to the next step. And this is a question a lot of students ask me, especially when trying to get experience and to apply for a job and to show their experience with working with coding agents. What you need to do is to build a lot of projects. And this ties in closely to step one. In step one, we identified the underlying tech stack for an application that we really like. And we noted down all the little building blocks. The next logical thing I want you to do is try to recreate that application using a coding agent. Don't just copy that GitHub repository though. What I want you to do is prompt the agent to build maybe a clone of that application. And it should use the following tech stack and then give it those building blocks that you discovered in step one. Another idea is take an app that you use every single day and see if you can get your coding agent to recreate that application. Or ask your friends and family or even local businesses if there are any apps that you could build for them to help them out with tasks that they do on a daily basis. This will give you the necessary experience and confidence that you need to work with coding agents. Don't just leave the project sitting on your own PC either. Push your projects to GitHub. GitHub is super valuable. This allows you to create a remote backup of your code on this GitHub website. The other benefit is that you can actually share this code with others. This can be extremely helpful if you are looking for a job in the space as well, as you can share your projects with your future employer. And you can actually discuss one of these projects in your interviews. There are plenty of other benefits of using GitHub as well, which we'll cover in the session. GitHub repositories can be set to private or public. Private means that only you can see the code or people that you invite to that project. Public means anyone can see it. Now, this might sound scary, but you can actually get a lot of valuable feedback from people downloading your code, testing it themselves, and then logging things like issues. Or they might actually try to contribute to your code base by creating pull requests. Let's step things up a bit by discussing reusable systems. The first topic I want to cover are agent skills. Now, skills might sound scary, but they're not. They're basically reusable prompts. Let me give you an example. Whenever I start a new web project, I tend to give the agents very similar instructions. Now, of course, the details around the app that I'm trying to build will be different for each app, but there's also a lot of things that get repeated. For example, my underlying tech stack. It's usually the same database, the same front end, the same sort of front end components, the same ORM, the same auth system. I tend to use the same things because that is what I'm comfortable with. And I'm sure that's true for a lot of you watching this as well. So whenever you find yourself repeating anything, whenever you start a new project, that is a great opportunity to create an agent skill. So what I did as an example is I created a skill called start an app. And this skill gives the agent all of the instructions that I typically give the agents when building software. The skill file itself is nothing crazy. It simply says, whenever the user wants to create a new app, you need to follow these rules. Ask the user what the requirements for the app are, kind of grow then to get those requirements out. And then based on the app that the user is building and their requirements, you need to install the following things in the tech stack. And we can see all of that in the reference folder. If the app requires any AI functionality, then references AI.md file, which says that all right, you have to install the AI SDK. And maybe we're using open router for inference. Or if the app requires user authentication, then use better auth. Now, of course, you can switch any of this out for clerk or whatever you want to use. But I think you get the idea. I do not have to repeat these instructions every time I want to start a new app. And by the way, all of the skills and everything I show you in this video is there for you to use as well. Feel free to install the skill yourself and give it a go. The same thing with reviewing an app. And I might be getting ahead of myself as we will discuss this in a second. But I've also created a skill for reviewing an app. And review actually means a couple of things like checking for any security issues, checking for any drift. So did we add any features to the application that's drifting from the original vision? Is the web app SEO optimized? You can really take all of those things that you keep repeating in your applications and create a skill for it. Now, this is something I'm really passionate about. In fact, I actually have to go full screen for this. Pay attention and look at me. Stop copying other people's skills. Write your own. Whenever I go to websites like skills.sh, I see the same one or two names show up. And it's for the silliest of things. A major part of becoming an AI engineer is to understand how to prompt agents yourself. Prompting and prompt engineering is a skill and I'm not referring to an agent skill. It's a human skill that you need to practice and improve. And if you're only copying other people's skills without ever reading it yourself, you are doing yourself a massive disservice. Now, I'm not saying you should not try out other people's skills. But what I want you to do is if you find a skill that works for you, open up that skill file, read through it and make notes of why that skill actually works. How was the prompt phrased? Are there any sort of trigger words or something that sticks out to you within those prompts? Make notes of it and then try to write your own skills and your own prompts that get similar results. And I promise you in no time, you'll be able to write your very own skills and get really good results out of coding agents. Unfortunately, I've seen it too many times that people copy other people's skills and then they're too afraid to change it. So at this point in the roadmap, this is what I want you to do. I want you to create your very own skills repository on GitHub. So this can be in your username slash skills. Then whenever you create a new skill for your workflow, push it to this GitHub repository. It's super simple. You simply have your skills folder. It's similar to the skills folder that you already have in your .cloud folder or your .agents folder. You're simply pushing these skills to this repo. This way you always have access to your skills if you want to set it up on a new machine. I do recommend creating a single skills folder for your project or your org and allowing your team access to that repo. If you are working in a team or at an enterprise level, being able to create skills that your team can use to get consistent results out of agents is just invaluable. You also need to get comfortable with using memory files. This is actually easier than you might think. A memory file is usually this agents.nd file that you can store at the root of your project or at your sort of user level, which will apply the rules globally. We can use these memory files to set certain guardrails, workflows, and rules that the agent needs to follow across all of the sessions for this project. What I recommend is to keep this file as concise as possible. Try not to overcomplicate it. Whenever you find your agent is doing something in your project that you really don't like, you can simply put a rule in this file and the agent will follow that rule whenever you start a new session. So I'll just briefly go through my file. Briefly, I prefer if my agent actually keeps the responses concise as I find that sometimes with certain agents like Claude, the responses go on forever and you're just paying for the tokens. I prefer shorter responses personally. And for the planning mode, I like it if the agent can ask me clarifying questions. I like to use sub agents to do deep research. And I also like to use sub agents to review our implementation plan. I also have specific rules for change and edit mode. Whenever we make database schema changes, I've got certain things that I prefer to do. I also like to add instructions to force the agent to test its code before handing it over to the user. And very important, we can enforce our design system by tagging our design.md file. This design.md file simply contains our entire style system, which contains things like the theme, the tokens, the typography, spacing, border roundedness, etc. We can also give our agent instructions like to use work trees instead of trying to commit everything to the main branch. Right, let's really step things up. I think we've discussed the reusable systems. But now when we're working on larger projects, we really have to think about team workflows. So here's a discipline that I started doing in my projects. In fact, to be honest with you, when I started with agent decoding, I actually followed this exact same process. And then somewhere in between, I started to kind of move away from it. And now I find myself using this system again. What I encourage you to do is when you start a new project, or even for an existing project, always ensure you've got a GitHub repository set up. So when you are starting off with a new project, shortly after building the base code, ask your agent to create this GitHub repository for you. And it will look something like this. Now, the next time you ask your agent to do a piece of work, what you can do is either log a GitHub issue yourself, or simply get your agent to create the issue for you. Now these issues should be a logical piece of work, it could be a bug fix, a new feature, maybe a documentation change. The point is, this is where we document all the new work that needs to be done on this project. What I used to do, and I think this came because of sort of spec driven development, is I would ask the agent to create a folder on my, you know, within the project, and then create a little individual feature files within that. And it should just kind of implement those features one by one, kind of like a to do list. But recently, I think it's better to just use GitHub for this. So instead of creating those little feature files in the project, ask your agent to create GitHub issues for all the work instead. All these issues can be labeled, you can set dependencies between them. And it's a great way to see the status of all of your work. In a single view, I can see all of the issues and new features that need to be addressed in this project. So that means that when we open up Claude code, we can simply tell Claude, hey, go and read all the outstanding issues on my project, and just, you know, start implementing them one by one. Also, as you're working on these changes, go and add comments to the code, or to the issue. So when we scroll down with this issue, of course, we've got all the detail on the specific change that needs to be made. When we scroll down, we are able to add comments. Now we can write comments ourselves, which is kind of a great way to give feedback to the agents. Or as the agents are working on this issue, they could actually update this issue as well. And they can add a lot more than just text, by the way, they can attach test evidence, screenshots, you know, stuff that's really useful. And it's a great way to view the progress. Now we will discuss things like software factories in the session as well. But this is all building up to a world where you actually don't have to interact with Claude code yourself, all you have to do or even your users is log a bug, log an issue, and your coding agents will run in the background processing these changes, creating pull requests that could automatically be merged, or you could merge them yourself. Now you might be wondering why did I call this a team workflow? I'm not referring to human teams necessarily. But a team could also be AI agents like your agent swarm. But yes, if you have human developers on the project, or even a project manager who wants to create the board, to see where all the issues are, this solution is perfect. So just to demonstrate how this works is whenever you need to make a change to your app, you can go to the get up website or just use your phone. Create a get up issue. The agent will pick up the issue. It will make the change. It will test it using your normal unit. Black Week Wahnsinn bei Simon Mobile. Sicher dir zwölf Monate 99 Gigabyte ab super günstigen 9,99 Euro oder unglaubliche 999 Gigabyte ab 19,99 monatlich und höre deinen Lieblings Podcast unterwegs. Top D Netzqualität inklusive 5G, all net flat und monatlich kündbar. Mit dem Code extra 10 gibt's für Neukunden bis zum 13.12.26 zusätzlich sechs Monate lang monatlich 10 Gigabyte on top. Mehr unter simon.link slash Spotify. Test end-to-end tests, or the agent could just kind of use its own test suite as well, and it will update the issue as expecting changes by adding comments. And once the agent is done, it will create a pull request, which you can review and merge. Now branches and work trees are something that vibe coders are kind of afraid of, but you shouldn't be. It's really not that bad. At the end of the day, you are not the one managing these branches and work trees. It's really the agent. It's important for you to understand what it is and why it could be useful to your project. When you work on your project for the very first time, all of the changes are made on the main branch. You only have one single copy of your code. That copy will eventually be deployed to something like GitHub. And from GitHub, you will deploy it to some production server where your end users can access it. Now, when you want to make changes like, you know, fix a bug, introduce a new feature, or make a documentation change, you ideally do not want to change the main branch. If you introduce a new bug, your end users are going to feel it immediately. A better convention is to create a work tree. If you have a look at this little diagram, all this does is when we ask our agent to make a new change, this will create a copy of your code into a separate work tree and feature branch. It will make the changes only in that copy, which means that the main code is unaffected. And let's say that while this agent is working on this change, we realize that, oh, we actually have to make another change. So maybe we've picked up another bug. We can fire off another Cloud Code session and that session will then create a new work tree, which is a new copy of the code and work on that change in parallel. None of these two changes are affecting the main branch. It's only once the changes are complete and we've actually reviewed the pull request that we can squash that branch and merge it back into the main branch. So that way we don't affect our users until the changes have been fully tested and approved by ourselves. Now, this is something I'm quite passionate about and I think it might feel a little bit technical, but it's really not. This is something I call respecting the CI CD pipeline. CI CD simply means continuous integration and continuous deployment. And this concept has been around for a very long time and it's worked within larger teams as well. So let's assume that we are working on multiple changes at the same time. Of course, we are not making the code changes. Our coding agents are working away. So we've got two changes over here happening at the same time. Maybe we've got a human developer making changes to the project as well. Humans and coding agents could accidentally introduce a bug that could break something that used to work in your application. So they might have worked on a bug, fix on one thing, but by fixing that thing, something that used to work now fails. Thankfully, there are plenty of solutions to do regression testing on the code. We do not have to wait for our agent to test the code itself. We can run automated scripts that will test existing functions in the code and ensure that everything still works. We can even run automated end-to-end tests that will test a user's journey in the application to make sure that everything still works as well. These scripts run within milliseconds or within seconds at the most, and they can really save your butt. So maybe let me show you an example of what that actually looks like in the real world. After we've made a change or after our coding agents made a change, it will create a pull request on GitHub. Now this change has not been merged into main yet. What we can do is have a look at what is contained within that change. So if we wanted to, we could even review the code. But if we scroll down to the bottom, we can see a section containing these checks. And this contains the test scripts that we set up for our application. This means that whenever a pull request is created, this set of tests would need to execute and we could set up rules that say, well, if any of these tests fail, for example, our unit tests or end-to-end tests, if we run into any issues, we will not be allowed to merge that pull request. So this could proactively catch any bugs that your coding agent could accidentally introduce with a change. But this really does deserve its very own session. So if you are interested to learn how you can add automated testing and regression testing, you can have a look at this course in the Gentic Labs, where we did a deep live session on testing, GitHub and safe deploys. Trust me, this is a lifesaver. You won't believe how many times Claude Code, as good as it is, failed these checks because it introduced a bug. The nice thing then is you can ask your agent to review the issues on that pull request and resolve those issues as well. Another thing I like to do is to run security reviews and code reviews as well. So basically, after you've asked your coding agent to make a change, simply split up a new session and ask that agent to do a code review. And then open up another session and ask that agent just to do a security audit. I've heard a lot of people in my community say that what they like to do is if they use Claude Code to work on the main change, they'll actually get another model from a different provider like GPT-6 analytics from Codex to review the code. So that way you don't have sort of anthropic reviewing Anthropic's code. So for the code review stuff, you could also use my skill, which is called Review an App. Within that skill, we actually review a couple of things like SEO, but we also have the security skill. This will review your code using the OWASP top 10. Now I always run those two steps because as I said earlier, you are accountable. If you're dealing with real users with real payments, and there's a data breach, you need to prove that you try to keep the system as secure as possible. So what I like to do is when I get my agent to run that security review step, I also ask you to update the GitHub issue or the pull request with the audit and the findings and how the issue was resolved. A little bit of effort on your part can definitely cover you in the future. And as we covered earlier, automated tests can definitely save your butt. Simply ask your agent to add a test suite to your project. This could be simple unit tests that test all the functions in your application. It could include end-to-end tests as well, or a little mixture of the two. Then ask your agent to add those tests to your CI CD pipeline. Now let's scale things up. Now that you're comfortable working with coding agents, and you've got your workflow bedded down, it's time to push yourself to work with more than one coding agent at a time. The system that I showed you today allows you to create multiple issues, and that also means you can run multiple coding agents working across multiple issues at the same time. Your job as an AI engineer is not to sit there and babysit a single clawed code session. You need to be as productive as possible too. So the benefit of working with multiple agents is you could assign different issues to different agents. Each of those agents will work away at the changes in their own work trees. And by the end of it, you can review the pull requests and then squash and merge those changes or send the issues back to the agents to address any issues. Now this is actually a fun part. I love it. A lot of people ask me where these issues actually come from. On the one hand, it's probably you as a developer logging it, or if your business owner needs a change made to the application, those will eventually result in a GitHub issue. But issues could also be the result of proactive monitoring. What I like to do is to run security audits on a schedule, the same with UI design and the same with code review. So I would have an agent run maybe once a day or like every six hours to review the application for any possible improvements. And if it identifies any gaps or issues within each of these different categories, that agent should automatically create a getup issue on our behalf. Ideally, you don't want your users to run into issues and then they have to kind of email you or contact support to resolve those issues. For the most part, people don't really report issues. They'll probably just think your app is crap and never come back to it. So just by proactively monitoring these three categories, you could identify security issues. For design review, what I like to do is to ask my agent to compare the application. So it should pull up any random component or page in the app, and compare that to the actual design system. And if the page or component is misaligned, it needs to create an issue to resolve that request. These agents do not fix the issues themselves. They're simply there to scan the app for improvements and create the issues if the issues do not yet exist. And the same thing for code review. Sometimes code just needs to be refactored. Sometimes code becomes stale because the feature was deprecated a long time ago, and now the code is just kind of sitting there idle. Here's another thing I noticed with code review as well. I have applications that were built by like all the GPT and Claude models from like two years ago. And of course, new frontier models are released all the time, and they are way better at writing code. So if you have all the projects, this code review agent could actually greatly improve the quality of the code in your code base. And now we're really stepping things up. So far, we are the ones assigning issues to agents. So we are opening up our Claude Code session and asking our agent to address issue 123. What if we could do all of that on autopilot? So instead of us having to assign these issues, we simply create the issue, and then our system or our software factory will classify or categorize the issue itself, and assign that issue to one of the agents in our agent swarm. When I create a new issue, that issue will automatically be labeled by our software factory. Let me show you what that actually looks like. I can go to any one of my repos like this RTS demo, and let's just give it a name. Let's say we want to add like a PS1 graphics filter. What I can do is simply create this issue. Under labels, I can simply set this as ready. So once I'm ready for the software factory to process it, I can do this while creating the issue as well, by the way. So all I have to do is set this issue to ready. And now we can see this label just changed to factory running. And if I go back to my software factory itself, we can see that my software factory is actually processing that issue at the moment. And my software factory consists out of 10 coding agents. So I've got a combination of Haiku, Codex, Claude agents. And here we can see that the Codex 2 agent is actually working on this change. Now I could actually specify exactly which agent should process this from this list. All I have to do is just kind of select the specific agent. And this does include human in the loop as well. So if that agent has a question for me, it will update the issue with its question. And I can simply update the issue with a comment and the agent will continue working. Software factories are really popular right now because you are not running agents on your own hardware anymore. These are running in virtual machines in the cloud, which means they are running in isolated environments as well. So if there was any kind of prompt injection or the agent messed up badly, it's all sort of isolated to its own virtual machine. And of course, you don't have 10 or 20 or 100 agents competing for the same resources on your laptop. So just imagine a world where you've got your agents proactively monitoring your system for potential security issues and logging the issues themselves. When that issue is created, one of the agents in your swarm automatically pick it up, they work on the change, and they raise that pull request for you. All you have to do when you wake up in the morning is go through the pull requests and simply decide on what changes you want to keep or throw away. And finally, I do want to discuss custom harnesses and harness engineering. Custom harnesses are extremely popular right now. You might have seen plenty of coding harnesses out there like the Pi Agent SDK, the DeepSeq harness. There are so many different options. You definitely do not have to use codecs or cloud code if you don't want to. Custom harnesses can be fantastic. If you wanted to enforce certain policies within your organization or have very specific hooks and features available to the agents, just build your own coding harness. Let me show you an example of a harness that I built. Now, as I mentioned, there are plenty of coding harnesses out there. Cloud code, Open code, the Pi Agent SDK, you name it. But none of those were effective in my opinion at working with open source models. So I decided to build my own coding harnesses. And this is called small. This is a tiny coding harness that only injects a small system prompt. So it barely uses any of the context window. And it automatically picks up models running on your own hardware. So if I go to slash models, this automatically scans your system for any models running in OLAMA and LM Studio. And if you've ever tried to use local models in other harnesses, it usually involves a whole bunch of configuration, which is not fun. This harness only includes a tiny set of tools that's custom designed for these tiny models. These local models are really not good at doing things like using sub-agents, skills, MCP servers. So all I did was simply strip away everything that agents shouldn't have access to. And now it's got an optimized environment for these tiny models. And yes, this does include a web interface as well. The point being that depending on the environment that you're working in and what you have, you can definitely build your very own coding harnesses. Again, we've actually got courses on that in Argentic Labs as well. And finally, that takes us to harness engineering. You are not just limited to the coding harness and any specific agent from any provider either. You can set the environment up any way you want. You can decide what tools the agent should have access to. Should it support memory files? Should it automatically implement like company policies? I've seen plenty of harnesses that are optimized for larger organizations and for use at enterprise. These types of harnesses will identify things like personal identifying information before sending the prompts to agents. Or if your company actually wants to block access to certain tools, for example, Google Drive or, you know, Teams or whatever, you could build a harness that will add all of those protections already. So you could build your own custom harness that enforces the CI checks. Or the custom harness could enforce monitoring agents. And finally, let me show you one of the craziest coding harnesses that I've actually built for myself. This project enforces everything you've learned today. This is a coding harness. It enforces rules through very specific memory files. It tackles things like security and everything else. But what you're seeing here is my software factory represented in 3D space. So who said that coding should be boring? As my agents are working in idle, they can actually interact with their environment, keeping things really interesting. Each of these coding agents are doing real work. So if we have over any of these monitors, we can see that this agent is actually running. And this is running a cloud code session running on Opus 5.5. We have our Kanban board over here. And guess what? Each and every one of these stickies actually relate to an issue on GitHub. So this is a normal GitHub issue. And the same thing with pull requests as agents complete their changes, they will actually create and review their pull requests. And whenever I add a new task to the backlog, this will actually create a physical GitHub issue. So this is everything that you've learned today represented in a very fun and interactive manner. This could be the future of Vagente coding. This project is open source by the way. And yes, you can try it yourself. The project is called Kubefarm and you simply install it with a single command npx-kubefarm. If everything I showed you today still feels like it went over your head, and you actually need something that's a bit simpler, I do have a free course called the ramp framework. This is where I teach you a simple repeatable workflow that you can use for any coding agent. This even works with free local models. You can simply scan this barcode and this will take you to my free community where you get access to that free course. If you would like to contact me, I've got a YouTube channel. My company is called Cognitive AI, where we help businesses get AI ready. And I have a paid community called Agendic Labs. And that is where we do deep dives. And I've got exclusive courses in there as well. Thank you for your time. This was a lot of fun. And I do hope to hear from you guys soon. Thank you to the AI Practitioner Summit for having me and I'll see you later. Bye bye.