Transcription
Hello everyone. Uh, so in the last couple of days, my uh context engineering framework, PRP product requirement prompts, has gotten a lot of exposure, a lot, thanks to Cold Medicine, who actually featured my framework in a recent video of his. And this is where we get into two of my favorite things for context engineering: Cloud code/commands and PRPs, which is short for product requirements prompts. And so, they're similar to product requirements documents, PRDs. You've probably heard of this before if you've been diving into AI coding, but they are specifically designed to instruct an AI coding assistant. So, yeah, I'm really excited about that.
And uh, yeah, so today I'm uh planning to show you around a little bit in the in the repository. Uh, but yeah, first I'll just show you uh Cole's video here. As you can see, he has um, when it comes to third party, let's just uh watch this ad here a little bit. And if we skip here, we can see that he has his context engineering intro. He has a lot of good information about context engineering itself, uh, the principles of context engineering. So, I highly recommend that you go and check that out to get like a deeper understanding about context engineering. But yeah, then he showcases my framework. Month in our community, and it was, I did a workshop for uh, the Cole's Dynamis community. So, I highly recommend you check that out as well. There's a lot of interesting discussions going around in there around uh, cloud code agentic engineering in general and and agent uh, building in general. But yeah, uh, check this out and uh, let's take a look at uh, my repo.
So, uh, I'll just open the preview. So here we have uh, my PRP framework. So, what is it? Uh, it's uh, product requirements prompts. It's a derivative of PRDs, which is product uh, requirement documents. I have a long background in business analyst analytics and uh, product management. So, I've spent a lot of my time writing PRDs. So, uh, when I started uh, coding with AI, it was pretty natural to me to use PRD and and other business analytics techniques to uh, improve my prompting and the context I was giving to AI. But yeah, in short, the PRD is a PRD plus curated codebase intelligence plus the agent runbook, uh, aiming to be the minimum viable packet an AI needs to plausibly ship production-ready code uh, in the first pass. So, it's a planning framework for how you curate context, implementation plan, and references to documentation to kind of outside of your codebase context, but also a lot inside of your codebase codebase context. So, it's very much designed for working on uh, existing mature codebases as well. Uh, so that's kind of where it came from. Uh, that's what I needed. That was my use case. I needed something that could work on existing codebases. So, that's where this, why this was created in the first place. I've been working on this uh, and I've had several versions of this uh, before uh, this one. So, I started uh, in uh, the summer of 2024. Uh, that's when I named it PRP, at least. And before that, it had a bunch of other names, but the concept was very much the same. But yeah, there is a lot of instructions here, like how you can get started in the readme. So, please check that out if you want to get started. But I will uh, take a little bit more of a deep dive into the repo here uh, for you right now.
So, if you open up this PRP's uh, repository, you will see a little bit more of a uh, readme here. The readme that's here is actually for feeding to the AI when the PRP is created. So, we will not go too deep into that. And in the templates directory here is where all of the PRP templates are. So, this is basically prompt templates that Cloud Code will use to fill uh, when we execute our commands. And here is where it all starts. So, I have a lot of commands here in the commands directory directory. So, this is a lot of things that I use in my day-to-day. I have generalized them slightly. So, these are in every case where I use them in a real codebase, they are very much adapted for that codebase. But this is basically, you know, the base that I would use for for most of the things, and I would add specific things for my, uh, specific use case for the codebase I'm working in. So, please take a look, look at a lot of these. I use a lot of these daily, especially this review stage on stage and review general. Very useful for when you want some help reviewing your code. Some development helpers for like Git stuff and uh, other kind of things. Uh, uh, this is what I will go through now.
So, here's the PRP directory. There's many versions of the PRP, and they all serve a different use case. I will use the PRP base as our example for today. Uh, so what this does is it takes your idea as an argument. So, say that you have an idea of a product you want to build, or you have a large task, or a task that you want to do on your existing codebase. Uh, you pass that in here as an argument. So, it's worth spending a lot of time up front on preparing your, let's say, feature request that you will have to feed into the PRP. So, the more work you do before you uh, add it here as an argument, the better your result will be. So, here is like, you can use a Jira task, an epic, a PRD, uh, so a traditional PRD, you can feed here to get like, the more context out of it. But yeah, here are some instructions for Cloud Code. What it will do is it will generate a complete PRP for uh, general feature implementation without uh, with thorough research and ensure that all the context is passed to the AI to enable self-validation and iterative refinement. So, yeah, yeah, some instruction here that the AI only gets context that you are appending to the PRP. So, it's important that all of it is there. There is some Shane thought prompting here to get it to work in this research process. So, it will send it into your codebase, do a codebase analysis, and like gather all of the context that it will need from your codebase. It will do external research that is more like online. I'll open this up actually in the preview. I think it'll be easier to see. Then it will search for similar patterns and features that you already have, uh, and, uh, yeah, uh, libraries, implementation examples from, you know, GitHub, blogs, whatever, best practices, and common pitfalls. It will also ask you, so if it feels like it doesn't have enough context uh, from your argument, it will ask you for clarifications here as well. So, there you have an opportunity, it will ask you questions, basically, to to fill those gaps. Then it comes to the PRP generation itself. So, it will use the PRP base template that we'll take a deeper look at soon. Uh, and it will fill it, uh, when it has all the context. So, here is just some kind of iteration on telling it that it must provide context of documentation, code examples, gotchas, patterns, and implementation blueprints. It will add pseudo-code, uh, reference real files, and for patterns, include error handling and so on. And it will also do uh, validation gating. So, it will do the two main ones it does is is the syntax and style checks, and also unit tests, but there's also a lot of other validation techniques that it's used and and that I recommend looking into. Uh, so, yeah, here's also some uh, prompt techniques. So, adding some critical marks and ultra-ink is also something from Cloud Code that you can add to to make it activate additional thinking tokens. I'm not going to go too deep into how Cloud Code works. I'm going to assume that a lot of you know how Cloud Code works, and I'll do a deep dive into Cloud Code in a later video. And then it will save that PRP into a new file in our in our PRPs directory. It has also some quality checklist here at the end.
But yeah, so here, let's take a look at that PRP uh, template that it will be filling. So, here is that. I'll open that in the preview as well. So, this here is basically a predefined template that uh, every, all of the context that has been gathered in in the context gathering phase will now be filled into this uh, template here. Uh, so there is some front matter here. So, the purpose uh, and the core principle. So, it's like explaining to the AI what this is and why it is. And it also is referencing here the readme that we looked at before. And so, it will read that readme as well before it creates this template here. So, yeah, it will add three core things here in the beginning, or for the goal of what you're building this. So, like the value of what you're building, uh, what exactly you're building, uh, and then also the success criteria. And here, uh, if you look back for a second on the base grade here and this argument that you're passing here, the more context you bring related to these core, the core things here, the goal, why, what, and the success criteria, the better your uh, result will be. So, it will really like use your input here if you have given it. But if you don't give this, it will, you know, make something up, and uh, then you have to be really sure that when you read this back after it's created, that it fits your goals and your needs. So, that's kind of like a thing to look out for if you uh, try to wipe code your way through this. I I don't recommend that. Really spend time planning and spend time preparing, otherwise you're you're not going to have a good result, or you will probably have something working, but it's not going to work the way you want it to work. Uh, but yeah, then we have uh, the context. So, it will, it will give you all of the context that is gathered, and all of the context that the AI thinks that it's going to need through the implementation. It will put it here in in different formats. And then it will also run the tree. So, it will give you the tree structure, uh, desired codebase, uh, and then it will, uh, so, yeah, desired uh, tree structure after the implementations. Will give one before and one after, some known gotchas. It will give you the implementation blueprint. So, it will give you the data models and the structures. So, this is always really good to go through here after you have uh, ran the PRP. So, especially things that are, especially worth looking at is the tree structure. Does it fit your pattern? Is it the architecture that you want for your codebase? Otherwise, you know, just manually change it to whatever it is that you desire. Same thing goes for the blueprint, especially when it comes to the models and the schemas. Does it fit your data structures? Is that the tables you want in your database? Is that the API contracts you want, and so on? Because that will all kind of go here, uh, depending on what you're implementing.
Then you have the list of tasks. So, here it will create quite, depending on how large your request is, it will create quite a large list of tasks. Here it will use information-dense keywords like find, inject, preserve, modify, mirror. These are all kind of designed for keeping the task description as concise and information-dense as possible, making it easy for the AI to understand what it is that you want. It will also add uh, pseudo-code when it thinks it's needed. So, some of the more complicated tasks will have pseudo-code as well in this lower section. So, this is also, check this out. Uh, when it's created, make sure that the task makes sense. Uh, because I don't recommend just running uh, the PRP creation and then just running the execution of it without actually double-checking a lot of these things, because sometimes, of course, it will do strange things. It will give you the integration points as well. So, this is also like a very important part where you need to kind of look into what it has created, make sure that you, sometimes you have to not do any change at all. Sometimes you have to change an entire route, uh, or another entire migration file. So, it's all depends here how you want it, and and how it fits your style, really.
Here we come to a really important part now, which is the validation itself. This is like, there's there's a few core principles of a PRP. It's the context, of course, uh, but one is also the validation. You want to make the AI run in in in loops until it has self-validated that what it has built is working. So, that's really what this is about. And the more ways you can create for your AI to validate its work, the better your result is going to be, especially with tools like Cloud Code and and Gemini CLI and and CodeX, which is what this is built for. Is like purposely built for uh, for those CLI tools. It will work in Cursor and Windsurf, but it will just be worse because Cursor and Windsurf are worse in that sense. There's more cost optimization built on top of the models that that makes this run like less autonomously. But yeah, so linters, checks, then you have the unit tests, which is like an easy, so these are like the two easy ways to do it: unit testing and linting. And here you can also set up your own rules in the linters and so on, which will help a lot. But yeah, make sure that they all pass, and it will run until tests pass and until linters pass. Then you have, if you're building an API, for example, it's very powerful to do integration testing with curl because it can run its own bash commands with curl. Some extra tips here that you can do. Say that if you're doing a test that includes like some deployment or deployment setup or Docker, use MCP servers. You can easily set up, I mean, I use Digital Ocean a lot, so I use the Digital Ocean MCP and the Docker MCP. So, I just have here, when I run something that that relates to either of those services, I have uh, a level four, which is like the MCP validation, where it, I will prompt it to check the implementation through the MCP servers and and also like fix it until it works. Then it has a final validation checklist, making sure that all tests pass, no linting errors, no type errors, manual tests successful, and so on. Then there's also like an anti-patterns to avoid in the end. And, uh, yeah, so that's kind of the template.
I will show you an example here of what this can look like when it's uh, executed. So, here's an example that I ran in a workshop I did uh, with Cole's community. So, I did a workshop there uh, and I ran one of these PRPs. This is from the base template on his MCP crawl for AI RAG. And I did it to like refactor uh, the structure of the codebase. So, it wasn't a lot of or any really function changes. It was just like, make it uh, less monolithic and split it up into files and modules. So, that's kind of was the purpose. This is more or less this is what I wrote uh, as my argument. If you, if we go back to this arguments, I didn't get very specific here, as it was just a, an example. And, uh, yeah, but it still, you know, fills out a lot of things. So, the goal here is to refactor the current monolithic codebase. So, there was two files with around thousands lines each into a well-structured vertical slice architecture of Y. It adds the Y. This is not something that I added. It added all of this itself here. Success criteria. This is something that I added though, because this is actually part of my Cloud MD, which is something I will show later as well. So, it uses the Cloud MD as well. So, if you have a very good Cloud MD, it will be even more powerful. Uh, then it gives, so you can see that context. So, what it does here, it uses my AI docs directory, which is where I will put library documentation for libraries that I know that will be used during the implementation. So, here I used UV. So, I part of the refactoring was to go from like pip to UV, and then I know that Cloud Code struggles sometimes with some UV setups. So, I just added this here to give it easy access to those. I know you can use some kind of RAG or context 7 for this, but I, I have not had very good success with context 7, to be honest. So, I prefer to uh, copy out the pieces of documentation that I know will be needed and put them in here, because then Cloud Code can use Grap and Rip Grap and so on to find those much easier than to to search through those RAG embeddings and and even the web search as well. Uh, so here you see it even references Cloud MD for the coding standards, which I have in there, or in this case, we were using Cole's Cloud MD because it was in his project, and I think he already had one set up. Uh, then, so Pydantic documentation by test and so on. So, this is like what it found itself through the through the web searching. And, uh, yeah, here was the, so the refactoring plan was in a markdown file here as well. So, it like basically had this sentence more or less.
Then we have the tree structure. So, there is like the tree structure that was before the refactoring, and here's the tree structure that it had after the after the refactoring. So, I did quite an extensive uh, modularization here. When I ran this, uh, it actually ran for way past when the workshop was over. So, I think it ran for 1 hour and 40 minutes or something like that, one of the longest runs I had had up to that point autonomously, and it created something like 300 plus tests as well. So, it was uh, chugging on for quite a while. It was working perfectly though, almost out of the box. I think I had to iterate like once to fix some some import errors and stuff, but it worked really well. Uh, there is actually a PR on uh, Cole's repository. Because if you go to Cole's uh, repository, you can see that PR that was created based on this run here. And, uh, yeah, so it gives, you know, the models, the tasks. So, here's like the task list. Quite a long one here. Pseudo-code, it didn't add here because it didn't need to. But then it had, or some actually had pseudo-code here, I guess. But yeah, it kind of decides itself where it needs pseudo-code and where it doesn't. Integration points, the validation loops. So, here it was using unit tests, linting. Let's see if it used something else. So, yeah, integration, just making sure that it ran. So, yeah, no like advanced validation gating here. Uh, also one thing that I want to say about validation gating, like if you're building a front end, use something like Puppeteer or Playwright, because then you can use level here. You can add level four or something, and you can say, use the Puppeteer MCP tool or use the Playwright MCP tool to test end-to-end the user flow or whatever. Click all the buttons, you know, all of that. And it will actually go and do that, open a browser, and it will click around and make sure that everything works, and it can read the console and and stuff. And that's like a really, really powerful self-validation loop that will ensure that everything works uh, before it is done.
But yeah, that's more or less uh, it for the template. Uh, and then we have also, so when you have your PRP ready, and when it's like written for you, and you're happy, you have read through it, and you're happy with the goals, what's the data models, the tree structure, everything. Then you have the PRP base execute command. So, this is what you run uh, after the PRP is created. I mean, I mean, I can show that just so, if you're not familiar with how you run the slash commands, you just do slash and then PRP, then I have base execute, and then I just pass the file. So, I just do copy relative path, and you, you just paste it in like that, and you run it, and it will take that into context. So, I'll just close this out.
Then we have the uh, instructions that it has here. So, yeah, implement the feature using a PRP file. Argument is a relative path to the file. Execution process. So, here, load the PRP. This is also like chain of prompts, chain of thought. So, to make sure that it's following the process that is intended. So, load it after it has gathered the context. So, this is like for gather context first. When you're done gathering context, do the ultra-think before you actually execute the plan. Create a comprehensive plan addressing all requirements. What this will do is that it will break everything up into these smaller to-dos. I used the to-do right tool and tracker implementation plan. I also have some experimentals uh, here going on for this to happen all in parallel with the batch tool. So, if you are interested in that, you can look into this experimental folder here where you have like create base parallel, create planning parallel. All of these like are more or less some parallel prompting techniques here. So, please uh, check that out if you're interested. Execute the plan, uh, validate, complete, and reference the PRP. So, it's just to make sure that it can, so sometimes when I ran this, like, I mean, I've been doing this for a long time. So, as the models get better, I can actually remove. So, probably a lot of this could be removed because as you can see through past all of these free files that you will be executing, there is some repetition here. But when the models were, let's say, dumber, like pre-Claude 4, there was a lot of, you had to like repeat yourself to, uh, really, really enforce the model to follow your instruction. But you can get away with less of that now for sure with Claude 4 and especially with Opus. But yeah, so this is like a way for it to make sure that it kind of references back to the PRP, and especially when it goes across context windows, because that's also something you can see when when you run really large PRPs, it will do one context window, do a compact, do another context window, and sometimes like up to five context windows I've done for experiment's sake. And then it will, after each compact, it will like re-reference the PRP and make sure that it's like has the context again. So, it's actually quite powerful. I'm very surprised at how good Cloud Code is at, uh, working across two to three context windows on the same task. It's like quite amazing, I have to say. So, yeah, uh, check that out, uh, as well. Like, try it out. Try to run it on some like ridiculous task and see what happens, because it's quite amazing, even if it's not perfect. It does a pretty good job at running long, uh, refactoring jobs and long setup tasks and and, you know, any kind of long job that you have scoped out in detail, it will execute and it will follow your guidance, or even its own guidance in in some sense, right? So, that's kind of the PRP framework.
There is a few other use cases here for the PRP. So, this base one is for, it's intended for quite large pieces of work. So, if you have like a small task, like a Jira task, or a GitHub task, or a GitHub issue, or a bug fix, or whatever, I don't recommend you to use this because it's, it's like intended for larger pieces of work. Let's say on the story at minimum, up to like a full PRD, so like a full feature. I've even experimented with like full PC or MVPs. So, it can do that too, but that's like more experimental stuff. If you don't want to go full-blown, right? You want to stay specific. But so then for that use case here, if you have like smaller pieces of work, you have the task. So, this is like a sliced-up version, you could say, of the PRP one. Still has a lot of detail. It could definitely be, I haven't used this a lot since Cloud 4 came out. So, there's probably a lot that can be stripped out here as well, but it's using a very similar process. So, chain of thought, it has that, the pattern, same pattern as from the PRP or the base PRP, and the sequence of how it should do it. So, like, yeah, uh, don't have to go too much into detail to that, but yeah, it has this PRP test template as well. So, it will like fill this out. Is like will make your say that you have a Jira ticket or whatever. It will make your Jira ticket complete with the full implementation plan because it will go and read and understand existing codebase patterns. It will create a file with all of the task descriptions, update, modifying an existing file. So, it will like document all of the steps that it needs to do. So, if it's a small task, it will kind maybe, you know, have one or two of these, sorry, these, this is like the implementation, so one or two of these. But if it's like a longer, a few chain tasks that are chained together, it might be again quite a lot of tasks, but it all depends how large your request is.
And then there is one more uh, use case here. I have a bunch of experimental ones actually that I will add in here into. So, in the coming days, there will be a lot of things coming into the experimental folder. So, specific ones for building MCP servers, specific ones for using specific libraries, specific ones for using different languages and so on. So, I've been using it for TypeScript and Next.js and React and Astro as well. So, those I will be putting in here because, as you can see on these, that they are very specific, or some of them at least are very specific to Python, because that's what I use the most. But I have been uh, dabbling more into TypeScript and and other languages as well to kind of test the framework out as well. But also, I'm building real TypeScript projects at this point as well. So, there is actually a base template for TypeScript here as well that you can check out if you're using Next.js or something that I know that many people are doing. And it has then, then you use this create base PRP TypeScript instead. So, there's no execution command for this right now, but you can just use the same execution command that is here. There isn't a lot of difference.
And then, let's see what else do we have here. So, yeah, the planning one is also very interesting. It's a little bit of a wide way of doing it because you can give your argument or your feature idea into the planning template instead, and that will create you your PRD. So, this is basically a PRD generator. So, if you have an idea or a PC or an experiment you want to do, it's quite powerful to get your first draft of a PRD. It will give you, also based on this template here. So, it will have, let's see where the template itself is. So, it will have, same like context gathering stuff and stuff like that. But yeah, it will have executive summary, problem statement, solution overview, success metrics, user story scenarios, and then primary user flows. Will have a bunch of Mermaid graphs here for the for the user flows, the user stories, the system architecture with another Mermaid graph, and it will have like each component that you will need, and backend services contracts, technical specification with another Mermaid sequence diagram, endpoints. So, yeah, I kind of like the contracts here, the data flow, uh, implementation strategy, uh, priorities, and, uh, yeah, a bunch of stuff that is like more gen-related to what you do before, uh, you do any kind of, uh, development work at all. So, so this is kind of to help you plan stuff. And, uh, this is also in create planning parallel, you have here in the experimental. This is something I use a lot actually when I plan a new piece of work, or especially like if it's a new project. I send out, you know, planning agents in every direction that I can think of to kind of come back to me with reports and so on that I can read and use that to create my first PRD. So, that's something that I highly recommend. Don't just run it blindly and take whatever output you get and and paste it in as a as a argument for your PRP creation, but use it as a research base because it's really, really powerful at doing research and creating those PR PRDs. But yeah, you need to validate it, make sure that it fits your use case and and that it creates something that you actually want to do.
Now, for the last thing I want to show you here is uh, the Claude MD file. So, I have a library here of Claude MD files. I have one for Astro, uh, that I'm using, uh, kind of daily. I have one for Python that I'm using, uh, kind of daily. The other ones, or the Next.js one as well, I use, but the other ones are kind of outdated, I would say. So, if you use those, read through them and make sure that they are up to date and that they follow your patterns. I think you can see that if you, this is like my core one. So, if you read through the core Python one here, you'll find a lot of things like that are specific to my use case, like my architecture, my patterns. Um, I use UV, for example. So, you might be using something else like Poetry or Pip. So, make sure that you change those things around if you want to use this template, uh, so that it kind of fits your use case. And and one thing that I want to say about Claude MD files as well is that as your project matures, you really want to make sure that it matures with you. So, put project-specific instructions in your Claude MD, and you will see exponentially better results working on that specific codebase.
So, yeah, something that, uh, I hear a lot of people say about Claude Code specifically, or other AI coding assistants, is that they are not good at working on large existing codebases. And I think, I mean, I highly disagree. The reason being that in a large, mature codebase, you have existing patterns. So, if your codebase has good structure, is modular, is easy to read, your AI assistant is going to do extremely well in that codebase. So, it's only if your codebase is a mess that AI is going to be a mess in that codebase. So, set up your codebase in a way that's going to be easy for both you to understand and for your AI to understand, because you want to be able to easily help your AI assistant find what they're looking for. If you, you know, make them go look for something in your codebase and they can't find it, you need to be able to point them in the right direction, and that's something that will help you a lot in in debugging, especially. Uh, so, yeah, I think, uh, I don't really have anything more to go through.
I have one, uh, thing here that I was thinking about maybe kicking off. So, yeah, this is how I usually run things. I have my four windows of my Ghostly terminal here with the four sessions. Then I usually have another, some other session here going in the, why can't I move my window manager crashed, I guess, but yeah, so then I usually have like my core workflow running, my development workflow usually running in my IDE. I have just traded, actually, I switched from Windsurf to Zed recently, but I have this project specifically I'm using in Windsurf because I have a lot of MCP servers and stuff set up that I've been using that I haven't set up yet in Zed. But, uh, yeah, so here I will just, uh, show you. And this here is a, is a mature codebase. It's quite a large codebase on, uh, for a voice AI, like, agent. So, there is like a good chunk of code in here. I don't even know, but a lot of code. And, uh, I'm planning to actually kick off one, uh, PRP here. So, I'm just going to show you how I do that. Execute base PRP. I have my PRP prepared in my PRPs directory. It is called 11 Labs. So, the whole idea is to integrate, uh, 11 Labs as one of my voice providers. I have already several voice providers in this codebase. So, one of the core things it's doing is that it's mirroring existing voice pipelines and it's just adding 11 Labs as another voice pipeline and adding it to my configuration for how I run it in the CLI, how I run it in the API, and so on. So, all I really have to do, I don't have to say anything, just execute. I have already prompted it through my PRP and research, and yeah, here you can, I'm not going to show you this PRP because there is some, uh, business, uh, secrets here that, that I cannot share. But yeah, you'll see some of the things that it kicks off here. It will go and, uh, yeah, start gathering the context. You see it's starting to read everything and start gathering that context for starting to execute things on the codebase. Yeah, it will do quite, quite a lot of research before it starts.
And, uh, yeah, one thing that I also highly recommend you doing is that between the creation of the PRP and the execution of the PRP, you really want to use a new instance of Cloud Code, or at least the slash clear command. Because if you do your planning and then execution in the same context window, for example, you will run out of context really quickly. But even a larger problem that I have seen and have had several times is that it will assume a lot of things because it thinks it, I have already done this research, so I don't have to do this again. And in that, a lot of hallucination is created, actually. So, always run it in a new, clear instance of Cloud Code when you do the execution. And you can see here that it's starting to work now. It has created its, uh, to-do lists and it's ready to, uh, to start. So, yeah, uh, I'm going to go back here and I'm going to let that run. And because I think, uh, actually I'm going to see, I need to, and I actually, so this is one thing that is also is a good example here, because this is something that it runs into quite a lot. So, I'm going to say, do not edit by project tunnel, use U, add instead. And then I'm just going to let it run here.
But yeah, so that's uh, about my PRP framework. A lot of things to come here. So, a lot of things that I have been using in in different projects that I will update here. So, make some slight changes to the templates that I have in other projects. So, yeah, I'll be tinkering with this and and when I do updates on how I do things, I will commit those same updates to this, this repository. So, if you're interested, please follow along and let me know what you think. And yeah, so yeah, if you want to as well, uh, I have uh, two things here. So, I spend a lot of time, this is kind of like my, what I do in my free time. I write these prompts and I research how to use Cloud Code and other coding tools. So, if you want to, if you find value in in this and want to support me, please consider donating through this link here. And also, I have, uh, recently starting to run, uh, workshops. So, I've been running a couple of workshops with companies, but also in in Cole's community on agentic engineering, and you can find more information about that on my website. And I actually just yesterday opened up, uh, early bird tickets to the next, uh, online workshop. So, very similar to the one I did in in Cole's community here, you can go to my website and you will find this. So, you can sign up here, and if you add your email address, you will get access to this price. So, this will run until the 1st of August. So, after the 1st of August, it will be 250, and I will be announcing the dates, uh, around the 1st of August as well, because I haven't set the exact date yet. So, once I have the date, you will be sent an email with your coupon code, and you can sign up if you have registered before the 1st of August. So, yeah, please check that out. And also, if you have a company and you want to do this for your team, you can also, uh, give me a message, and we can talk about how I can help your team to to do a full-day workshop or a half-day workshop on agentic AI as well.
So, what you would learn in this workshop is, first of all, I'll go through a little bit about PRP, but it's not about PRP. It's about engineering, uh, agentic engineering principles that you can take and use for your specific use case. PRP will be somewhat the base for that. We will build a couple of, uh, at minimum, it will be one MCP server and one agent using that MCP server. We will be using Cloud Code. And we will learn about multi-agent system or orchestration patterns, how to set up guardrails and evals, and also you can also meet other professionals through this and and learn about their journeys as well. See that and a lot more. So, there's a lot of things in this workshop. We'll learn how to run parallel, how to run in different work trees, how to run in, like say, YOLO mode, so that you can run it on in different work trees without having to interact with it at all, and just look at the output when it's done. So, yeah, that's uh, some of the things that you will learn in this workshop.
But yeah, with that, uh, I think I am done for today. So, uh, thanks for for listening, and I hope this gives you some value. And and I, I know a lot of people have been asking me about this in the last couple of days, especially since Cole, uh, posted his video. So, really, really appreciate uh, the feedback I've gotten already, and and consensus seems that a lot of people like it. So, I'll continue keeping it updated. I'll add more things as I discover more things. The next thing I'm going to be looking into is the hooks feature. I've been on vacation uh, now, so I haven't really looked into the some of the new features in Cloud Code. And, uh, yeah, uh, when I do that, those things will also be added to this repo. So, uh, yeah, follow to stay up to date on the latest stuff here. Uh, I try to learn about everything new that comes out, especially that's concerning Cloud Code and and other CLI tools. But yeah, thank you, and uh, see you soon again.