opencode skills tutorial

You want a better way to do lazy context loading and maybe run a few scripts in open code and you're trying to figure out what's the best way you can do this similar to claude code skills in open code. If so, then this video is for you. We're going to be tackling Open Code's new skill feature that just dropped a few days ago. I'll talk how you should set up skills, the limitations, and some interesting examples of how you can actually think about customizing skills for different parameters.

Anyway, let's jump straight in and let's go. All right. to start with every video. If you want to find where the documentation for all of this is, just go to the open code docs, scroll down, and you'll see this agent skills feature.

This was released literally about 3 days ago. I'm just going to jump into it quickly. So, it's very similar with every other open code feature. It's a single um file got open code skill and then name skill.md.

This is the most important thing to note. It's you have to do the skill.md part and this is the actual main skill name. So when you're defying defining it into your MD or your config, it's this name that you need to use. Just just keep that in in notes.

It's a little bit confusing, but it's important to note that's how the skills is. So it maps to this name and then apps to that skill ID. Not the best, but it works. All right.

We also need to talk about discoverability with skills. So to start off with it looks in your your local project. So it'll start it'll look for any file in a skill uh folder. So essentially if it's inopen code it will look for skills and then it'll look for that skill.md.

And if it's in a doc claude it will also look for that skill.md along the way. And then lastly it will check your globals to see that it is there. And this is all loaded in to open code. One thing I do want to state is all skills are available to all agents.

What how open code is handling it, they're not loading the context from the initial prompt, but they're telling the agent, hey, they can use a tool to actually search for the available skills that are available to it. So very important to note if you do want your open code session to use a kind of skill you're going to have to specify your skill and then the skill name and then it will do use the tool to search for the skill and then load it into context. So it works a little bit differently than claude but hopefully you understand what I'm talking about. All right just to jump to the code.

This is have a quick look. So, I've got this uh open code skills folder bin here, and this is a way for me just to demonstrate how skills are made and some different concepts that you guys can consider. Essentially, I've got a few different skills. I've got hello skill, uh step skills, t skills, workflow skills, and smart routed skills.

Essentially, each of these is just a way I can demonstrate how you can think about using skills in a different variety of manners. But essentially, hello skill is exactly what it sounds like. It's actually a skill that runs a bash command. It says hello from tier one skill.

And the next one is step skills. So this is a way I can show you how to run certain things from a directory. So we can see we've got a script here and we're just telling it how it should run the script, where it should run from, and then just bash script essentially. And that's how it works there.

Then workflow skills is essentially how do we run certain skills in sequence? Can we define it here and will it follow it? And this is correct. TS skills is how do we run like a TS for example?

And if I open this TS, you actually see there will be some syntax errors because there is no bun runtime. And that's it's in this folder. So you'll see in the skills here, we're telling it, hey, go to the base directory and then run it. And then that way it should pick up the button package right there and run it with not a problem.

So you might have to equate for the different packages or different scripts that you're running that you have the right you know environment to run it like so for example if you're trying to run Python you might have to instantiate the Python environment and run it etc. So, and the last one is the smart router skills. Essentially, this is a smart way I want you to think about how you could dynamically render different uh context or allow skills to change the way your agent works for a sub uh section. So, everything works with the skill.md as I discussed earlier, but let's just have a quick peek.

Essentially, what it is is it's a character selection. So you can choose from Yoda, Tony Stark or Sherlock Holmes. And depending on what's configured, it'll have a different outcome that goes through. And you'll see here I've got this config folder.

And in this config folder, I've got a mission and I got mission one and two. So depending on what's uh defined here will determine how the rest are interaction. You know, what the rest kind of interact with. How does it pull that out?

So essentially it just allows us to dynamically alter how the skill will work. And then lastly with all the skills is how do you add this to an agent? Well, so this is take my codebase agent. This is from the open agents repo.

I just use this agent if I'm starting with any repo. I just like working with it and this is a quick easy one I can grab. But essentially you'll see there is no skills defined in here. What you'll find is open code pretty much has like a skills like this and then it's pretty much it allows all skills from default.

That's pretty much what it looks like under the hood for open code. So it actually goes and picks up the skill definition. So when you're writing these descriptions here, this is actually pulled into open code and you depending on how many seals you can have that's loaded into context. So they say it's not going to add too much.

Not a big fan of just adding things unnecessarily to context, but that is how open code is doing it. Cloud code does it the same way is it injects the definition of the skill and what the skill name is to how to the agent so it knows that it exists so then it can invoke it. So that's kind how it works. So let's have a quick look you know just to make sure my claims are true.

So let's just quickly run open code here. So, I'm just going to fire up the terminal and I'm going to run open code and I'm going to go to my codebase agent and just to make sure I didn't leave that in. Yep, no skills are there anymore. So, great.

And I'm just going to go to the codebase and I'm going to say uh what skills uh do you have access to? All right. And it's pretty much just going to tell us all the skills that we've got defined [clears throat] here. So it's literally told us the hello skill which is here.

It's got the step skill, workflow skill, TS and smart route. So all skills are getting picked up there. So if I just exit that, I'm going to run open code again. And this time instead of running uh the codebase, I'm actually going to go to got two different ones.

I've got the small and the main. So this one skills demo agent without the small at the end. You can see pretty much has access to all skills. So it's pretty much the same as the codebase agent but we explicitly define defining it.

One thing you will notice here is I haven't defined the smart router skill but by default it will be picked up regardless. So just to show you this. All right. So if we just go to the skills demo agent.

So which skills do you have access to? And we can see it's pretty much giving us the same output. All right. So lastly, I want to run open code once more, but I actually want to go to the small agent.

There's a few key differences here. You'll see I allow it to have access to three skills, but I denied access to two two skills. So let's just have a look if that's the case. So if we go to the small, you can see here it's the small and I'm literally going to ask it the same question.

And we can see it only giving us act these three skill names back. And it's telling what it's about and the smart router. All right, I'm going to tell it to use the first skill. Hello, just so we can see how it works.

All right, and we can see here it executed our hello script command and it's got that tier one skill. And this is to make sure that works. We can see this is exactly what it ran. Perfect.

All right. So now the other skill was let's see we said it was a TS skill. All right. So this is running this one and what did this do?

This just pretty much ran our example TS from bun and this just executes a few different things here. So let's just test this that this works. Please uh use the yes skill. All right.

And there we go. And we can see it's running. It went to our open code and it just ran our example and it ran without any issues right there. And that's the the skill in action.

All right. I'm not going to show the the main one right now cuz I want to leave that to the end. All right. So, I'm going to open code once more, and I'm going to go to the the main the skills demo agent here, and I'm going to ask it to run [clears throat] the step skills because that's the one we haven't seen yet.

So, I'm going to ask it to run the step skills. Um, oops, I ran the wrong one there. All right, we're going to go to the skills demo agent here, and we're going to say, uh, what skills do you have access to? And we got everyone.

So please uh run step skill. And we can see it it's running each skill in parallel. So it's running our steps.sh. So if we go here, it's just running that.

All right. So this asks it to run the workflow one. All right. So we're going to want run the workflow skills here.

And we can see if we just scroll up because it runs quite quickly. It will run each script in our order that we define. Script one, script one, run, script two, uh, script three, script four, and lastly, script five. Oh, sorry, only there's only four scripts here.

So, we can see it ran all four scripts and it executed it there. Perfect. All right. Now, so we've shown all these except for the the main one.

I want to leave that to last. But if we go here, if we go to the small, we can see I denied a few. This actually tests if we can run this, you know. So this asks you to run the step skill.

So I'm going to just change agents to the small here to see if we can still access it. Because this is in context, I want to actually I'm very curious to see if we can run the skin. So I'm going to tell it to run the step skill. We can see it's still got the skill in context.

So we understand tabbing through doesn't work. But if we go new now and we ask it, hey, run the step skill. Does it actually work? No, it ran the wrong one.

So it ran the TS skills. No. All right. And here we can see right here access was denied.

I had to explicitly tell it hey run the steps skill and it tried to access it and it was denied and that was done through our permissions here and that was done through those permissions here. The same will work if I do with workflow skills. Only difference is if I can't change agents with the tab expecting it not to have access, especially if it's already accessed that information and pulled into context. This a good key thing to note.

Another thing I also want to state um if you are working with skills, this is something I run into, but you'll see this indentation here, especially in the YAML. If the skills is not correctly indented and everything below, open code does not tell you there's an error with skills. It will just work regardless and just assume that all skills are there. So be very careful when you are setting this up that it looks exactly like this.

All right. Lastly, I actually want to run. So I'm just going to go a new one here and we're going to go to our small again. And I actually want to run the smart routter skills right now.

And we can see we've got this mission as one. And I think I'm going to ask to go as Yoda. All right. Okay.

Smart. All right. So, we can see it's loading the smart news. And it's telling us to choose character Yodas, Tony Stark, or Sherlock.

I'm just going to say one run as Yoda. And we can see. Okay, it's running. It's okay.

Personality, Jedi Council. Uh, phase one, train the patter ones. Phase two, fortify the temple, defenses, council, strategy, session, mediation, ready to defend the public. We are perfect.

Okay, so we can see it's run through of different things. It's defending the republic. But now, what happens if we change this config here? All right, we come here and we change this to two.

What happens now? All right, so let's just see. All right, so it's telling us to to choose again. I want to choose Yoda.

So I'm going to just tell her, hey, one. All right, but now we can see loading Yoda's personality. And we see, hey, undercover operation, infiltrate the Sith, study the dark side, establish a cover identity, gather intelligence, prefer for extraction, and it was undercover. And that was all done through that variable here.

We just changed this mission to two. So the first mission was defend the republic and the second was infiltrate the uh the Sith. And if we go to the scripts here and we go to Yoda, we can see if mission was one, this is what it ran. And if mission was two, this So we managed to dynamically make this happen.

And again, this will work with any of the characters that we talk about. The only only thing is we kind of have to tell it to run the the skill again or it can just run the script and the script will pick up the config. But hopefully you guys get get the the idea with this. So I just wanted to show you how you can make this dynamic skill work for different use cases.

But again, this is all determined by the agent. So if your agent is not smart enough to understand your skill prompt here, it will not execute in that order. And again, if you are over context loading it, it might not perform the way you want. And you're also injecting to whatever agent you have that consumes the skill and then acts on it.

So there's a lot of little different variables that you need to account for when running skills and how the agent actually uses those skills. So you want to maybe you know do incremental tests and not load all the tests uh all the skills at once in one agent and hope it performs the right skill at the right time. Especially if skills are very closely named to one another, the agent can get confused. Anyway, I hope you guys enjoyed this quick introduction to Open Code Skills, how you can think about it, and how you can actually personalize it for your own development.

Anyway, I'm going to leave uh the link to the repo down below. And please, if you find these videos use useful about Open Code, please hit that subscribe button. The support is really well welcomed. And thanks again so much for watching.

And I'll see you in the next video. Thanks.

Claude code has been getting a lot of attention lately, but it's not the only AI coding tool worth using. Open code is growing in popularity and for good reason. It's 100% open source, it supports multiple providers and models, including free models, and it gives you an incredibly powerful agentic coding workflow right in the terminal. In this video, I'm going to show you everything you need to know to get started with open code from the initial setup to learning advanced features like agent skills and CP servers, sub agents, background agents, and real project workflows.

By the end of this video, you'll know how to use open code as a serious alternative to Claude code. Let's jump in. The first thing we need to do is to install open code. So, you can just go to open code.ai and from this page, simply go to the installation instructions and they've kept the setup process extremely simple.

You can simply copy this curl command over here. Then, you can simply open up your command prompt or terminal, paste in that command, and press enter. And it will only take a few seconds to install open code. Beautiful.

Now that we've got open code installed, in order to start open code, we can simply enter the command open code and press enter. And that's it. Now, we've got access to open code. Now, when using open code, I do recommend opening it up in a project folder.

So, you can just open up your terminal window, first navigate to that folder, and then start up open code. Or, something I like to do as well is to start open code from a code editor like VS Code or Cursor. This is definitely optional, but the benefit of doing it this way is I can easily see any files that are being created by the agent. But, if you just want to use the terminal window, that's perfectly fine as well.

So, within our project folder, let's start up open code. So, the first thing we need to do is to connect open code to any provider that we're planning to use. So, what we can do is enter front slash interconnect, which will run this connect command. Then from this list of providers, we can search for a provider or go through the massive list of providers that I do support out of the box.

Now, this might be enabled by default, but I do recommend connecting to open code Zen. This is basically their own gateway for calling models, and this does give you access to free models by the way. That's why it's definitely worth it. So, I just look for open code Zen.

Then this is not going to cost you anything. We just have to hook up an API key. So, I'm just going to open up this URL. Then from this dashboard, we can actually view our usage.

We can set up any billing details. And just to prove to you that these models are free, my balance is actually $0 at the minute. So, let's go to API keys. Then let's actually create a new key.

I'll just call this one open code masterclass. Let's create it. Then let's copy this key and let's pass it to open code and press enter. I am going to delete that key, so please use your own.

After we sign into a provider, we can select from the available models for that provider. Now, as you can see, there are actually free models in this list like Big Pickle, HY3, Minimax 2.5, and NeMo Triton 3 Super from Nvidia. Now, I do want to mention that with free models, there's always a chance that they might be using your prompts to train these models. So, if you just want to try this out for free or follow a tutorial, you can definitely use the free models.

And I will show you how to hook this up to an actual paid service as well. For now, I'll select Big Pickle, and now we're back to this chat interface. Let's just say, "Hey." And we do get a response back and it didn't cost us a thing. So, at the moment, our project is very empty.

Let's ask our agent to scaffold a new Next.js project. Please can you set up a new Next year is project? Use the NPX command. And I'm actually just going to add to this as well.

In the current working directory, there's always a chance that the agent might actually install Next year is into some kind of subfolder. All right, that's good enough. Let's send this. And as you can see, it's running the NPX command to install Next year is.

And if you have a look at our file system, we do indeed see our Next year is project. Let's see if Open Code can also run commands. Please start the dev server. And indeed, it's actually starting the dev server on port 3000.

And cool, our Next year is project is running. All right, so we can actually interrupt the agent by pressing escape. If we press escape again, we've just interrupted this agent. So, what I also want to do is actually clear the conversation by entering \{{}forward slash} new.

And now we've got a fresh session with a fresh context. If you ever want to resume a previous session, you can simply type the sessions command. And we can see that earlier today we started this conversation. And now if we wanted to, we can simply continue with this chat.

But I do want to start with a new conversation. And for the rest of this video, I'm actually not going to use a free model. Instead, let's connect Open Code to a different provider. So, I'll run the connect command again.

Now, in order to connect Open Code to a more intelligent model, you can select a provider like OpenAI or Anthropic or Gemini, whatever you want. Now, here is something you need to be careful about. You do have two different ways to pay for inference. You could pay for APIs, or you could use your existing subscriptions with one of these providers.

As an example, if you want to use something like Anthropic or Open Router, you could provide your API key, and you will be billed based on your token usage. So, it's kind of a pay-as-you-go option. But honestly, I think that's the most expensive option out there. I would not recommend using API keys, especially for coding tasks.

Instead, use your subscriptions. Now, unfortunately, Anthropic is not supported yet. And if you are in the know, you know that Anthropic is banning pretty much anyone who's using their service and their subscriptions. And it's not limited to open code only, they're banning all sorts of tools like open claw as well.

So, to be on the safe side, I would recommend just hooking it up with open AI or maybe even something like Kimi. But personally, I'll be using open AI. From here, we can select our auth option, like ChatGPT Pro or Plus. This is referring to our subscription.

So, if you do have a Pro or Plus subscription, choose that option. The third option was to provide your API key, which I just would not recommend. Then we can open up this URL in the browser. Let's sign in with our account.

Let's continue, and done. Now, we can select a model that we would like to use. Let's go with GPT 5.5. And by the way, if you ever wanted to change your model, simply enter the command \{{}front slash} models.

So, let's click on that. And now we can select from any of the available models. We can also search for models, so we could just search for GPT 5.5. So, I'll select the one from open AI, and that's it.

Now, at the moment, we are using GPT 5.5, but with medium reasoning effort. If we ever wanted to change the reasoning effort, all we have to do is run the command \{{}front slash} variants, which gives us reasoning effort specific to this provider. For GPT 5.5, I'll go with high reasoning. Now, before we build our project, I do want to assign certain agent skills to this agent that will help it produce even better results.

Now, if you're new to skills, skills are just a really cool way that we can add additional capabilities to our agent. Skills are nothing more than very detailed instructions that the agent can follow to get very specific results. There are basically two skills that I would recommend installing into a project like this. Since we're building a web application, we want to give this agent the front-end design skill.

Now, the easiest way that I found to explore and install skills is with this website skills.sh. This is a repository of nearly 100,000 skills. So, you can simply search for skills, but you can already see from the all on favorites that the front-end design skill is at the top of this list. So, let's actually copy this command.

Then back in our project, I'm just going to open up a new terminal window, and let's install that skill. Open code is not in this list, but that's not a problem at all because it uses the standard dot agents folder for retrieving skills and anything that we want to attach to it. So, I'm actually not going to select anything in this list. Let's simply press enter.

We'll install this at project level, and let's proceed with the installation. And just to show you what this did, it created this dot agents folder, which is a standard convention for the majority of coding agents out there. And within the agents folder, we've got this skills subfolder along with our front-end design skill. This contains a name for the skill, a description on when to use the skill, and just a very detailed prompt on building beautiful user interfaces.

Since we are using Next.js, I do want to install one more skill, and that's the Next.js skill from Vercel Labs. Let's copy this command, and I'll just run that in the terminal as well, just like how we did it with the front-end design skill. We don't have to select any of these tools. We'll install at project level, and that's it.

So, now in the skills folder, we've got our front-end design skill and the Next.js skill that actually contains a a of reference documentation for using Next.js. Now, our app will have AI functionality baked into it. So, I'm actually going to be proactive and install the AI SDK from Vercel. So, again, just search for AI SDK, copy this command, and let's install this skill as well.

So, we can just verify that the agent has access to all of those skills by running the skills command. And here we can see our front-end design skill, the AI SDK, Next Best Practices, and Next.js. So, some of these skills might actually be stored in my user folder, but for you, you should definitely have those three skills available. Just a side note, if you don't see any skills, what you need to do is simply exit out of Open Code by running \{{}slash} exit, and just reopen Open Code, and now you should see all of those skills.

So, I'll just switch my model back to GPT-5.5-High, and what I'm also going to do is just go to source control and create a commit. Added skills. Nice. And by the way, if you click on this Open Code logo, you get this effect.

Another important component to understand is memory files. So, in the root of our project, what we can do is create a new file called agents.md. Now, I already have that file available, but if you don't have it, you can create it yourself, and that file looks something like this. I'm actually going to delete everything that's in that file at the moment, and this is where we can tell our agent all about our project and provide very strict instructions.

This actually forms part of the system prompt for this coding agent. So, if there are any specific rules that you want the agent to follow, this is where you need to add those. Now, if you want Open Code to set up that file itself, what you can do is run the command \{{}frontslash} init, and what Open Code will do is scan code base and then automatically create and set up this agents.md file. And once this is done, we now have our agents.md file with some instructions just kind of detailing the layout and tech stack in this project.

Now, what I actually recommend you do is just clear out this file and add as little information as possible. Only provide any strict instructions that the agent needs to follow. And let me show you how powerful this really is. Let's do something very simple like respond with emojis only.

That's it. And now if I send a message like, "Hey, how are you?" the agent responds with emojis only. So, this really is a critical file. If the agent is doing anything you don't like, just add a rule to that agents.md file.

You'll thank me for it. What we are going to do is change this agents.md file drastically. What I'm going to do instead is add all of these rules to the agents.md file. I do want to mention you can access all of this for free.

I'll link to the GitHub repository in the description of this video. So, if you want, you can simply copy my agents.md file and follow along. So, what I like to do is to add this rule, "Keep your responses concise and to the point." Sometimes these agents are way too chatty and we are paying for the tokens. So, I prefer short and concise answers unless I ask otherwise.

Then when the agent is in plan mode, it must ask clarifying questions. It should never assume design, tech stack, or features. And if available, it must use sub agents or background agents to assist with things like research. And it should also use background agents to review the different aspects of the plan before presenting it to the user.

When the agent is in change or edit mode, it should never implement features itself. It should always use sub agents. Now, there's a really big reason for that. We want to protect the main agent's context window as much as possible.

You will notice that even though this conversation is really short, we're already taking up like 10,000 tokens or 3% of the context window. And at some point, and usually past like the 50% mark, we start reaching the dumb zone of these agents, where the quality just worsens very quickly. So, by using sub agents, we're telling this main agent to delegate working tasks to sub agents. And then those sub agents will only give back the final summary of what they did.

That way we're keeping this main agent's context window as clean as possible. Also, identify any changes from the plan that can be implemented in parallel. When using sub agents to implement these features, act as a coordinator only. Use the best model for the task.

Use premium models for complex tasks and mid-tier models for simpler tasks like documentation. After completing features, always run commands like lint, type check, and next build to check code quality. Now, this might not be relevant to our application necessarily, but if we had a database, we could enforce some database rules as well. And if you do have some testing framework or tools, we can have some section enforcing testing as well.

Now, for the UI design, you must always follow the UI design system when creating or reviewing components or pages. If you've ever had that issue with agents where the UI is not consistent across the app, you can simply use this approach to force it to use a very specific design system. So, it is linking to this design.md file. So, I am going to create that file in this folder called design.md, and I'm actually going to paste in this design system.

And this just gives a lot of details on the, you know, colors, like the primary colors and borders and spacing, stuff like that. Again, you can download all of this from the description as well. And I actually have a lot of videos on building design systems that agents can use. Excellent.

So, just to make sure that everything does take effect, I'm actually going to create a new session and that should pull in our new agent.md file with all of these new rules and conditions. I'm also going to create a commit called memory files and design system. Right. Now that everything is set up, let's start building our actual application.

So, this is going to be a fun one. But first, a quick word from today's sponsor, Centra AI. And I think you're actually going to care about this one because they solve a problem a lot of us have. Let's be honest, if you've been following the agentic coding world, you know that shipping software is faster than it's ever been.

You can go from idea to working product in a weekend with Claude code or Cursor. The building part is basically solved. But then the product just sits there because the hard part isn't building anymore, it's everything else. The social posts, the launch emails, the newsletters, the product update announcements, stuff most of us didn't sign up to do.

That's where Centra comes in. Think of it as the other half of your business. It's a team of AI employees. Each one trained as a specialist for the non-coding parts of running a product or business.

I've been using two in particular. First is Soshee, the social media manager. I can tell Soshee about a new feature I just shipped and she'll generate a week of posts across platforms in my voice with my positioning. I review, edit what doesn't feel right, and approve what does.

The second is Emmy, the email marketer. I ask it to draft a product update email, she pulls context about my product from the Brain AI profile, and writes the first draft. I shall edit it. It's not magic, but it still beats staring at a blank email.

There are 10 other helpers covering SEO, customer support, copywriting, data analysis, and more. And there's a 14-day money-back guarantee, so you can try the full team risk-free. Head over to centra.ai/leon van sale. Link in the description or use code leon van sale at checkout.

You'll get an exclusive limited time 72% off on all plans. That's Code leon van sale for 72% off. Thanks to Centra for sponsoring this video. This app will allow the user to pass a rough idea of what they're trying to build, and our app will then suggest a tech stack and certain aspects about the application.

And at that point, we can kind of fine-tune them using the UI itself. And by the end of it, we'll have a prompt that we can copy and pass to our coding agent. It's kind of a design tool or a spec tool where we can plan the project before handing it over to our agents. We can switch modes by holding shift and by pressing tab.

This will switch us between bold mode and plan mode. You'll also notice that there are different models for plan mode and bold mode because sometimes you might prefer one model to do the planning and another model to do the actual implementation. So, in planning mode, I'm actually going to pass this prompt. Again, you can just get this from the repo itself.

But just to go over it, we're building a lightweight AI project planner app for this tutorial. The app should let a user enter a rough app idea, then generate an editable project brief with the app summary, the target users, core features, a recommended tech stack, the pages and routes, a possible data model, the bold phases, risk and edge cases, and a final copyable starter prompt for a coding agent. And then we'll keep the scope small, so no user authentication, no database, no payments. It's just a simple Next.js application.

I'm actually just going to switch out one thing here to say that we will be using the AI SDK with OpenRouter for inference. And then there's one more thing I would like to add. For the data model, it would be cool if you could visualize the relationship between the different entities as well, perhaps using React Flow or something. All right, I'm just going to copy this prompt.

Back in Open Code, let's paste in all of that. In fact, we do have to change the model. I definitely don't want to be using Ollama for this. I do recommend for planning that you actually go with the most intelligent model that you have access to.

If the plan is detailed enough, you can actually use a less intelligent coding model. So, for this, let's just paste in that prompt again. And let's send this. All right, this is a promising start.

We can see that the agent pulled in the AI SDK skill, Next.js, and the front-end design skill. And you know what, since we are using Shadcn, what we can also do is install the Shadcn skill as well. And that's kind of normal for my process. As I'm adding new frameworks and capabilities, I do like to look up an official skill for that framework or tool and install it into the project.

And now the agent is asking us a few clarifying questions. For the first implementation, should the AI response be generated all at once or be streamed section by section? I think all at once. Should drafts persist only during the current page session or restore after refresh using local storage?

Let's go with local storage. How interactive should the data model visualization be initially? It's a read-only graph. I think it should just be read-only.

All right, let's confirm these. All right, we've got our implementation plan. No files were changed. All right, that's cool.

Confirm choices. Here we've got our architecture. We have to add a few dependencies, which is 100% correct. We have to install the AI SDK as well as the open router provider for the AI SDK.

We install Zod for schema validation. And for visualizing the data model, we will install React Flow using this package. And this seems very cool. We do have an open question though.

Which open router model should be used as the default? If you don't care, I'll use an environment variable like open router model with a reasonable default documented in .env.example. Well, actually what we'll do is let's find a model that we can use. I'm thinking that I'm simply going to use Sonnet 4.6.

So, let's copy this model name. For the model use Anthropic Claude Sonnet 4.6. And let's send this. All right, we've got this plan, but this is actually just stored in the session at the moment.

What I like to do is to persist this plan. So, in this .agents folder, I'm going to create a new subfolder called plans. And then what we can do is switch over to bold mode. And I'm going to pull in the location to this plan folder.

Please don't make any code changes yet. Please store this plan in the plans folder. And done. So, in the plans folder, we now have our implementation plan over here, which means we can now refer back to that plan in the future.

It also means we can now clear this context by creating a new session. Let's pull in this plan. And then while we're in bold mode, let's say, "Please go ahead and implement this plan." That should actually be enough. Let's [snorts] send this.

And if it follows our agents.env default instructions, it should now split the plan up into tasks that can be executed in parallel and then run background agents to implement this plan. Let's see. I'll read the implementation plan and project structure first, then split any independent work across sub-agents where it makes sense. Perfect.

This is such a cool workflow. Nice. So, it's created this to-do list so we can see exactly what the agent is planning to do and it's currently installing all of these dependencies. While the agent is busy figuring out this plan, we do have to set up our open router API key.

So, in the root of the project, let's create a new file called .env. And what the .env file allows us to do is to store any sensitive information. So, this is typically stuff that shouldn't be deployed to GitHub or, you know, to some repository where anyone can view it. This is perfect for storing API keys.

So, what we'll do is create a new variable called open router API key. Then I'll go back to open router. I'll create a new key and let's just call this AI project planner. And let's create the key.

Let's copy this and let's paste in that key. That's it. We're done. This will allow our application to interact with AI models.

And also, by the way, if you were wondering if you can create your very own custom sub-agents, yes, you can. So, by default, if we go to /agents, we have a bold agent and a plan agent. But we can add our very own custom agents as well. Let me just show you how.

So, I'm going to open up a new terminal session. Then let's run the command open code agent create. Well, just create this agent in this local project. And now we can give a description of what this agent should be able to do.

So, I'll just say call it coder agent. I don't know, just for fun. Let's pause that. And this will generate a new agent for us.

So, if you do want to create agents that specialize maybe in only UI design or coding or testing or documentation writing, you can definitely do that as well. And our main agent is making a lot of progress here. And as this tool tip says, if you want to see what the sub agents are up to, we can press control and X and down to view our sub agents. So, we're currently be looking at the general agent and if we press right, we can see the explore agent.

And if you press right again, we can see the other explore agent as well. And then we can simply press up to view our general agent. All cool. So, the implementation is complete, so I'm going to open up a new terminal window.

And let's manually start the dev server by running npm run dev. And this is what we have. So, not bad at all. We can enter our app idea and hopefully on the right-hand side we'll see the AI results streaming in.

So, we even have a few example prompts. Let's go with a meal planning app for busy parents that creates weekly grocery lists. Let's click on generate brief. So, this is actually taking a very long time to get a result back.

So, it could just be that the model was taking a lot of time to generate the results, but it would be ideal if all of these sections would kind of stream in as they become available. And it took a minute or two, but we got our result back. So, we've got our brief. The app name could be weekly bites.

And the cool thing about this is that we can make changes by the way. So, if we don't like weekly bites, we could make this, I don't know, weekly meals. We can edit the summary. We've got our target audience.

Then we've got this JSON array of all the different core features. We also have this recommended tech stack. So, this is recommending Next.js with Tailwind. All right, that's cool.

Pages and routes, and we've got the data model. So, everything is here, but instead of showing a JSON array, I would actually prefer something different. Maybe nice visual cards instead of an array. Also, at the bottom, we can see this data model graph.

So, for any of those of you who are interested to see what the database or what the data models look like, this is kind of a nice way to just kind of visualize those relationships. It's taking a long time to see any results coming in. Please could you use the AI SDK structured output streaming to stream in sections as they become available. Also, I don't like that you're representing the data as JSON arrays.

Show cards instead. They translate to JSON behind the scenes that the user can easily edit, add, or remove. I think this should be good enough. Let's fire this off.

All right, then. So, let's see if this changes work. I'll just select one of these other ideas. Let's click on regenerate brief.

So, this should stream back these elements as the model is generating them. So, hopefully, it will feel a little bit more performant. And actually, it is. We can see all of these different elements just like popping in one by one as the model is generating them.

Okay, that's cool. Again, we can make edits to any of these fields. Instead of the app showing us JSON, it is actually showing us different cards, and what we can do is remove cards. We can add additional cards if we want, and we can edit the contents within each of these cards.

Cool. All right, our app seems to be making really good progress, but we're not done yet. It still doesn't look very good, so we are going to improve the UI. And secondly, I don't want to keep testing the app until the agent is ready.

So, we'll actually get Open Code to automatically test the app for us. What we can do is assign an MCP server to this agent. That will allow this agent to use a browser to navigate the app and test it. So, I'll be using the Playwright MCP server for this.

All right, then what we have to do is scroll down to the open code section. Then we've got this documentation showing how to set up MCP servers for open code, but what we'll simply do is copy this code over here. All right, in order to add MCP servers to open code, what you have to do is in the root of your project folder, create a new file called open code.json. Then in this file, I'm just going to write in the terminal.

We can copy this configuration like this Playwright MCP over here and paste it into this file. Now, you can call the MCP whatever you want like Playwright or I don't know, Playwright MCP. You can change that name to whatever you want. Now, what I'm going to do to test this is open up a new terminal window.

Let's run open code. Then let's run the command MCPs. And here we can see the Playwright MCP is currently connected. If you ever wanted to disable this MCP, you can simply hit the space bar and that will disable Playwright for this session.

So, instead what we'll do is go back to our main session where we don't have the MCP server yet. What we actually have to do is exit out of open code just to pull in this new configuration. Let's go back into open code. Let's go to MCPs.

You can see Playwright is indeed connected and to resume that previous session, we'll just go to sessions. Let's choose our implementation session. Cool. Now, we're back to where we were.

So, as the final part of this build, let's do something really freaking cool. The UI design really sucks at the moment. Use the front-end design skill to completely revamp the UI including fonts, colors, styles, the works. Then I need you to test the app and visually confirm that everything is working by using the Playwright MCP tools.

Once done, also update the design.md file. Cool, this should be fun. Let's run this and see what we get back. All right, this is really cool.

The agent made its changes and is now using Playwright to operate the browser. And I'm not touching anything, by the way. The agent is driving the app at the moment. It's populating fields, clicking buttons, and testing our app on our behalf end to end.

So, the agent will just kind of do testing on our behalf, making fixes, and it's a brilliant way to kind of auto improve and test your app on autopilot. Let me know down in the comments what you think about OpenCode. Are you going to give it a shot? Also, if this video helped you in any way, please hit the like button and subscribe to my channel for more agentic coding tutorials.

If you do want to take your agentic skills to the next level, consider joining my community, Agentic Labs. I just released the first few videos for my agentic coding masterclass, where I teach you everything you need to know to build real-world applications using AI. If you ever do get stuck, we've got live Q&A sessions every Wednesday. We also have a vibrant community of over 700 AI builders, so someone will definitely be able to help you.

Thank you for watching. I'll see you in the next video. Bye-bye.

If you have been using open code for any serious project, you already know the agent is strong, but the workflow around it makes a bigger difference than most people admit. Skills are how open code packages instructions, scripts, and reference material into a folder it can pull in only when the task calls for it. Open code lists the skill names and descriptions, and the agent loads the full content on demand through the native skill tool only when it actually needs it. Even better, open code reads from six different skill locations, including \{{}dot} open code \{{}slash} skills, \{{}dot} Claude \{{}slash} skills, and \{{}dot} agents \{{}slash} skills, plus the global versions of each in your home config, which means almost every skill built for Claude code can be used in open code without changes.

That keeps your context window clean and lets you bolt on real expertise without rewriting your prompt every time. The five skills I am going to walk through have basically replaced half of my custom setup. Each one solves a problem you are already paying for in wasted tokens, broken builds, or generic UI. Okay, so the first one is graphify.

The pitch is simple. You point it at a folder, any folder, and it builds a queryable knowledge graph out of whatever is inside. Code, docs, PDFs, screenshots, whiteboard photos, even YouTube videos and audio files. Inside open code, you type \{{}slash} graphify.

\{{}dot} in the TUI prompt, and it goes to work. Drop the skill into \{{}dot} open code \{{}slash} skills \{{}slash} graphify or your home config skills folder, and it gets picked up automatically. Why does this matter for open code specifically? When you ask the agent about a large repo, it has to grep through files every single turn.

Tokens pile up fast, and if you are paying per token through OpenAI or Anthropic, that bill grows with every conversation. Graphify runs three passes the first time. It uses tree-sitter to walk the abstract syntax tree of every supported language, so it gets classes, functions, imports, and call graphs without any LLM cost. Then it transcribes any audio or video locally with Whisper, so nothing leaves your machine.

Then it sends docs and PDFs and images out in parallel to whichever model open code is configured with to extract concepts and relationships. The output is a graph.json file, an interactive HTML viewer, and a markdown report listing the most connected nodes and the most surprising links. The number the maintainer keeps quoting is 71.5 times fewer tokens per query on a mixed corpus compared to reading the raw files. That tracks with my own experience.

After the first build, every follow-up question reads the compact graph instead of opening 50 source files. There is a watch mode that rebuilds the graph automatically as you edit, and a clone command that lets you pull any public GitHub repo and graph it without cloning manually. Install is one line with UV tool install graphify and a graphify install. If you work in mono repos, or if you keep dropping research papers and project notes into a \{{}slash} raw folder, this is probably the most useful skill on this list, especially if you are running open code against a smaller context model where every token matters more.

Number two is awesome design.md by Volt Agent. It is a curated collection of design.md files. Design.md is a format Google introduced through their Stitch product earlier this year. The thinking is that AI agents do not read Figma exports or JSON design tokens well, but they read markdown perfectly.

So a design.md file is just a plain text spec of a design system. Mood, color palette with hex values and roles, typography scale, component states, spacing rules, do's and don'ts, break points, and a quick reference for the agent to pull from when generating UI. What Volt Agent did was extract real design.md files from about 31 popular websites. Stripe, Linear, Vercel, Notion, Figma, Apple, Supabase, even Anthropic itself.

You drop the file into your project root next to agents.md and tell open code to build a page that matches. The agent now has every color, every font weight, every shadow value it needs to actually hit the look. This is especially important in open code because the model behind it changes. GPT generates one default style, Claude generates another, Gemini generates a third.

With a design.md pinned in the repo, all three produce roughly the same output, so your project does not visually drift when you switch providers. The combo I actually use is awesome design.md plus agents.md. Agents.md tells open code how to build, design.md tells it how things should look. I started by copying the Linear file into a project, asked open code in build mode to generate a settings page, and the result looked like Linear without me writing a single style instruction.

The repo also ships preview HTML files for each site, so you can see the swatches and type scale before you commit. It is not glamorous, but if your problem is that AI generated UI all looks the same, this fixes it for the price of one file copy. Number three is get done, or GSD. The install is one command, NPX get done \{{}dash} CC at latest.

The CC suffix is a holdover from Claude code, but the skill itself is just markdown plus shell scripts, so it runs the same inside open code. What it solves is the thing every long session runs into eventually, context rot. The agent is great for the first 30% of a long project, then quality starts dropping as the context window fills with old plans, half-finished tasks, and the model talking to itself. GSD treats the agent like a junior engineer who is brilliant but has bad memory, and it builds the planning system around that.

The flow is six commands. \{{}slash} GSD new project asks you questions until it actually understands what you are building, then spawns parallel research agents, then writes a requirements file and a road map. \{{}slash} GSD discuss phase is where you lock in implementation decisions before any code gets written. \{{}slash} GSD plan phase creates two or three atomic plans, each small enough to execute in a fresh context.

\{{}slash} GSD execute phase runs those plans in parallel waves where it can, sequential where it has to, and commits each task with its own atomic commit. \{{}slash} GSD verify work walks you through manual user acceptance testing with the failures handed off to a debug agent. Then \{{}slash} GSD ship to make the PR. The smart part is that each executor gets a fresh context window purely for implementation.

Your main open code session stays at 30 or 40% context use because the heavy lifting happens in sub-agent windows that disappear when they are done. This pairs really well with open code plan mode, which is read-only by design. You hit tab to switch into plan mode, run \{{}slash} GSD discuss phase, and the agent cannot accidentally touch files while it is still figuring out the architecture. Then you tab back into build mode for \{{}slash} GSD execute phase.

There is a quick mode for ad hoc tasks that skips the planning, a spike command for throwaway experiments, and a sketch command that generates two or three interactive HTML mock-up variants per design question. From my own use, the atomic git commits alone are worth the install. If a build breaks 4 hours later, git bisect tells you exactly which task did it. Number four is everything Claude code by Affan Mustafa.

This one is enormous. 167,000 stars, 25,000 forks, and the repo is not really a single skill. It is a whole performance optimization system that ships with 48 specialized agents, 183 skills, hooks, rules, MCP configurations, and command shims. The author won an Anthropic hackathon and has been refining this for over 10 months of daily use.

Despite the name, the readme explicitly lists open code as a supported runtime alongside Claude code, Codex, Cursor, and Gemini. The skills load from \{{}dot} Claude \{{}slash} skills, which open code reads natively, so you get the entire harness without any conversion work. What I actually use from it. The TDD workflow skill enforces test-driven development with an 80% coverage gate.

The code reviewer agent runs after every meaningful change and catches the kinds of mistakes that ship to production otherwise. The build error resolver is the one that surprised me. When a build fails, it does not just dump the error. It goes through dependencies, version mismatches, and config drift in a structured way.

There is also a continuous learning system that auto extracts patterns from your sessions into reusable skills, and a security scanner called Agent Shield that runs over 1,200 tests against your agent config to find injection risks and leaked secrets. The token optimization advice in the readme alone is worth reading, especially for open code users who are paying their own bill through open router or directly. Switching the default model to a mid-tier model like Sonnet or GPT-4o Mini, capping max thinking tokens to 10,000, and triggering compaction earlier at 50% context cuts cost by something like 60% without losing quality on most tasks. Install is npm install, or you can drop the skills folder into .cloud/skills inside your project.

There is a desktop dashboard now for browsing all the agents and skills visually. If you want one repo that gives you a complete production-grade harness instead of stitching together five smaller ones, this is it. Number five is UI UX Pro Max skill by Next Level Builder. This one is laser-focused on one problem.

The UI any AI agent generates by default looks generic. Same Tailwind buttons, same purple gradient hero, same boring dashboard. UI UX Pro Max ships a reasoning engine that takes your project description and outputs a complete tailored design system in seconds. And because Open Code is provider agnostic, this skill is especially useful here.

You stop relying on whichever model you happen to be using to have good design taste. The way it works under the hood is interesting. There are 161 industry-specific reasoning rules, each one mapped to a product type. Beauty Spa, Fintech Banking, Gaming Portfolio, Dental Clinic, B2B SaaS, Web3 NFT, and so on.

When you ask for a landing page for your Beauty Spa, the engine runs five parallel searches across product types, style libraries, color palettes, landing page patterns, and typography pairings. It then ranks the matches with BM25, filters out anti-patterns for that industry, and returns a full spec. Pattern, style name, color palette with hex values and semantic rules, font pairing with the Google Fonts link, key effects, anti-patterns to avoid, and a pre-delivery checklist that covers contrast ratios, hover states, focus rings, and responsive breakpoints. The anti-pattern part is what I appreciate most.

For a Fintech Banking app, it will explicitly tell the agent not to use AI purple gradients or harsh animations. For a Beauty Spa, it will block dark mode and neon. These are exactly the defaults most models tend to fall into. The skill ships 67 UI styles, including glassmorphism, claymorphism, neumorphism, Bento Grid, Brutalism, and Aurora UI.

It supports 15 tech stacks from React and Next.js to SwiftUI, Jetpack Compose, Flutter, Laravel, and Shadcn UI. Install is npm install -g ipro-cli, then ipro init --ai inside your project. And you can pass any agent name, including Open Code. There is a master plus overrides pattern for persisting the design system across sessions, so the dashboard page can override the master rules without you re-explaining everything.

Quick recap before you go. Graphify gives Open Code a memory layer for any folder of code or research. Awesome design.md makes the UI consistent regardless of which model is running behind Open Code. Get Done fixes context rot with a six-command spec-driven workflow that pairs perfectly with plan mode and build mode.

Everything Claude Code is the production-ready harness with agents, hooks, and a security scanner that runs on Open Code without any conversion. UI UX Pro Max generates real design systems based on your industry instead of the same default look every model produces. All five are free. All five install in under 5 minutes, and they stack on top of each other without fighting.

Pick the one that hurts the most in your current workflow and start there. Drop a comment if you want me to do a deeper walk-through on any of them, and I will see you in the next one.

So before we get started, I want to show you why this video is worth your time and why it's important to be talking about open code right now. Because tools come and go, but momentum and ecosystem usually tells you what's going to stick. I've collected these three different screenshots here that really show something interesting. It really shows why Open Code is worth your time right now.

So when we look at Cloud Code on GitHub, it has around 67,000 stars. But when we look at Open Code, it has 105,000 stars. In this month alone, it's gotten 36,517 stars on GitHub. Anyways, Open Code is more popular than Claude Code.

So, I think it's safe to say that Open Code is not just new and shiny. It's already ahead in the community adoption signals. But this screenshot here really shows the velocity that's happening. So, it shows that people are switching.

People are making content, building plugins, and the workflow is spreading. So, why does this matter? When a tool is moving this fast, you usually get better documentation, more tutorials, more community configurations, and more I hit this bug and here's the fix post that makes your learning curve shorter. All right, now that this isn't a random weekend project, let's talk about how open code actually works so the setup makes sense.

Let's start first by thinking about what open code really is. So, Open Code is really the open- source version of cloud code. So it can do almost everything that cloud code can do. Plus it's has an MIT license and is 100% open source and on top of that it's provider agnostic.

You can use it with cloud, you can use it with open AI, you can use it with Google and you can even use it with local models. This is what I think. If you want flexibility and an [music] open tool that you can shape, open code is probably the better choice. But if you want to go the official anthropic path and you're already standardized, then cloud code may be the better choice for you.

The most valuable point on open code is really this that it's provider agnostic. Because when you think about what just happened, for instance, Enthropic came out with their new AI model and then so did OpenAI. Enthropic said that this was their most powerful coding model and then OpenAI came out with one that was actually better for coding, right, the 5.3 codeex. And so it's nice to be able to try them both.

To me, this is a really important point that it's provider agnostic, so you can switch around from different ones. In this video, what I'm going to be showing you guys is how to set up Open Code on Windows. We're going to install Open Code in a Windows friendly way with WSL. We're going to connect models and providers and understand where the credentials live.

and I'm going to show you guys how you can use build mode and plan mode effectively and when to switch between them. We're also going to set up some project rules with agents.md and a quick refresher on this as well. And then we'll create we'll create some skills and commands that will work globally or per repo. Why are we going to install it on WSL?

Really? Because that's what Open Code recommends for the best performance and terminal compatibility. So, I'm not going to walk you guys through how to install WSL, but this is the command that you'll want to use. Just go to your terminal, type in WSL-install, and then it will work for you.

And then we're going to pick it up from right here. We're going to use this command to install Open Code, and then we'll go from there. How should we think about Open Code? Well, open code is easiest to think of as three layers.

First, we have the agents layer. Who's doing the work? Who's [music] driving right now? You'll mainly use the build mode and then the plan mode.

The build mode is the do work mode and the plan mode is think safely. If you're new to a codebase, plan keeps you from letting an agent bulldoze the repo and just run off the rails. Now, the second layer is rules. How should the agents behave in this repo?

That's the agents MD that tells the model your project conventions, structure, and do/dones [music] rules. Think of this as like your onboarding notes for a new teammate, how to run tests, the folder structure, formatting rules, what not to touch, how pull requests and commits work. Without this, you'll end up repeating yourself every prompt. Now, the third layer is the extensions.

[music] How we automate repeatable work. Skills are the reusable playbooks that the agents can load. And then the commands are like oneshot buttons that you can run with a slashname. Whenever you're first getting started with open code, you don't want to overbuild a giant skills library on day one.

You just want to focus on two to three real tasks first and then codify what you end up repeating. It's really good to just start with a well-rounded agents MD and using the agents effectively the build agent and the plan agent. This is the setup that we're going to have. We're going to use cursor for editing, open code for agent runs in a WSL environment.

And now the goal is cursor is the editor, WSL is the runtime. Open code runs in WSL and edits the same files that cursor has open. So the biggest win here is really consistency. One copy of the repo, one set of credentials, and one tool chain.

The workflow is going to be like this. We're going to open up the repo in cursor using the WSL file system integration. Open a WSL terminal in that same repo folder and then run open code from there. Now, a good rule of thumb is if your IDE shows that WSL in the bottom left, then you got your setup properly working.

Let's hop over to our file system and open up cursor and I'll show you guys how to set this up. I'm going to assume that you have WSL installed at the very least. Now, whenever we open up a terminal, we're going to go to the top here and this little arrow that's pointing down, we'll click that and we can switch to WSL just by hitting this, the Ubuntu. And now we're in our WSL.

What we're going to do is we're going to make a new folder for our project. Let's see where we're at right now. We'll go inside of coding projects. We're inside of the coding projects.

We're going to make a new directory and we're going to call it open code demo. We'll go ahead and change into that directory. Open code demo. And now we'll just go ahead and run a cursor dot.

We're going to open cursor up inside of this directory. And here at the bottom, you can see it's opening up the remote. with setting it up. Now, we have that going and there's nothing inside of here yet.

Now, we need to install Open Code. And it really doesn't matter in which order you do this. Like, we didn't have to open up the directory before installing Open Code. I'm just getting it set up.

So, you could do this before, but on the Open Code.AI docs, it gives us this command to run. We're going to run that now. It's finished installing. We're going to go ahead and run Open Code in this directory.

Looks like we may need to reset our terminal. I'm just going to copy this and we're going to open a new one. You have two options here. You could run the terminal user interface here with a separate window, which is the way that I like to do it, or inside a cursor.

I'll show you why I like to have it in a separate window. If we hit controlB, it conflicts with cursor. It's a little bit harder to use there. That's why I have a separate window open for it.

Now that we're inside of Open Code, what's really nice is that they automatically include free models without us doing anything. You can see we're running on this model here, the Big Pickle from Open Code Zen. And we can ask anything, we just say hello to make sure it's working. Even just for a simple hello though, it took 16 seconds just to get back hello, how can I help you?

Even though Open Code does include free models, it takes a little while. They're not the best. When we hit control P, we can see all the different commands that are already built into Open Code. And they're broken down by category.

The suggested category for switching sessions, switching models. And they have a few here for free as well, the Miniax, the Kimmy, and the GLM5, and the Big Pickle. And we can also connect popular providers here. I have the Chat GPT plus plan.

We're going to go ahead and select that. and we're going to connect it with browser. And I'm just going to log in here. We have authorized successfully.

We can go ahead and close this. And now we can choose which model that we want to use. I'm going to use the GPT 5.3 codeex because that's their most advanced model right now. But if we wanted to switch models, then we would just come back here and we can choose which model we would like to use.

The next thing here is whenever we're switching between modes, we're [music] going to use the tab button. We can see when we hit tab, it changes down here from build to plan and back and forth. Really using open code effectively or cloud code or any sort of AI assisted programming application. It really comes down to using both the build mode and the plan mode effectively.

I'm going to break down when to use which for you. The build mode is just do the work mode. The agent gets full tool access, edits, bash for implementation. You want to use this when you're ready for code changes, and that's best for adding features, refactoring, fixing tests.

A tip as well is keep your prompts specific. Make change X, run test Y, show diff. Now, the plan mode, that's the think safely mode, is restricted by permissions to prevent unintended changes. It defaults any risky actions to ask.

But it's going to ask you before it does anything, before it runs any sort of risky commands. And that's best for designing code reviewing, debugging strategy, really just making a solid plan. The practical workflow here is you want to start in plan mode. You always want to start in plan mode [music] and then confirm your approach.

Get that super solid. Make that bulletproof. And once that's bulletproof, then switch to build mode. And then you'll implement it.

And then you'll switch back to plan mode for review. Now the next step for us is to initialize open code in our repo in our directory in our folder. And what this is going to do whenever we run this command here the init that's going to generate an agents.md in our repo root. [music] And now what is that agents MD?

It's going to be custom instructions for the repo. It's going to explain the structure, the conventions, the dos, don'ts. The main point is that it helps Open Code navigate your codebase faster and safer. That's what it's all about.

And here's an example of a simple agent MD template. It has the setup commands on how to set up the repo and it has some code style instructions. A tip whenever you're doing this is you'll want to commit your agents MD so that your whole team gets consistent agent behavior. The goal is just enough structure that the agent behaves like a teammate who read the readme.

Now we'll run that command. We'll hit init. And that's also what's really nice about open code is whenever you hit the slash, you can see all the different commands that currently exist. It's currently inspecting the repo.

It's making an execution plan and going with it from there. This time it looks like it even asked me a question. Is this the correct repository path or should I analyze a different directory? Let me see.

Let's make sure that yep, that's the right one. Say, yep. And on Windows, if you wanted to type with your voice, you would just hit Windows H. And now it will start recording my voice.

That's how you can implement that. If you wanted to vibe code with your voice is just the Windows key and H. That's the shortcut. Ah, so I see.

So you see the importance of making sure that you're in the correct mode whenever you start coding. It's currently in plan mode, so that's why it keeps asking me questions and asking me to do more things. So, we're going to hit Ctrl P and we'll make a new session. And this time, we'll switch out of plan mode and we'll run [music] a netit.

Now, the agents.m MD file is created. And I thought this last message is really important. So, I want to point that out to you. It says the repository route is currently empty.

So, the commands are in intentionally a bootstrap matrix until real project scripts/configs are added. So, that really comes back to the whole point. Agents.m MD is not a write it once and forget it. Agents MD is this file that's living.

It's going to change as your repository changes. You can see currently all the things that it's done. It even has instructions here for if cursor or copilot rules appear [music] later. It has build and lint commands.

It has everything with the JavaScript, Python, Go, Rust. So, it's really complete. Not all this is going to be super important for your individual repo. This is a living document.

you want to change it as your project changes. And if you wanted to dig deeper into the agents.md format and its purpose, you can go to agents.mmd on online and you can see some more additional information and some good examples of some agents.mds. And you can see here how they recommend using it. Add the file, cover what matters, add extra instructions, and you can even use these nested agents.md files for sub projects.

At this point, we're pretty ready to start making some cool projects. We're ready to start using it. I'm going to ask it to just generate a basic flask application. I'm going to say make a basic flask website for my plumbing company.

This is our color scheme. And I found this color scheme off of colorhunt.co. And I really like this website because it's color palettes that have been curated by professional designers and it's their favorite ones and you can even see how many likes each one gets. So, it's a cool resource to check out.

It's completed the application and it's given me these commands to run it locally. We'll go ahead and run those. Let's go ahead and open that up. Now, you can see here how well it's used our color scheme.

And yeah, it looks really nice. And I'll show you something else, too. If we make this full screen, you can see that on this right side under context, it shows us the number of tokens that we used, how much of the context window that we're taking up, and also the number of dollars spent. We can track all that here.

And then we can also track LSPs. This will activate as files are read. And this is what an LSP is. It's a language server protocol.

It's an open JSON RPC based standard that allows code editors to communicate with language specific intelligence tools. That's quite a mouthful. So let me break that down for you. I came across this diagram and I think it explains it really well.

When we have our development tool here, it goes back and forth with the language server. You think about you open a document that's going to send a notification over to the language server. If you edit a document, it's going to send a notification over to the language server. And now the language server is going to analyze the changes and look for any sorts of problems and then [music] send it back.

The main point of an LSP is this. It lets any editor get smart code features. You think about autocomplete, go-to definition, references, hover docs, linting, rename, refactors without the editor needing language specific logic. The LSP is really going to assist the agent in writing code.

Now, as we build this site out, you think there's going to be a lot of repeat prompts. For instance, if we're going to add a new page, there's going to be a particular way that we may want to have that page structured. There's going to be, as we use open code, there's going to be prompts that we would like to save. And that brings us to our next topic, skills and commands.

You can think of skills this way as a reusable playbook. They're not commands you run. They're knowledge modules that the agent can load when it hits a specific kind of task. So example, this will be a skill for how we write migrations or how do we make a new endpoint, how do we make a new page and how do we write tests [music] in this repo.

The benefit is consistently this. instead of reexplaining your team standards every time you encode them once. Now, as you get more comfortable with using open code and as your repo grows, you're naturally going to build skills. There's no point in putting a whole lot of effort from day one [music] and coming up with all these different skills.

But once you notice yourself repeating yourself, that's a signal that you may want to capture that as a skill. And there's a particular structure as well for where to put skills. If you want it to be per project, you'll put it inside of a folder, you'll call it open code. And then you'll make another folder inside of that and so forth.

And then if you want it to be a global skill, you can put it inside of your config. And you can also even add permissions for it. So the discovery behavior works like this as well. Open code walks up to the git worksheet and loads any matching skills.

And global skills are always available in every repo. And here we see an example of one of a front the required front matter. It needs a name and it needs a description and then from there you can continue with it however you'd like. And now commands are very similar but you can think of these as workflow shortcuts.

Commands are more like buttons you press, not so much as playbooks. A command is something that you explicitly run like maybe slash test or slash review or slash ship. And you're going to run these in the open code terminal user interface. Commands are really great when you want repeatability.

They reduce the amount of typing and the number of prompt mistakes. And here as well there's a particular place that you want to put them as well per project and globally. And here's an example of one for a slash test. You give it a description the which agent you want and a model.

And [music] then you can put in whatever sort of prompt that you like. So run the full test suite with coverage, focus on failing tests and suggest [music] edits. You can also add arguments and placeholders by using a dollar sign arguments. And you can even which you can see here actually /component button create a React component named button.

That's where that would come in. And then for more than one argument, you would just use a dollar sign and then a number. You'd give it a description and then write your prompt. And then you would put the dollar sign and then the number of arguments.

Now you would create a file named config.json in source with the contents of key value. And again just to reiterate, commands are like repeatable prompts. It's do this. Now skills are how we do this here.

Commands are prompts. Skills are those knowledge playbooks. And if you wanted to go deeper on any of these topics, you can just find them in the open code.ai docs. So you can see for instance for the it breaks down the required front matter for a skill to work and [music] the places to put the files etc.

And along with the commands as well gives you a little bit more meat as if you want to go deeper in these. Let's go ahead and try to make our own command and skill. Now I've actually put together a skill already. We'll go ahead and we're going to copy this folder with this built-in skill and we're going to put it in our config for open code.

We're going to put it right there. I'll show you what that looks like as well. This command helps scaffold a new open code skill or command. And the usage works like this.

/caffold skill name or scaffold command [music] name. You are scaffolding a new open code resource. The type is one [music] and the name is two. If you look at it like this, you're going to run / scaffold either skill and the name is whatever you put there.

And then it's going to follow these instructions for each one to help us create either a skill or a command. And we also have global skill and global command. We have that loaded in our global. We'll go ahead and try it out.

After you add a new command, you're going to need to restart your open code. We'll hit C and we'll open it up again. If we go ahead and use our command and we'll run scaffold and we'll make this a new command and we're going to call this one a website or let's say web page. Actually, this will be a command that we run that will go ahead and make a new web page inside of our app.

Now, if we look inside our directory, it's put together a web page command for us. Create a web page from a [music] prompt with clear structure and styling. So, it's even bootstrapped our command for us. Let's go ahead and hit Ctrl + C to get out of it and we'll reopen [music] it.

If we do a web page, then it runs that prompt for us. Another thing too is you can see we're on GPT 5.3 codeex, but if we wanted to change our level of thinking, we can hit control T and now we're adjusting the level of thinking on that, but we'll keep it regular for now. It's completed a a web page here, index.html, and it's included everything that it needs. Now, when we look at our context, you can see we're already at 17,000 tokens.

That's not too bad. It's only 4% used, but I'll show you a command as that starts to get higher. You can just run slash compact, and that's going to compact the session. That's going to summarize the session.

Now, we went from 4% used to 2% used and 9,000 tokens. Let's go ahead and scaffold a new skill. We'll call this skill and we'll say that this is a copywriting skill. And we can see now that it's bootstrapped for us a copywriting skill.

What I want to do though is I'm a really big fan of high focus language. So high focus language is whenever you speak to the [music] person directly and you show them the value very clearly. Everyone has their own definitions on what high focus means to them. I have some instructions here and I'm going to go ahead and reference those instructions.

We can see that it completed it successfully and included this in its references and it's added the document to the copywriting skill. So, we can go ahead and delete this one. Let's go ahead and modify the copy on this page. Currently, we see it says plumbing done right the first time.

From emergency leaks to full fixture installs, our experienced team keeps your water flowing and your home protected. Let's go ahead and use our skill. Whenever we run the slash skills command, you can see because it was just added, it's not loaded. We just need to go ahead and do control C open code.

And now if we let's switch sessions. Actually, this is the one here. And we'll go ahead and we'll run skills. And we'll say this is the skill we want to run.

And I'll say adjust the copy on the homepage. Looking at the copy now after it's made the changes, it says that it's updated the copy to be more benefitled and high focus aligned. And it gives us a summary of the changes that it's made. You can see the clear user value and next steps is a little bit more solid.

That should give you a really solid introduction to open code. Just to recap, this is the workflow that you'll do every time that you open up a new codebase. You'll put the repo in one environment, preferably the WSL environment. Then you'll open up open code in that same environment.

You'll connect your model provider there. Use whichever one you want. Then you'll do your slashinit to generate your agents.md. Then as you develop, you'll come up with different commands that you think you want to add either for your global projects or for that individual repo.

And then you'll also add skills remembering the difference. [music] Commands are like buttons, repeatable prompts, and skills are more like playbooks for the agent to follow. If you wanted to go deeper on any of these topics, there's this really awesome article that I read about how coding agents actually work and inside of Open Code. Even this architecture breakdown is really nice.

It gives you a really deep dive into how everything is working. If you want to check this out, what you can do is click the link in the description, join our school community, and there'll be a post that has this video on it, and I'm going to link this article as well. If you want to check that out, that'll be there. That'll be it for this video.

Thank you so much for sticking to the end. If you enjoyed this video, give it a like. Subscribe for more content like this. If you'd like to check out some of my other tech demos, you can check that out right over here.

Open code is incredibly useful, but if you really want to take things to the next level, you got to start implementing custom agents. Because once you do, you'll stop treating open code like chat and you'll start treating it more like infrastructure. Your workflow is going to improve dramatically. And we're going to walk through four things that you need to know in order to do this.

By the end of this video, you'll be well equipped to make your own custom agents tailored to your preferences and your workflows, and you'll be able to make the system that only compounds and gets better the more that you use it. I'm going to show you why custom agents are the really the ultimate unlock inside of open code. If you've ever had a model do great and then fall apart the next time, that can be like a workflow problem. Agents let you package a workflow, tools, constraints, instructions, so you can run it again.

And every project that you use, there are going to be certain agents that are going to be more useful than others for you. We're going to cover why agents matter, how they're structured, how skills plug in, and then we're going to build some agents together. Why do custom agents even matter? If you're only using the vanilla agents that ship inside of open code, you're really going to keep your results vanilla as well.

Agents really fix that. It helps you with consistency, speed, and safety. With custom agents, you can add a lot of flavor to your workflows. You can segment your work in a more realistic way.

You think about generalist agents. If you get the same agent to do everything, well, that's like the AI equivalent of a jack-of-all-trades. As humans, we specialize, and AI agents should specialize as well. You end up getting better behavior, you get more consistency per tasks, you can set boundaries as well, you can adjust the permissions that the agents have, you get better speed, too, so you don't have to keep re-explaining your preferences.

And also, if you're working with a team, you can ship agents with the repo inside of the dot open code folder, and the entire team can be synchronized using the same agents. You get better quality across your entire team. Now, what are the different types of agents that exist inside of Open Code that you can make? You have these two types, primary and sub.

The primary agent, this is the assistance that you interact with directly. You can switch between the different agents with the tab key binding. Whereas, sub agents are invoked by a primary agent or you can manually invoke them by using the @ mention for focused tasks. The built-in set makes the idea really concrete.

Build and plan are primary agents. Whereas, the sub agents that ship inside of Open Code are the general and explore. When I say main agents in this video, I'm talking about primary agents. Primary drives the conversation.

Whereas, sub agents really handle narrow units of work without bloating the main context. If you're wondering too a little bit more about the distinction between the primary agents and the sub agents, you can go to the openinterpreter.ai docs under agents and it gives you more information on this. Particularly though, I think it's interesting to look at what the sub agents are used for. Whenever we look at the general and the explore, the general agent is a general purpose agent for researching complex questions and executing multi-step tasks.

Has full tool access except for to-do. You can make file changes when needed. Uses to run multiple units of work in parallel. Whereas, the explore agent, it's fast, read-only agent for exploring code bases.

You cannot modify files and you'll use this when you need to quickly find files by patterns, search code for keywords, or answer questions about the code base. And again, these sub agents, they're specialized assistants that either the primary agents can invoke or you can manually invoke them yourself if you'd like. The next thing that we're going to talk about is how do Open Code agents really work? Well, an Open Code agent is really just a markdown file with a YAML front matter.

And this front matter defines what the agent is and what tools it can use. And then the body here is just your instructions. So, you want to keep it focused and you want to think of it as one job per agent. In this instance, we're looking at this agent here that writes project documentation.

It's in the sub agent mode and it does not have access to this bash tool. And the prompt that is given to it is you're a technical writer, update docs based on code changes. Let's go ahead and walk through this together. Now, over here in Cursor, I have a new project opened up and we're going to go ahead and make a new folder and we're going to call this open code.

Now, inside of here, we're going to put another folder and we're going to call it agents. We're going to make a new agent inside of here and we're going to call it a reviewer agent, make it an MD file. Here, we have the description set as reviews code for quality and best practices. We put this in the sub agent mode.

We set the model that we want it to use. We also have the temperature as well along with some different tools here. So, we're saying it can't write, it can't edit, and it can't use bash. And we've given it the system prompt.

The next thing that we're going to do is and I'll show you guys this real quick, but inside of Cursor, there's an open code extension. You'll want to get that. After you have that downloaded, if you don't already, hit control shift P and then we can just go ahead and hit open code right here. It's going to go ahead and open that up.

Do the at, you can see now we have the general, the explore, and the reviewer agent that we just made. Go ahead and put it to the test. The first thing that we're going to do is with our build agent selected, I've had open code generate a simple script here with a bug in it. I said, "I want you to write a Python file that performs math, but it should have a small bug in it for me to figure out as a test." And down here, it's written this and it says that it includes basic math functions, one small intentional bug is included for your test.

It also has a main section so you can run it directly to see the output. We look at it, what is the bug? Here, it's using floor division instead of regular division. You do 10 and four and it hits here, it's going to be two when it should be 2.5, I believe.

Now that we've done that, we're just going to go ahead and make a new session and we're going to add our reviewer and then we're going to ask it to analyze the Python script for any code errors or quality issues. And so, here it is. It's given us the findings. It's looked at the medium, the high, the medium, and the low sorts of issues here of as far as quality.

And you might say this is just about the same as any AI model. But really, the beauty of this is that you're adding the preferences. You're giving it a specific prompt and you're setting the permissions, you're setting the temperature, you're setting the modes. You're doing all these sorts of things that's really going to streamline your developer flow.

The next thing I'll show you too is whenever you change this mode here, there's three different types of modes for agents. You can do sub agent, you can do primary and if we do primary, what that's going to do is now I can go to my reviewer agent with the tab button. So now it's switched to primary. But if we wanted it to be both a primary and a sub agent, we can also make that happen.

Now I can switch to it with the tab button and I can mention it with the app. That's something to keep in mind as well. All right, so that's our first basic agent that we've built together. But there's another way to make agents that I want you to know just so you're aware of it.

I think primarily most people are going to prefer to define their agents using markdown files, but you may want to do this as well if you wanted to keep your code base a little bit smaller, I guess would be the primary advantage. But you can define agents in open code JSON. The way that you would do that is here inside of the JSON file, you have an agent key and you have a dictionary of your different agents. And you would have a mode key, a tools key, and so forth and so on.

You just go down this nested dictionary route. What's really cool about this, too, is you can see we already have build agent and a plan agents. If you have an open code.json, you can override those agents using this file. Meaning as well, you can have a prompt key along with the destination of that prompt, so you can modify the build agent and the plan agent.

Let's go ahead and define some of the primitives here talking about agent skills and commands and how they fit together because this is where the agents are worth it argument really becomes real. An agent is this configured assistant. It has a role with a custom prompt, uh optional overrides, and tool access. That's what an agent is.

Whereas skills are these reusable playbooks that are loaded on demand via the skill tool. And the commands are your shortcuts. They let you trigger repeatable workflows quickly. They're basically what allows you to use your prompt library effectively.

Something that you can use to run a subtask as well. Whenever you combine all of these together, when you combine agents with skills and commands, you get something that you can really continuously improve upon. Every time you learn a better way to do something, you update the agent prompt, you update the skill. Now the next run starts from a better baseline and your results get more consistent over time.

Now let me show you what I mean by that. Here with our reviewer agent, I've added a little bit of extra information inside of the prompt. Now I've told it that after every review, I want you to make a new file in the code reviews folder and make one in the repo if it doesn't already exist talking about this folder and it should contain this information the title why it matters where and the evidence and with a recommended fix here for that we're also going to change right to true with our reviewer agent I'm asking it to review the python code after it's run it has made a code reviews folder and it's generated this document for us so we can see what sort of errors exist the division returns the wrong result type and value for many inputs why it matters bug correctness maintainability where is it at gives us the exact line the evidence and then the fix the next thing that we can do is we can just switch over here to our build agent and if we go ahead and paste that we'll ask it to fix this you can see the way that you can start developing this workflow and how you can start continually improving your agent and the way that you think of about your repo and if we were to take this to the next level then maybe I would modify the build agent and have it to where after it fixes one of these code reviews it would go ahead and just delete it or market as done you can start developing your own sort of workflows your own custom agents or you can use a really awesome framework that helps you that already has done like 90% of this one of the ones that I like is called the B mad method I'm going to show you what that is the B mad method is this building really awesome software with agile development inside of it it has AI intelligent help it has a scale domain adaptive so it can automatically adjust planning depth based on project complexity you can build structured workflows you have 12 domain experts it comes with a project manager and architect a developer a UX scrum master and more agents inside of here it also has a party mode so you can bring multiple agent personas into one session to collaborate and discuss it. Go ahead and install that and I'mma show you how powerful this is.

The first thing that is asking us is for our installation directory and then it's asking us here what sort of modules would we like to install. We're just use the BMAT core module but you can see they have different ones here like BMAT method agile AI driven development if you wanted to stick with that. If you just want the core module, you can do that. There's the BMAT builder if you wanted to build agents, workflows, or modules.

There's the BMAT creative intelligence suite for creative writing, brainstorming, game development studios. There's a lot of really good stuff in here. But we're just going to do the core module and yeah, I guess we'll go ahead and do the agile AI driven development. So do we want to add custom modules?

No. We're going to come down here and we're going to select open code and you can set your name. What sort of name would you like it to have for you? What language do you want it to use?

Where should the output files be? We'll just accept all these things. Now that we've have that set up, we can go ahead and switch to all of our different agents that have been pre-made for us. Inside of here we have the BMAT method analyst, the BMAT method project manager, the UX designer, the quick flow solo developer, and the tech writer.

What else is really cool in here is all the different sorts of commands that come pre-made. Come inside of here and we go to BMAT help. Let's say for this demo we want to know what agent should we use in order to build a quick Python game. We're going to build a snake game.

Let's go ahead and ask it. And here it gives us the answer that we need. It says that we can use the BMAT method quick dev berry and it is the fastest path for one-off simple apps without heavy planning, ideal for a quick snake build. Go ahead and make a new session and we'll switch to our quick flow solo dev and we'll activate him.

And we need to activate our BMAT agents first so that way it can get all the context that it needs. Go ahead and activate it. Berry here, your quick flow solo dev, ready to move fast and ship clean. It gives us these different modes, chat with the agent about anything, quick spec architect a quick but complete technical spec with implementation stories and specs, implement a story tech spec end-to-end, initiate a comprehensive code review across multiple quality facets, and start party mode.

We'll go ahead and we'll switch to the CH mode, and we'll say, "I want you to build a Pygame snake game." While this is running, I'll show you inside of here, too. You can edit any one of these agents that you want to make it your own. That's something to be aware of, as well, because I'm sure that it's not going to exactly make the snake game exactly to the code standards or the way that I would like. And you can see here what it says.

Built it. I added a complete playable snake implementation in snake game, game loop, snake movement, validation. I ran, it passes, and then here import Pygame. It fails, so it's asking me to install Pygame.

And this is the thing. So, whenever I write Python code, I like to use UV. I like to have it initialized in a certain project. If this was going to be a repo that I would work on regularly, I would modify either the agent or the skill.

It knows that in the future or the agents.md. Now, we'll go ahead and test this out, and there we go. We have a nice snake game rolling, and it's a UV project, and everything works very good. But it gives you a different idea, a different way to think about your projects, about your repos, about the way that you structure your agents.

One of the coolest things that I've made with Open Code is actually my Open Code expert. And my Open Code expert lets me generate different things for Open Code. Instead of me building things out from scratch, I can just ask it to make an agent, make a skill, make whatever I want. And at the very least, it gives me a good starting point, and then I can build on top of it from there.

For instance, I can say, "Make a static React site expert agent who creates visually appealing React sites using this color scheme. And now it will generate that for me. When we look at what it's made, it's given it a nice description, it's given it the mode, and it's given it a nice prompt as well. One thing though is I would like this to be a primary agent.

So, let's go ahead and run a \{{}slash} new on it, and let's go ahead and test her agent out. We restarted our OpenCode, let's go ahead and try out our static React site expert. That's finished. One thing that I meant to add was I meant for it to use Vite, so I went ahead and I had it run that, and we'll go ahead and see how it comes out.

When we look at the website it's made, it looks really good, and it has used the color scheme that I have provided for it. Really cool stuff. So, if you think that OpenCode expert agent would be useful for you in your setup, click the link in the description and check out our school community, and I'm going to put a post on there, and I'm going to add that agent there. So, if you want to download it and check it out, maybe refine it to your own taste, you're more than welcome to.

Thank you so much for watching this video. If you enjoyed it, please give it a like and subscribe. And if you want to check out some of my other tech demos, I'll put them on the screen somewhere right over here.

Recently, I came across this really awesome open-source AI coding tool plug-in. And in this video, I want to show you how you can use it because when we check it out on GitHub, it's blowing up right now. It's got 160,000 stars, about 14,000 forks, and 664 watches. And it describes itself as an agentic skills framework and software development methodology that works.

And that's a really great description of it because it really does just work. I want to show you the main difference of using superpowers versus not using superpowers. Over here in Cursor, I asked app that monitors the rainfall in an area and estimates when you should mow your grass the next time. And you can see with this one prompt, it's gone ahead and it's set up a plan to start building this app.

This is without superpowers. But let's go ahead and stop that. Now this is with superpowers. Over here I have the open code server opened up and I pasted the same exact prompt.

I gave it a little bit of information about the stack and some of the technologies I wanted to use. And the first thing it does is it starts using its brainstorming skill. It uses that to shape the app before any implementation. And then it asks this question here.

Some of what we're working on might be easier to explain if I can show it to you in a web browser. And it talks about it can put together mock-ups, diagrams, comparisons, and other visuals as we go. This is still new and can be token intensive. Do you want to try it?

On here I put yes. And this is really one of my favorite features about superpowers and I'm going to show you what that looks like in a minute. But you can see here before it did anything, it just starts asking me questions. First it asked which target feels right for the first version.

Then it asks how should the app know your location? Then it asks how accurate do you want the grass cut to be? And it goes on and on. It helps you come up with this really detailed plan so it gets everything right the first time before it starts building anything.

Really, it can help you save tokens in the long run and it can help prevent excess token usage by you tell AI to do something, it goes and does it, but it's not at all what you wanted. And then by the end of it, after you finish the brainstorming session, it creates a doc folder for you. And it puts together the brainstorming design.md. Here it gives a summary of what the app is, the goals, the non-goals, the product scope, recommended approach, and it's very extensive in what it puts together.

You can review it and make any changes before you start making anything. And then after that, you can see the next step is it's going to ask you to review the spec file and then it's going to move on to making this implementation plan. And whenever we look at the GitHub readme, it tells us the basic workflow for the tool. The first step is it's going to start with brainstorming like I showed you.

Then after you approve that design, it's going to spin up some get work trees, which are going to be these isolated workspaces, and it's going to run project setup, verify a clean test baseline, it's going to write plans, it's going to use a sub-agent driven development or executing plans this step-by-step coding, or if you would rather have the sub-agent where it spins up maybe three or four agents and it all starts working on the program at the same development. You can request code reviews and you can finish a development branch. This activates when a task completes, it verifies tests and presents options, and it cleans up the work tree. This really can transform you from being just a vibe coder to being more of an agentic enabled engineer.

Let's talk about how to install it and what it's compatible with. On the readme, it tells us that it works with Claude Code, Code X CLI, Cursor, Open Code, Copilot CLI, Gemini CLI. More than likely, whatever sort of AI coding tool that you're using right now, you can go ahead and install this and start playing around with it and see how much better it makes your coding workflow right now. I reviewed the design doc and everything looked good.

Then it went off and it used the writing plan skill to create the implementation plan and it turned the approved spec into a concrete task-by-task build plan with exact files, test commands, and commit points. I'll show you what that looks like now. If we come over here, we have this new plans folder. And inside here we have a markdown file.

And in here it has the the tracker implementation plan. And here it says for agentic workers required sub-skill [music] use superpowers sub-agent driven development recommended or the execution plans to implement this plan task-by-task. Here it's come up with a file structure for us. Then it's broken it down into tasks.

This first task is scaffolding tooling and the app shell. We can really review all the code and the method before it does anything, which is really very cool. And you can see it even has steps in here for committing different changes that it makes. And at the very end of it, there's this final manual verification step and self-review notes.

What I like about this is it allows you to get this broad overview of its plans before it does anything and it allows you to pivot at any point. Like right now, for instance, if I wanted to use PNPM, I could change that. If I wanted to use a certain library instead of the ones that it's recommending here, I can change it to that. Then it asks this question.

Do you want to do the sub-agent driven mode or do you want to do the inline execution? This is what I was really wanting to show you guys. Here it was wanting to move on to the execution path, but first I wanted to brainstorm the look of the app. And what's really nice is all these skills, they just run.

It's [music] like they're super low friction. It just makes the whole experience much better without you even noticing. But here I said let's brainstorm the look of the app first and it set up this web server for me. Then it asked the question, which visual direction fits the app?

And it gives three different options here. Which one do I like? I kind of like this one, the B option. I can just come back here and I can say B.

And it turns out that was actually the recommendation from the AI as well. And we know how Claude design just came out, which is a really awesome and powerful tool. I was playing around with it yesterday and I was really impressed. But you think about this is a way for us to kind of get an open-source Claude design within our Open Code or within our Cursor CLI or whatever sort of coding agent that we're using to get like a little taste of that, right?

Without using Claude design. Now it's actually wanting to brainstorm [music] a few more specific variations. Let's see what it's asking us here. We set which sort of general version that we wanted and now it's asking us like to go a little bit deeper into it.

This one, the field notebook, that's the one that we're going to tell the agent that we like. And we said C which should have been B3. And what it will even do is create a full mock-up for you. So here it's made this dashboard screen for us and the setup settings screen for us.

And we [music] can mention any sorts of changes that we'd like to make or if this is good, we can just go ahead and approve it. This is awesome that it makes the mock-ups for us. Like how many tokens would we have wasted or how much time would we have wasted if we would have just prompted it vaguely, it spit something out, and then we had to redo everything, right? Because we didn't like any of it.

But this way, you can lock in precisely every little detail first, make sure that your plan is like bulletproof, make sure it's super solid before any of the code gets written. You know that you're heading in the right direction. And it also gives you this very thought-out methodical process to go through, right? Like the same way that we should develop code, organized and well thought out.

This does remind me of a different project that I've used before in the past. Like the B Mad method, maybe some of you guys are aware of it. But what I think is the differences between these is like the B Mad method was really there's a lot in the B Mad method and it can feel a bit heavy. But Superpowers feels like really light.

It just feels very efficient and it just feels like an upgrade. So you can see here it's given us an update. It says we're about 85% to a solid V1. It let us know what it changed and it also just let us know that it's going to continue to be using the same sub-agent driven approach to finish it up.

And you can see this is what it looks like when it has the two sub-agents running. So it looks like as I was working on it, I hit my token limit and we're almost there. I'm going to come over here. I'm going to say install plug-in on my cursor.

Or add plug-in, that's what it is. Add plug-in. And I'll look for the Superpowers here and we'll go ahead and just install that. We'll just set it for this project.

Now I'll just ask it to finish up this project. This is where we were and this is the current issue. That's just a part of building any app. What's software without a few bugs, right?

It's got into the home screen and now if I go ahead and enter and hit save, then it will give me this. But I just wanted to give you guys an idea of some of the cool things that you can make. If you want to check out the repo, it's on GitHub. Just look up Superpowers for Claude Code or Open Code and it will pop up for you.

If you're serious about taking your AI skills to the next level, consider joining my school community. Hitting the link in the description will take you right over there to it. You can see we just hit 216 members and I'd love to see you over there. So thank you so much for watching this video.

If you liked it, please give it a like and subscribe. And if you like this video, you may enjoy checking out some of my other tech demos. I'll put that on the screen for you somewhere right over here.

Open Code is an open source AI agent that lives in your terminal and can do anything on your machine and it works with any AI model and you can give it any task. In this video, I will show you eight insane use cases that save me many hours every week. From finding leads to organizing files to data analysis to deep research, Open Code can do all of these. However, I do have to warn you, this AI agent is extremely powerful.

It will do whatever you ask. So, make sure to use it ethically. Now to begin using open code, just go to open code.ai. Copy this terminal command.

Type in terminal. Boom. This will open the global terminal on your computer and then paste it in and hit enter. This will install open code if you already have it.

It will update it. And there you go. You can type in clear to reset the terminal. The next thing you need to do is type in open code of login.

This will show a series of different providers for AI models from Open Code Zen which is their own to enthropic, GitHub, OpenAI, which by the way this is probably the best because a lot of you already have a CHG subscription whether it's the pro or the plus doesn't matter. You can just select that go to this link obviously will be a unique link for you. Just copy that. Boom.

Paste that in. I'm going to select my personal account because u I have the pro subscription. And there we go. Authorization successful.

We go back to the terminal. You can see login successful. And then I can just type in open code and it will launch the open code agent globally on my machine. Amazing.

Now once you go through the authentication the next step is to just type in open code into any terminal. So that could be your global terminal or it could be a terminal inside of an IDE like I did here inside of cursor. And as you can see it launches open code. If you want to customize the colors just do / themes.

But this is it. See the build mode either build or ask. You see the model and you see the provider. Now, to make open code a lot more powerful, we're going to give it an MCB server so that it can operate the browser.

So, first off, I'm going to CD out of this. Boom. There we go. Uh, I cd to the root folder of my computer.

And then I'm going to launch Open Code right here. I'm going to ask it make sure to edit the following file. Paste that in at/openode/openode.json. If it doesn't exist, create it.

Otherwise, just edit it so that it has the following JSON. and then control commandV mcp.json just to show you what that looks like. This is the schema we need to give it. Right?

So the mcp chrome dev tools and this here's how you install that mcb server. Now again uh this is just to show you this file is irrelevant. We can delete it but I paste it in open code compresses it these nine lines is that JSON I just show you. Do not change anything else.

Boom. Enter. So as you can see this is the same JSON. Feel free to pause it and copy it.

It's finding the file. It listed it out. Doesn't exist. Directory exists, but the file doesn't exist.

So, it created it and it's done. So, now if I open a new terminal and type in open code, drag it here. This one, the new one, it should be MCP server tomcp. There we go.

Chrome dev tools connected. So now we can give it a lot more things to do. Now, the first use case I'm going to show you is finding highquality leads for any business. So, I'm going to go into the prompt area and I'm going to speak it.

I need you to find highquality leads for my business of implementing AI NA10 automation for local businesses. Personally, I live in Warso, Poland. So, I need you to find businesses that would be ideal for this and find their contact info online and save them into a clear markdown file. Get to work.

Answer in short. Boom. Here's the prompt. I spoke into existence.

Literally one paragraph. And now, Open Code is going to get to work. It created a list of to-dos. Research ideal businesses for NAN automation.

It's using web fetch. Okay, maybe let me interrupt it. I'm going to press escape twice and say make sure to use the Chrome DevTools MCP to execute any of these web tasks cuz I want to watch it work. It's probably not the most efficient, but it's going to be a lot more visual.

There we go. Boom. It I'm not doing anything. It's using it by itself.

We can make it side by side actually. Let's make it on the side. Open code on the left. I'm going to let it do stuff.

It's literally operating the browser by itself, guys. Crazy. You can give it real tasks and will do it. Now, it's searching businesses.

See, personally, I don't speak Polish, so I don't even understand half the stuff, but uh obviously it can easily understand it. Right now I'm using Opus 4.5 but even the latest Open AI models GBD 5.2 can easily understand any language. Cool. So it's looking for e-commerce businesses.

And keep in mind my prompt was very basic like my prompt is doesn't even say what type of businesses you know it's just like ideal for my business model. And you can do this whether you're a personal trainer, whether you have a sona, whether you have a gym, whether you have a construction business, whether you're electrician, doesn't matter. You can give it real tasks and it will do them. Cool.

So now it says I've collected great data. Let me update it through and create a marker file with all the leads. And keep in mind this was like 60 seconds, 90 seconds, very fast. So boom, here we have a new file.

It found 33 businesses that are all from Warsaw. Marketing agencies, real estate, accounting firsth. So let's look at it. And uh here are the businesses, their addresses, their websites.

1 minute 41 seconds. So literally 101 seconds, we have a list of 33 leads. Guys, we really are living in the future. But if you think this is insane, just wait until you see what's coming because we have seven more use cases that Open Code can do.

All right, the second use case is going to be organizing files and folders. So again, let me start open code. Boom. I'm going to say find the downloads folder on my device.

Analyze it to find the 20 oldest files in there as well as the 20 largest files and present them to me in a clear format. Do not delete them just yet. Boom. So, a lot of you, myself included, have a tons of unnecessary files and folders on our computer and we can use open code to help us organize this, right?

So, it'll find the downloads folder. And some of this might need to be blurred, by the way, because these are my actual files and some of it might be personal, but I wanted to clean up my downloads folder, right? It's probably too long, too large. Let me see how long it is.

Downloads. Get info. Yeah. So, 20 GB in my downloads and 2,400 items.

So, way too many files. So now it's giving me the lists, right? Top 20 largest files, mostly video files, raw photos. Okay, so let's look at it.

Oldest files. Yeah, none of these seem to be important. So I think we can delete them all. Let's look at the 20 largest files.

And I think we can probably delete all of them as well. So now get to work and delete both the 20 oldest files as well as the 20 largest files. Do not delete anything else. Boom.

In a matter of a few seconds, it'll help me save a lot of space inside my downloads folder and uh stay a bit more organized, which again manually I could do it, but would take me probably 10 15 minutes. Open code is just one or two prompts. There we go. One fuzz special character issue.

Oh, this is a video from the second channel. By the way, this video will be cross-osted on my second channel, which is more focused on software and how to build an AI software company. So, if you're interested in that, make sure to subscribe. The link to my second channel will be below the video.

So, it says it freed around 15 GB. Let's verify that. I'm going to right click on the downloads folder again, get info. And there we go.

It's true. So, it went from 20 GB to 4.3 GB. So, saving me 15 GB of storage. Very nice.

The third use case I'm going to show you is using Open Code to analyze lots of data and to visualize it. So, here I have a Markdown file with over 250 startup ideas. And you can look at the first few, but we're going to blur the rest because these are only available to the people in my accelerator. But, as you can see, this is over 1,000 lines.

It's over like 250 different AI startup ideas. So what I'm going to do is I'm going to use open code to analyze it. So read add startup ideas and analyze all of the startup ideas inside organize them into different categories and create a visual obsidian style graph that groups them into clusters and output that graph as a PNG file. This is multiple tasks in once.

And again could you do this manually? Sure. But you need the right skill set and even if you have the right skill set, this is minimum 60 90 minutes of work. Open code is going to do that in less than a minute.

So now it's writing a Python script to categorize all these ideas before it can generate a graph. And notice how anytime we give it a task, it creates these to-dos. Now this time it was pretty easy because I listed it out. But in previous tasks, it did it by itself.

So instead of trying to do like one big thing at once, it breaks it down into three to five steps and then focuses on one step at a time. And by the way, pro tip, this is how you should work as well. A lot of you guys when you're starting out and you're trying to build a business or you're solving a big problem, you get overwhelmed by a big task. Just break it down into four smaller tasks and focus on each of these subtasks one at a time.

This is such a good productivity tip. Make sure to use it in your life and business. Okay, so it finished writing 400 lines of Python. Now it wants to install dependencies.

So in install mattplot lib, it wasn't there. Now it installed it and it'll visualize it and save it as a PNG file. It started. Okay.

So it created a virtual environment to run it in there. And we have the PNG now. So verify if PLG was created. It's going to update the to-dos.

And we can actually go to the right and give us the final answer. I've analyzed 234 stars from your file and organized them into 21 categories. The obsidian style graph has been saved as startup ideas graph.png. So as you can see the categories are AI infrastructure and APIs, niche tools, HR recruiting, AI development tools, productivity personal tools.

Yes, stuff that I have expertise in. No surprise. But let's look at the PNG file. Wow, very nice.

We can zoom around and explore this. This is very nice. Travel lifestyle consumer apps. Super cool.

Fine-tuning ML ops enterprise and B2B automation and agents. Very, very nice. And again, how long was it? 2 minutes.

Crazy. The fourth insane use case I've been able to find for open code is custom deep research. So, let me give you an example. I'm going to paste in a prompt.

Execute deep research on the topic how to reduce no show rates for sales calls. This could obviously be any topic that you're interested in using YouTube as the primary source or you could say using Reddit as the primary source. And there we go. It opens the web browser again and it goes it controls the browser and it's going to execute the research.

So obviously it needs to close this warning. It can click amazing. How to resur rates should click on a video and find the transcript. And again guys my hands are not involved.

It's using the MCP tool that we set up earlier to operate the browser. So first it opened this tool to find these right videos from Dlog, Sabres, Sububi, Tyson, a bunch of people. It just found these videos and now using YouTube DLP which is a I think Python library it's going to find the transcripts of the videos and analyze these transcripts and give us the answer as to how what's the best way to reduce not show rates. Right?

So it wrote a Python script using uh YouTube transcript API to get the transcript of these videos. Seems to struggle to get the transcripts in a bunch of different ways. So it's trying things. It doesn't give up on the first error.

Notice that it keeps trying, keeps going until the task has been completed. All right, there we go. It found something that works. YouTube transcript API.

So, it would probably had an older version. I've successfully retrieved transcripts for the videos. The output was truncated, but let me save this as a file to read. All right, so smart.

Instead of being satisfied with just 14 seconds of transcripts, it's going to save it as a full file. So, it's even does its own context engineering. I've collected substantial transcript data for multiple videos. Let me read the remaining transfer content and then compile the research brief.

And again, completely handsoff. It's doing all of this. I just gave it an initial prompt and it's doing deep research. And this is way more photo deep research than just JGB or proxy.

You can customize a lot. You can tell it which sources you want, how you want to research, how you want to output anything you can want. And it has access to these libraries that you cannot execute inside of JGBT. Why?

Because open code runs locally. It's fully open source. It's locally in your machine. It can do a lot of things.

Now, of course, there is still a risk that it's going to mess up some files on a computer because it's not isolated, right? So, if you want something that's fully private and secure, use Agent Zero. It can do everything that Open Code can and more. But Open Code is just more focused on coding.

Agent Zero is focused on everything else. So, actually, for a task like this, I would definitely use Agent Zero. And in fact, recently I made a whole in-depth video on how to set up Agent Zero and how to use it. You can watch that right here.

It'll also be linked below the video. There we go. It finished writing the report. Let's look at this.

Nearly 300 lines of in-depth research on what to do to decrease no show rates. So yeah, this is a very very thorough deep research. It took 5 minutes. I gave it a single prompt, just a one paragraph in plain English.

And here we have it. YouTube research, how to read your social rates. Total videos analyzed 13 combined view 75,000. Even the date source YouTube executive summary details of each video transcript.

Yeah, this is very very thorough. And again, you can do this on any topic in any industry. Have a very nice output that like a lot of the times you would have to pay a consultant thousands of dollars to do this. Or again, if you wanted to do this yourself manually, be prepared to give it a half of a day or a full day to watch all these videos and create a nice report like this.

But for Open Code, it was just 5 minutes and 15 seconds. The next use case is something that all of us can do and should do every now and then, and that is to figure out why our computer is getting slower. So, I'm going to paste in the prompt. I prepared find out why my computer has been running slower recently.

Uh check load averages, memory pressure, disk space, stack processes, and swap activity. Basically, analyze my entire computer and figure out why it's running slower and then give me a report. I told it do not make any changes yet. Do not delete any files yet.

I just want a report to figure out why my MacBook has been slower than usual. Now, to be honest, it hasn't been slower than usual. Uh but hey, if you have an older PC or if you notice some slowness, single prompt to open code and like what is it? 20 seconds and we're already getting an answer.

Bas says, "Here are the top five reason your MacBook was slower than usual. High load average system up time. Your system hasn't been rebooted in 11 days. It's the beauty of MacBooks.

Uh I remember when I was younger and using Windows. I had to restart it every day." Brave browser resource hog. Yes, I'm using Brave browser with many open windows. Docker VM.

That's agent zero. Obviously I'm using agent zero at all times running locally instead of sending all my data to open anthropic which then train on those data and you know sell it to palanteer but hey I cannot go too much otherwise they're going to shut down the channel. Uh but yeah Windows server OBS yeah obvious OBS is clogging a lot of CPU obviously I'm recording. Okay so very nice report of why my Mac is slower than usual and then if this was an actual problem we could solve these one by one.

So, if you have an older computer, all it takes is a single prompt to open code and it can help make your old slow PC fast again. All right, so the next use case I'm going to show you is pretty insane. It's using open code for writing articles for your website. Now, in the past, this used to be called SEO, search engine optimization.

Now, this is still a thing, but what's becoming even more important is AEO, answer engine optimization. Now, there's different terms for this, like GEO, generative engine optimization, doesn't matter. Basically, it's optimizing your website for traffic from AI because soon enough nearly 100% of the visitors will be different AI agents that are browsing the web. So, I gave open code a very ambitious task.

Use the MCP Chrome tool to browse different sources comparing the existing code review AI tools for your CSA products. Now, this obviously could be any article topic you want. Could be different diets, could be how to increase your testosterone, whatever is relevant to your product, to your niche, to your industry that you want to write an article on and put it on your website. Just replace this part of the prompt.

Next up, research how to optimize articles for AI agent traffic. See context. So here in the context below, I just explained what this is, right? What is AI agent traffic?

Brainstorm five different articles relevant to topic based on the sources. Pick the best idea. Actually write the article yourself. Save as MD file.

Build a simple single HTML website in this codebase. Put the article in there. improve the design so it looks unexper this could be a position in a company research the topic write the article and deploy it on a website like this would be a full human job in the past now it's it's a single prompt to open code so let's see how it's doing it's a definitely the most complex use case so far all right so here's the MD file we have the article scroll down it's pretty long article 354 lines but hey hopefully it's optimized for agent traffic. I know nothing about a or g optimization, but open code does because it researched it, right?

So now it's building the single HTML website. And this works with any framework, whether you use React or you use Angular, whatever you use for your website. Open code can design the article and help you deploy it. That's the main thing.

It can do the end to-end process. So if you want more users, if you want more traffic to your website and you're not using tools like Open Code to write articles for you, you're falling behind. This is literally so free. The difference is first of all knowing that this is possible and number two doing it.

Thanks to videos like this, you know it's possible. So make sure to subscribe so you don't miss future uploads like this. But the second thing is actually doing it right. Most people are just chronic watchers.

They just watch. They, you know, productive procrastination. They never execute. They never do.

Thanks to AI and AI agents, you have so much leverage. If you actually have the slightest big bit of ambition and the slightest bit of work ethic, you're gonna out compete everybody else, especially in 2026 because AI agents have gotten so good. That's why you really cannot fall behind on this. And again, I'm just sitting back, guys.

Like I I could be reading a magazine. I could be going to a cafe. I could be driving my car, which I don't have any car. You get the point, right?

I could be doing anything else, but Open Code is working for me. I just send a prompt, go outside, go to the toilet, take a nap, and it will do a full day's worth of work uh in a matter of minutes. Insane. Really insane.

All right, so Open Code wrote a 1,000line HTML file. This is kind of crazy. It took over a minute just to write a single file. I'm not scrolling all the way back.

Okay, I'm not scrolling that. But uh let's look at it. Open a website using FCP tool. Again, not doing anything.

It should open itself. Actually, is it even open? Where is it? Oh, there it is.

Okay, I closed it. So, this is our article. Look at it. Best AI code review tools for CI/CD table of contents.

This is clickable. You can guys this is a fully interactive website with styling animations. Crazy good report. Look at this.

Code rabbit kodu sorcery kurasto. It's a good report on which are the best AI code review tools. Like this is crazy. Took 10 minutes.

Okay, this was the longest task so far. As I said was the most ambitious task so far, but open code managed to do it. It didn't crash a single time. It kept running for 10 minutes straight.

And not only did it research the topics, learn about how to optimize for AI agent traffic, write the article itself, and fully build a website and deploy it end to end all from a single prompt. Insane. All right. So, the next use case is using open code to create autonomous documentation.

So, let's say you have project and you have a bunch of code, but you didn't do the best way of documenting it. Well, guess what? Open code can come in and fill in that missing documentation. So, let me show you.

I'm going to use my actual software that I'm building for my accelerator. Boom. Let's hit clear. Open code.

By the way, every person in my accelerator gets custom accountability software. And we're rolling this out uh this week. But anyways, I'm going to paste in the prompt. Boom.

Analyze this codebase and identify all areas where documentation is missing, outdated or incomplete. For each gap you find, number one, list the file function that needs dogs. Number two, explain what the code does. Number three, write the documentation for it.

Then create or update the readme.md and any relevant dog files. If the /docs folder doesn't exist, create one with proper structure. Start by exploring the codebase structure first. Do not change any code.

Just create new documentation. So another use case that especially if you're a VIP coder, you need to be using, you need to be adding documentation because if you want other people or other AI agents coming into your codebase and being productive right away, you need lots of documentation and especially relevant documentation. Right? So now I'm using open code to fill that up.

I have some basic uh readme file or whatever but admittedly this codebase specifically could definitely be better documented. So let's see. We have nothing in the in the staging. So no changes made so far.

So let's see what open code does. Will it find stuff that needs documenting? And if so, how will it do it? Will it just write comments?

Will it create new files? Again, this is a at bigger companies, this is a full-time position, like adding documentation, making sure docs are up to date. Sometimes there's developers that spend half of their time doing this. Now, we can just single paragraph to open code and it'll do it.

But again, you need to know this is possible and you need to actually do it. Otherwise, there's no point. Now, let me read the key source files to identify documentation gaps. I'll read the main applications.

All right, so now it's reading files. Look how fast it's executing these tools. Amazing. Open code is very optimized for speed.

It's doing a lot of these in parallel as well because there's no way it's deploying it so fast. And by the way, this is the difference between just an AI model like cloud open 4.5 and a full agent like open code the harness the prompting the tooling. This is what sets it apart. All right, based on my analysis here are documentation gaps files missing request headers.

Okay, let me now create or update the documentation. So it found the biggest issues. Okay, read me file describes the landing page VSSL but codebase is actually an accountability dashboard. So it's completely outdated.

readme file. So, it fixed that. Look at the to-dos. So, it created a bunch of to-dos to fill in the missing documentation.

And again, I'm just chilling. I'm just commentating what it's doing. You can give it this task. Go back, you know, browse Twitter, do anything else you want to do.

Maybe respond to some emails, whatever other tasks you have, and just let open do this. And this is a use case that anybody building any type of software can start using today. All right. So, it's on the last to-do.

And again, this one is taking a few minutes because each of these files is 200 300 lines. It's very thorough documentation. Uh admittedly, I could have told it to be bit more concise, but it's doing a good job. Okay, it's trying to document everything thoroughly and it created the new docs folder.

We have API reference architecture offflow components deployment development. So, anybody or any AI agent that codes into this codebase will now have a much easier time getting up to speed. even creating a index.mmd as a documentation hub with explain everything and the last updated file. So it needs to like it shows you when it was updated to see how outdated outdated the documentation is and whether it needs another update.

And again I can run this in 14 days in a month to go through everything again and update the documentation so it's up to date. And again this was less than 8 minutes. This is thousands of lines to in total. Look at this.

Boom. 80 lines. This is 284. Let's at the bottom 321.

This one is 330. This one is Yeah, this is thousands of lines of documentation in 8 minutes. Doing this manually would be a pain and I would never do it. So say now com pull the latest from GitHub, do a commit and push it.

Okay, so you know in 2026 you don't have to do your commits. You can just delegate it to AI Jones. I mean it was possible in 2025, let's be honest. But hey, I'm just going to show you with open code.

Oh yeah, the main branch is master. It just, you know, gives you more aura if you're if you name your main branch master. But hey, realistically, it doesn't matter. So it pulled uh recent logs, checks recent logs, recent comments with git log.

Now it does a comment and it's going to push it. It's crazy. You can literally automate anything in 2026. Wild.

Wild. All right. The use case number eight for open code is going to be how to use it to build an interactive pitch deck for any idea you might have. So here's the idea.

The first startup mobile app that would remove all frictions from recording videos and posting them on social media. Super simple. Feel free to pause and read it. But that's not the main point.

The main point is that I have prepared a detailed prompt for open code to create an interactive investor pitch deck for this idea. So as you can see it gives a role goal text tag the idea being pitched pitch deck slides and open code should create an interactive pitch deck that could be sent to potential investors so that we can get funding for this idea. So a lot of you are building startups and maybe you don't have you cannot bootstrap it right with vectal what I did is I bootstrapped it and that's what allowed me to build it myself and from founding to acquisition was 14 months so from literally choosing the idea to selling it for 1.8 million took me 14 months but it was possible because I already had successful businesses and I could fund it myself. If you need funding, which in this case, you know, it's debatable.

AI has made it more possible than ever to build startups. But let's say some ideas still require funding. Some startup ideas are more complex than others. If you knew, you need a proper pitch deck.

You need to pitch investors, right? And you cannot just do that with a amateur not research pitch deck. And maybe you don't even know what a pitch deck looks like. Well, guess what?

Open code can build one for you. So again, I from a single prompt that describes this idea, describes the target avatar, and tells it to build a pitch deck. And now, Open Code creates a list of to-dos like always and gets to work. And by the way, if you want to take it to the next level, what you could do is for each investor that you're pitching, include details about that investor and create a new custom personalized pitch deck that appeals specifically to that person.

So, personalization is a huge thing in the age of AI. Well, in the past, maybe you were doing an email campaign and you know, you have 1,000 leads and you had to say send the same email. Guess what? Now, you can make these way more personalized.

So, yeah, AI is going to be huge. AI agents are huge for personalization and if you aren't using them you really are are missing out because you can have higher converting ads you can have a more open rate in your emails you can have a more successful page decks whatever like wherever personalization makes sense use AI agents to personalize like it's worth it you just need to you just need to try you just need to do it yes there's a friction using tools like open code might be intimidating for the first time because it runs in terminal but guess what it also has a dedicated app with a graphical user interface but the you really have to f push through the first 30 minutes, first may maybe 60 minutes if it's, you know, if you're a beginner and you're not familiar with terminal. But if you can sit down and push through the friction and actually implement one or two of these use cases I showed you, you're going to be ahead of 99% of people because most people are just going to watch this. They're going to be like, "Wow, open core is insane." And then they're going to go to sleep and wake up the next day and forget about it.

They're not going to do anything. Okay? If you actually want to be one of those people who completely changes their life in 2026 and gets ahead of everyone else, sit down when you finish watching this, block out 60 minutes and actually implement one or two of these use cases that make sense for you with open code and start using it dayto-day. You will like trust me, you will thank me later because these AI agents have gotten so good, people just don't know how to use them.

So I guess that's my job to research that and communicate it to you in an easy to understand way. Again, if you want more videos like this and if you want to be on the cutting edge of AI, make sure to subscribe. That way, YouTube serves you videos about AI agents and that way you can stay ahead of the competition. So, again, please subscribe.

It's completely free and it takes 2 seconds. All right. Open code is still writing, still creating our pitch deck. Uh, it created a new folder to stay organized.

Very nice. And it's going to be a full Wow. So, it's not just a single HTML file. It's using Vite.

It's going to be a nice website. Yeah. It's crazy. The cost of developing software is falling through the roof.

I mean, I just spent like $0.8 to create a pitch deck that could raise me hundreds of thousands, maybe millions of dollars depending on your connections and your idea. But, uh, yeah, the leverage is insane on people who can execute. Entrepreneurs are going to be way more valuable, and there's going to be more entrepreneurs than ever. And you're going to be able to build a multi-million dollar company with less people than ever.

Uh, so what matters is not quantity of talent, but quality of talent. If people on your team aren't using AI, you are either a bad leader or you probably need to get a new team. That's the harsh truth because people who use AI are going to absolutely out compete people who don't. By the way, if you're wondering about this cap, this is a custom one of one vectoral cap and it is not for sale.

So, if you want it, too bad. Only one exists in the world and we probably won't make more. So, it's unfortunate, but I'm just answering comments ahead of time. Yo, it's really taking its time with this pitch deck.

This this better be good. Okay. Um, it created a bunch of files. It created an entire entire code base for this.

So hopefully I'll be impressed. I thought it would be a bit simpler, but open code is really taking its time. Look at this. Look at this.

It's very interesting. It ran a TypeScript checker npm run build. It found a few errors and now it's fixing them practively. Insane.

Like the people behind open code really cooked with it. Okay, now it opens it using the MCP tool and look at this social video publisher. This is the startup idea and we have a whole pitch deck for it, right? Record once, publish everywhere.

seed drowned 1.5 million. Next, the problem. Content creators are drowning in publishing friction. Oh my god, this is guys, this is actually something I would need.

So, I'm amazed because this is one of my startup ideas from the talk I showed earlier, which again, um, it's going to be blurred because that's exclusive to my accelerator. But man, whole pitch deck, the solution, animations, pricing, traction, competition. This is crazy. The team, the ask.

Wow. Wow. 7 minutes and it's a fully built pitch deck that you could just throw up, deploy it real quick, send it to investors. Wild.

I don't even know what to say, guys. Like the use cases are getting crazy. We need a new word. Like the word insane doesn't do it justice.

We need something more insane than insane. But yeah, open code is crazy. U if you're not using it, you're missing out honestly. And um hopefully you found this video valuable.

Now, if you actually see the potential of AI and if you understand that 2026 will be the year when few people get insanely ahead and the rest of population falls behind and if you want to do something about it and start your own business this year, make sure to watch this video. I just made a full breakdown of the best AI business models for 2026 and how to actually get started. So, watch it here. It'll also be linked below the video.

That being said, thank you for watching and have a wonderful rest of the

Do you want to get started with Open Code and you don't know where to start? If so, this video is for you. We're going to show you how to install Open Code, what are the main features you should know about, and how you can get started as quickly as possible. With no longer to do, let's jump straight into the video.

All right, so to start off with, what actually is Open Code? Well, Open Code is a AI coding agent. It's available both as a terminal based interface, a desktop app, and an ID extension. We're going to be doing the terminal interface in this demo.

So, we're going to just jump straight into it. But to get started, just scroll a bit down on the docs here. And you'll find there's multiple ways that you can get started. I'm just going to do the brew install over here.

I'm just going to copy this. I'm going to open a terminal. You can use powers script or whatever you you want. Run the terminal and literally copy and paste that command and you will install open code and it will download and run everything through.

All right. So, now that we've installed Open Code, how do you actually start using Open Code? So you'll see I'm in a folder here. I'm actually in my own project called open code for/intro.

It's got no folders or files in it. It's just got a get ignore. So I'm literally just going to open the terminal at this location. And I'm literally going to type in open code.

And this will actually launch our open code instance. One thing to note, open code comes with two default agents. And that agents, one is build and if I press tab, one is plan. The idea with both these agents is you want to use the plan agent to actually pretty much um scan through your your current repo or your codebase, come up with a executable plan, then press tab and go to the builder agent and then stop building.

That's the idea of it. But one other thing I just want to show is if you want to use a different model, you go forward/models here. And open code actually comes with a free few models out the get-go. You got this Miniax M2.

You got Grock um Grocode Fast, which is alo another one. Grock code fast, which is also free. Uh this one. So you can actually use a free model off the bat.

If you want to actually use your Open AI subscription, there's actually a way for you to do that as well. So if you just go exit here and you go open code orth login, this will this is the method you'll use to add either an API credential or an oorthth. So for this case, I'm just going to go to OpenAI. So we're going to go login and I'm just going to go down to OpenAI here.

We're going to press yes and then I'm just going to say I want to use my chapter pro plus. Hit that. I'll go to the link on screen. It's generally just a take me to the oorthth I'll log into my chatbt account.

All right. And then you'll just get you're signed into chat. And if I go back to the code, it's pretty much like that. Login successful.

I can clear this. I can go to open code and I can just go models and then I can just go to chat gpt. Look for don't see here I'm not really getting the ones I want. So let's go codex and then we can go open AI or here.

So I can use the codeex or if you do go models and say it doesn't come up. You can see at the bottom here you can ch uh change providers and you can also select favorites. So that's why you you see some of these are favorites. You just go F and they become favorites.

But say you're not seeing open A here you just want to connect the provider. You can also go Ctrl + A. So, if we just do that quick and here you can just see I can quickly change between providers and you can see what I've connected. There's a whole lot a lot more providers here that you can also um go through if you want to use a different one.

Cool. Another thing you can do in open code, you can actually change themes. So, say you don't like the open code theme, you can go like one dark nord. You can come here and change your own theme.

That's another one. I'm just going to keep it as open code. I enjoy this theme. All right.

just to get started to show you how this works with the plan and build agent. I'm just going to dictate through the mic here. All right. All right.

So, I just want to make a simple dashboard um just describing different services for a pizza shop. I just want to make an idea on what the landing should be and different aspects of it especially to entice customers to come to my inbound store um so they can get away from the computers. grab that and then start jump, you know, trying to do a plan. We can see here it's actually asking what we want here.

We can actually go single HTML. This is a new feature they recently bring out. Let me just make this a little bit bigger so I don't have to scroll the whole time. And you can see here, plan, discover, structure, define landing page, all of this.

Um, so it's going to ask for a scan. Proceed. I'm just going to tell it proceed. It's got nothing to do.

You'll find there's nothing here. And it should then just say, "Cool. We need to make the plan and I'll switch to the build agent and then it can start establish that plan. Cool.

I'm just going to go tab here. Cool. I'm telling to build the page now and you'll see it'll just start building this currently right now. Very simple, straight to the point.

All right. So, that's done. If we just open this, we can see this is what it built. Very standard uh text HTML page.

Not bad. That's just a quick demo of the default agents. All right. So what happens if you actually want to build your own custom agent?

All right. So if you want to build your own custom agents, just read about it. You can come here. Just go to agents here.

And in agents, you they've got different ones. You got primary agent. So this is your main agent that you can select like build or plan. And then you get your sub agents, which you can't select, but your main agents can call.

So we're going to just do a quick example with um primary agent and some sub uh agents. We're going to go through and use the markdown. So, it's quite simple. I'm just going to grab this as a template to get started.

We just jump back to our code. And you'll see here we got nothing here. I'm actually going to just make this over here a new folder called OpenCode. And inopen Code you, I'm going to make a folder called agent.

And I'm just going to do like that. And in agent, I'm going to make a new folder. And for this one, I'm just going to call it um main agent MD. And I'm just going to copy that what we have here.

All right. [clears throat] So, we can see this mode is sub agent. So, if I actually run open code again now, this main agent won't pop up. So, let's just show you that.

Okay. So, I'm just exiting my open code and I'm going to run it now. And if we press tab, we don't see that agent. So, I'm going just exit.

I'm just going to change this to primary. Cool. And I'm just going to go back here. Run open code again.

And we should see our new agent there. Main agent is there. Perfect. And if we run here, it will use this command that we stated over here.

Code quality, best practices, you name it. So, it's very generic, but we can add on to this. Maybe we say just telling it, hey, before any requirement, you know, refer to the master plan agent for understanding the user's intent. So, we're going to say, all right, in my open code here in the agents, we can literally just grab this one and we can create a sub aent here.

I'm just going to make a new folder called sub aents because I just like things to be organized. And in here, I'm just going to make our new agent called master planner. Yeah, I'm just going to put in here. And I'm just going to say, all right, so just for this demo, I'm just making this kind of silly, telling it to only uh reply with burger references and emojis.

One thing to note just quickly while we're looking at here in your agent, you can define what tools it has access to. So we can see this one has no right, access, edit, or bash. We actually need to go back and change that. We can see what model it's tied to.

We're going to take this away. We actually don't care what model it needs. So, it will run on whatever main model that we select. And we'll do that with the main agent.

So, we're just going back to the main agent here. Uh, we're going to say write is true. And we're going to just make all the rest of this true. Uh, we're going to update this.

Okay. And we're going to also take that model away. So we can use any model. All right.

So one thing we'll note is if we just jump back to our main agent here, we have to exit cuz our changes aren't saved. We're going to just run open code again and we're going to just jump to our main agent. A little hack you can do is you can go open code- agent and then you can actually name your agent here and press enter and it will actually open in that agent automatically for you. So now we got our main agent.

I'm just going to let you going to tell it the same thing. All right. Hey, we want to update our website, but we actually care more about uh developer like health and we're just trying to make sure we are actually catering to developer health. Mainly we don't want developers doing too much on pizza and things like that, but we want to focus more on our pizza delivery business online, not really in store.

So we can make this plan. All right. So hopefully it'll call our sub agent. um and go through.

So we can see there it is delegating. And what's nice with open code, if I actually just press to the side here, I can actually see what's happening in my sub agent. So we can see what is going on, what the sub aents going through. And one thing to note is it didn't pass to our sub agent.

It actually just passed back to general task, which is not really what we want. So we can probably come here into our main agent here and say hey. All right. So I just quickly updated our main agent and sub agent.

One thing to note when you are calling your sub agent try make sure the name actually matches what it's expecting because under the hood how open code works it uses a a task command and then actually uses this open sorry this name here to pass to pass to the sub agent. So if the name is incorrect it won't find the agent. And in the sub agent here, I'm telling it to always refer back with burger uh burger emojis. This is to see if it actually works.

So, I'm just going to run open code again. I'm going to go open code slash double. All right. And I'm going to just run open code again, but I'm going to just target our main agent so we don't have to tab into it.

So, just jump straight into it. And I'm going to ask for the update on the site, which is just like changing the site a little bit. And we can see right off the bat, it is actually delegating to our sub agent. So, if we just go into that, we can see what our sub agent did here.

Just responded with some burger emojis. Not very useful, but exactly what we wanted. And And And that's waiting for returns. It actually doesn't know what to do because it just got burger emojis.

So, anyway, I just wanted to show you some All right. So, this was just a dumb example to show you exactly how main and sub agents work. But this actually show you how that looks in if you actually want to build with this. All right, just to show you how a main and sub agent could actually look if you actually want to use it on a day-to-day basis.

This is just a simple demo. We just got our main build agent here and we're just telling it every time it wants to complete a task, it should actually follow this procedure here. Implement, review, test, iterate. So, we've got some sub aents here.

We got a tester and we got a reviewer. So if we just go with that. One thing you'll note is edit is false. So it can read but it can't actually edit anything and if it does want to it can ask and test is pretty much the same.

It's got false for everything itself. It can run bash commands but we are trying to deny everything. It can allow some tests but that's all we're allowing it to do. So if we actually want to run this I'm just going to run open code again.

I'm going to run the main agent and I'm going to ask ask ask make a nextjs app. I'm just going to tell it to make a next.js app for our tech company about pizza shops. And it should create that and then it should then ask for a review and testing. So all right, just to quickly go over what's happened in the run.

So we can see we gave our main agent a very simple task. make a nextjs for tech company about pizza shops and it went and created our nextjs app and when it was done so it actually did its own builds and the rest of it. So it actually then delegated back to its sub agents to actually review each one. So if we just scroll down here we find when it's finished building the nextjs app.

So we can see it built. Okay, it's in a test application and then it delegated to its review agent. Then after that it actually gave it to the test agent. It had some feedback and then from that it's going to build again and we'll go through this loop.

Hopefully you see the power of having like this system where you can actually have a main agent where you can actually ask for review and test and then iterate on that constantly. So there's there's pros and cons for this design. This is not really elaborate. It's very like basic and broad.

So you might have varying levels of results. So every time you run this, it might be a bit different, but it's a very good way to get started. All right, I'm going to jump onto the next section I actually want to talk about, which is skills. And I think this is quite handy, especially right now.

So in the documentation, you can just find agent skills here. Right. So one thing about skills that I want to instantiate skills is a way that your agent can actually grab relevant context files. So we call it lazy loading.

And in that context you can actually have instructions on how it can run different script commands. That's what mainly mo most people use it for. So you could also have a skill for um UI design for example. So we're going to do that in this one.

We're going to do the project config. So, we're literally going to go open code skills, whatever the skill name is, and then skill.m MD. And this this is an example of an MD. So, we're just going to copy that.

Going to jump back to our code. We literally going to go to our open code here, and we're literally just going to make a new All right. To get skills going, you just need again go in the skill directory, whatever the skill name is. So, in this case, it's called front-end design, and then your skill.md.

And then here we can see what we're telling the LM to grab in terms of context. How to design different skills. This is just in terms of demo purposes. One thing I want to state is the description here is very important.

You kind of want to make this enticing as possible for the AI if you want them to pick up the skills automatically. Not that you have to invoke it. So you can see here I'm trying to do that. How to build the best and design beautiful accessible responsible user face interfaces interfaces.

Yeah, I don't know what happened there. Anyway, so with that going, if you actually want to have an agent to have access to the skill, one thing to note, it has it automatically. So skills are global. You can disable skills and then enable them individually.

All right. And you can actually enable skills here. You just have to be under the permissions tab. It'll be skill whatever the skill name is and allow.

So you can see PR allow. But by default skills are loaded automatically. You can go start all and then deny and then allow the c the certain ones that you really care about. But yeah, so if we wanted to do that for the main agent, we can say permission skill frontend design.

And if we just exit this now and we open open code again to the main agent. So here we're telling it, hey, we want you to use your skill front end design to fix the site. And we can see here it actually went in for a skill call and it actually used that name and actually got skill. And it's actually going to use that skill to update according to whatever we named it.

So that's how you can use skills. You can also put ash or a script command within your skills and tell the skill how to run that um script command. That could be quite useful if you've got a build script or a testing script and you can use skills that way. And if you are looking to get started a lot faster, I actually have my own repo called open agents control.

So I'm just showing this on the screen. And just to get started, you can literally just come down and grab this command here or another one suiting your needs. And you can actually get started and you can literally copy and paste. It'll actually do an automatic installer for you.

You can do local and you can do a quick install and developer. And you can then start using this automatically. This is using a lot of the main techniques I've learned over the last eight months. And you can use this all for free.

It'll just download and start and you'll see it'll update your open code here and just use the open coder agent as the main one if you are using for coding and I'll just show you that in a bit. All right. So once you've installed that you can just run open code now and you can literally just tab to open coder and this is the main agent I use on a daily basis that I am constantly updating. So definitely keep a lookout on the repo and for future videos describing what the process is going behind the scenes for all of this.

But yeah, this is the quickest way to get started. And lastly, there is a link down below. I'm trying to understand people's interest in building a community cohort. I really want to try understand how I can help people the most.

And I don't expect this to be too big. I really want to focus on the outcomes here. But if you are interested, please hit the link down below. Anyway, thank you guys so much for watching and I wish you the best in your open code journey.

Cheers.

All you have to do, guys, is paste this one command into the terminal, press enter, and this will install the skill. This can be used in any AI coding terminal or otherwise, and the quality of what it actually builds is absolutely crazy. This is an example from Claude Code. Today, we're going to be doing Open Code to see if it can follow skills properly, but the quality of this website, it's a fully-fledged, ready-to-rank website for a business in Dublin.

Let's jump into the video. Okay, guys, so recently, I've been mixing a couple of things together, and I've managed to make a skill which I think a lot of people will be interested in. This builds websites that are ready to rank on Google, as well as, if not better than things like bolt.new and lovable.dev. Now, obviously, you can do your own thing with the UI/UX, but the important thing is this base of a website is so strong that it will be able to be sold to someone very, very easily.

Now, this thing comes with a basic admin system built into it, a database that you can, obviously, offer to host for the person that you sell the website to. You can do maintenance for them every single month, show them that they're actually getting leads, etc., etc. This is the kind of thing that people have been waiting for. So, how do we do it?

So, the first thing you need to do is you need to run the command. I'll leave the command in the description. I'd recommend doing it all, um just yeah, just do all. And then, once you've run that command, we're going to write Open Code right here.

And then, once Open Code loads, let's just quickly update to 1.4.0. There we go. Open Code. Let's see what's new.

Okay, so there's a few new things here, nothing too major, but there is one thing I do want to mention. They basically pulled the rug out from under us, and this Qwen model is no longer free. I am still going to be using this Qwen model because I think it's probably the best open-source model, or open-weights model, if it even is open-weights. I don't actually know if it is.

Um but, yeah, I I just think it's really, really good still, and I'm just going to use it because it's extremely cheap. Now, there are some alternatives to using this. You could use Anti-Gravity for free. You could use CodeX-CLI for free, right?

Or you can use the CodeX app even if you're on a Mac, you could use this completely for free. But, yeah, um I'm going to be using a cheap Open Code model just cuz I think that's probably the best test of things. So, this does still say free, but I don't think it's free anymore, as far as I understand it. So, once inside here, once you've selected your model, let's just quickly check if the So, what is it?

Um no, Qwen 3.6. Okay, so it's not there. So, all you do is you just write \{{}slash} skills, and then you look for that skill, right? So, I'm looking for Astro.

I'm going to write Astro. There we go. And then, say I'm just going to do that and say activate the onboarding for this skill. I just want to know how well this can, um okay, follow the commands.

Okay, so I've now set the model to Qwen 3.6 Plus, just so you know. I had to go through and get Claude Code to change that for me, just cuz I don't know what the hell I'm doing. Um and then, now let's write skills and write Astro. So, this uses Astro, just so you know.

Activate the onboarding. Astro is a really, really good system for this kind of stuff, and then it uses a Turso database as well, which is completely for free. Okay, so I just had to quickly make sure that it was finding the proper files. It was trying to read an incorrect path, but I managed to get it in the end.

There we go. So, now it's read all of the skill, instead of just part of the skill. I want to know how well this model inside Open Code can follow skills. So, I'm testing both this model and also Open Code skills at the same time.

So, what is your niche or business? What's the primary goal of the site? So, let's say Let's try something different. So, an AI tool directory.

I want to show you guys that you can do many different things with this setup, right? So, we're making an AI tool directory. Yes, I want a database. Uh do you want to generate images?

Yeah, I guess so. Let's try it. Okay, so I just topped up $10. Let's see how much this costs at the very end, and let's see if it can manage to do this entire thing within its 1 million context window.

Now, these are the steps that it's created. This is pretty interesting. Okay, and now we basically just let this run, and we'll see how good this combination of Open Code plus skills plus the new Qwen 3.6 open-weights or open-source model, or will be open-weights \{{}slash} open-source model, does, and we'll be back when this finishes. This will take quite a while.

We'll see how much it costs, as well. Okay, so one thing just to mention quickly, guys, is this is doing the very basic thing of creating data from its memory. I wouldn't recommend this. Now, unfortunately, for some reason, Open Code's web search isn't working.

So, one thing I would change straight away is that instead of using Open Code, I'd probably use Claude Code for this, because it's much better at doing web searches. Now, it's supposed to do research on things like this. That's what the skill says, but because web search was failing earlier, it's just decided to create this data from its own memory. So, the end result here will, unfortunately, be Claude 3.5 Sonnet and GPT-4 and stuff like that inside the data, which is less than ideal, and it's not what we're trying to actually build.

But, unfortunately, just because Open Code's web search wasn't working, it had to do it from its memory. So, that's just one thing to mention here. This would be fixed by using this in Claude Code instead, which is most likely the test that I'm going to do next. Okay, guys, so the bot is still running, but this is kind of what it looks like, right?

So, okay, so like I said, it is still running. Let's see what we've actually got here. So, some of these things are 404ing cuz it hasn't finished yet. There are still some errors, unfortunately, but overall, I mean, the homepage looks pretty nice.

Let's just click on one of these. Okay, that doesn't work. Okay, guys, before we give you the final reveal, a quick shout-out from our sponsor, me. This is HarborSEO.AI, a tool I've been working on since 2024, and I'm trying to now make it the best SEO content generator on the market.

With huge updates, such as increasing the quality of the content writer to Sonnet 4.6, the new Clusters feature, which allows you to scan your website, find clusters, and then work on topical authority, the Spy, which allows you to look at your competitors and find out what they're writing, and then write those articles yourselves, and much, much more. As you can see, the founder offer is finishing in 14 hours. You can still go ahead and grab a free trial, which will give you the founder pricing, and just look at how well these articles are ranking on Google. Only 100 pages published.

There's It's obviously much more than that, but this is just 100 peop- people who have actually gone in and pressed publish. 34,000 impressions and 380 clicks in just 100 pages. Thanks for the attention, guys. Go check out HarborSEO in the description and in the pinned comment, and then let's look at the final result.

Okay, guys, so as you can see, it's pretty much finished. There's a few things that still needs to be finished, but it's just taking so long that I'm probably just going to jump in. Um it's literally been running for like 30 minutes. So, just so you guys know, like, the ability to run for a long time is basically how people measure how good something is, right?

So, this ran for pretty much 30 minutes straight, non-stop. I didn't give it any input or anything like that, and this is what it created. Now, this looks pretty damn good, to be honest with you. It looks like Claude Opus.

This is pretty much what Claude Opus would output. If I click on ChatGPT, you can see that this is an actual uh page, right, that would rank on Google. So, ChatGPT review features, pricing, alternatives. This is a really good base for something much, much bigger, which I will probably actually make.

The reason I would make this, by the way, is because I want to rank Harbor, right? So, I can put HarborSEO inside this tool and maybe get a few more people clicking on Harbor, right? So, that's why I'd do that. It's done breadcrumbs, which I didn't even ask it to do breadcrumbs.

It's got this entire browse feature right here. This is really, really good, I have to say. If you compare this to a build with, like, for example, um WordPress, this is significantly better than what it would have done with WordPress. So, just so you all know, this is using a database.

So, when I click on complexity, what it does is it it gets the information from the database and shows it to people. When people click submit a tool, it's the same thing. It gets they put them in the database, right? So, that's actually how that's working.

So, blogs is here. There's no blogs right now. Compare doesn't exist, it's a 404. It's already doing the 404 page, though, which is pretty nice.

Let's see what happens if I click this. There we go. ChatGPT versus Claude, very nice. This is very, very interesting stuff, guys.

If I can increase the quality of the search, right, so that this is all real information, up-to-date models, up-to-date pricing, etc., etc., you can see just how quick and easily you could make one of these websites and actually have it rank on Google. So, you can see right here, this is the submitter tool. So, um you could submit a tool right here. And then, you know, the admin or whatever would come and accept the tool.

Let's see if it did the admin page cuz it is supposed to. But yeah, overall a 43-minute run for a free Not free, sorry, they're not free anymore. For a cheap Chinese model inside a free AI coder is pretty damn crazy, I have to say. Okay, so there we go.

This is the admin dashboard. Let's go to newsletter. Let's put my email here. This is so damn cool, actually.

This looks really nice as well, I have to say. Let's refresh this. There we go. Bang, newsletter subscribers.

This is a whole website, a whole business built in 43 minutes. Let's check the cost. So, let's go to logs here. Let's go to credits.

Now, obviously, my open router is used by other things at the same time, but the cost of this was about $2.30, $2.50. I would guess it was less than that, probably $1.80. Absolutely insane that you can now build an entire business in 45 minutes for less than $2. Absolutely crazy.

Let's just submit a tool. So, Harbor SEO, https harborseo.ai. Select a category. So, marketing and SEO, I guess.

Um Harbor SEO writes SEO content for people. I don't know. Hamish openstreamserver@gmail.com. Submit for review.

There we go. And then, let's go back to \{{}slash} admin. There we go. So, now I can press approve, right?

And then, that's so cool. That's actually so cool. So, does that then just put the Harbor in in the thing in in here? Harbor.

No. No. No. Okay, so there's obviously a couple of things missing, guys.

The fact that it doesn't then send Harbor here is a mistake, but these are all things that like if you I did this inside Cloud Code instead, it would do all of these things instantly, for sure. But yeah, guys, I'm going to leave the video there. Thank you so much for watching. If you are watching all the way to the end of the video, you're an absolute legend.

I think this has been a really, really good test. I would like to do this again inside Cloud Code and start to make directories and maybe get them out there because I think this is a really good way to rank on Google and to help Harbor also rank on Google. Thank you for watching. Peace out.

Open code plugins beat claude code at this one thing complete workflow control to just quickly show what I'm talking about on screen is I've got the cloud code documentation and open code documentation side by side and claude code only works with the bash command where open code gives you a lot more access to the actual app the client and shell commands so you can actually customize your whole developer experience in open code way more than you code in Claude Code. So, if you're serious about automating your Dave workflow or changing it to suit your needs, this is probably the feature you can't afford to miss. Let's jump in. How do you get started building your first plugin?

Well, it's quite simple. You can either use in your global or your local per project. You just need to put in your open code folder plugin and then your name of your plugin. And once you've got that set up, you can put the code in your plugin.ts s or it can be ajs and you can then just start it and start testing with your plug-in.

It's very that simple and it's quite powerful because you can hook into different events. So let's have a quick look at what those events are. For example, you could hook into a certain event maybe before a message and change the LM temperature for a certain LM if it's there. Or you can handle messages.

maybe the message context is too long and you've got a a different way of refining context before it gets passed to a bigger model. You can then put that process in there. So to just get started, we're going to build a local plugin. I'm literally just going to copy the code that you see on screen here.

Essentially, all this code is going to do is be using the plugin from Open Code AI plugin. And that just allows us to have type safety uh when building this. And this will literally tell us when the session is idle. it will just say your code is done.

Just jumping in again. I've got nothing here. I'm going to make a local project. I'm just going to go new and I'm just going to make my open code.

In this folder, I'm going to make plug in. It's singular, not plural. And then from that, I'm just literally going to call this one called notify. DS.

And I'm literally going to import that. One thing you'll note, we've got these errors because well, it's TypeScript. And I'm going to use So, literally just going to go to the uh open code folder plugin and I'm just going to run bun in it just to initialize and I'm just going to say plugin file. Great.

And then I'm just going to go uninstall my plugin here. And once that's installed, everything should be working great. And everything is picking up. Now to see that if this is working, I'm just going to run open code here.

I'm just going to run a simple one at a junk just so it finishes quickly. >> Your build is done. >> And we can see our plugin is working very quick and easy. It's a simple plugin that we we made very very very fast.

One thing to note if you are debugging, I think this is always important to understand where you can find information is you can find the log files in on at these at these spots and you can always monitor your log with the tail.f command. This is just important if you just want to understand what your plug-in is actually doing and I feel like it's always just important in the development process to get blocked. Okay, on screen I'm just showing quickly all the different types of events you can actually get in open code. You can also find it in the open code packages folder called SDK and this will have the whole list.

You can also use plugins like um connect with external API. I've actually made a different one. I'll probably show that after this how I just plugged in every time I get a session idle that it sends me a message on telegram that hey the code is done go check it out then you could also add web hooks or polling to then actually use telegram to interact with your open code editor like the possibilities are quite endless here anyway I'll probably just jump ahead to show you my telegram integration so you can kind of get a feel of what that looks like jumped ahead now I've just got this Telegram uh plugin that I made just for demonstration purposes where I I can just send a message on telegram saying hey session idle here's your last message or your open uh session is idle time to check your work. Pretty simple but this is see how this works.

I actually have telegram here and let's see how this you can see I've been testing this a bit. If we get my Telegram account here, I'm just going to write a few things just so we can see when it comes back. All right, going to open code again. We can see it's running there.

Let's make this a bit bigger. And I'm just going to say tell me a joke again. And I'm going to run that. And I'm going to grab my Telegram.

And we should see it pop up as soon as it's done. Quite instant. You can see a bit above here. I was playing with other commands that I could send to it like send a command, start, give a status.

Hopefully you got guys have got a bit of a feel a better feeling now how powerful plugins can be with open code and the amount of customization you can actually use with plugins. So now you guys can see how you can integrate with external APIs like send a message to telegram slack you name it. This is simply claude code can't do right now. Open code just gives you full control.

That's one thing that open code plugins beat claude code ad giving you total warflow control. plugin would you build to automate your workflow? Drop down your ideas down below. And if you like this content, definitely hit that like and subscribe button and let me know what you'd like to see next in the next videos.

Thanks for watching. Syrup.

[Music] Everyone's talking about slash commands in AI tools, but there's what everyone gets wrong about slash commands, and it's not what you think. In this video, we're going over what are slash commands and how can you get them working in open code. What are slash commands? Best way I want to describe this is think macros but for AI powered workflows.

Why type 200 characters for an instruction that you use all the time where you can just use a slash command to execute the same command just saves you a lot of time. You know in the beginning I said there's always some things people get wrong with slash commands and it's a little bit like how people think of macros. Sometimes they try base their whole workflow around the macros and people do this as well. They probably base their whole workflow around the stash of plants and that's incorrect.

Commands should be used to save you time and energy of tasks that you already do in your workflow, not the other way around. They should fit in your current workflow. That's it. If they're not working for your current workflow, you shouldn't be using them and try things this way.

Save your hole. But how do you get all these slash commands working? Well, let's have a quick look through the document. Jumping on to screen here.

I'm in the open code documentation. We're in the command section over here. And we're just looking at slash command. And we can see right here on screen, this is pretty much how you just write a slash command.

It's slash where the name comes from and then your command. And it will execute whatever you've defined. With most AI tools, it comes with a predefined set of commands like, you know, slash init. that will scrape the whole uh codebase and make its own agent MD or claw MD, whatever AI tooling you're using at the time.

But that's that is an example of a slash command. But we're going to be talking about how do you create your own slashcards cuz I think this is where the value lies in Open Code. It's quite simple. You can use an empty.

It's one of the versions. And it's very important that it is underopenode/comand singular and then whatever your file name is here test.mmd and the file name is very important because that's actually what your slash will be. If you want to go further, you can actually define what agent to specify to and what model. And the reason why you might want to do this is maybe you've built up a very decent agent with a certain context where you find certain files.

Then you can always use that agent to do the specified task. How do you actually prompt in arguments? And this is a good example. So you can actually pass through arguments.

So for this command, we got component. And yeah, we're just going to create a new component. And it just specifies with this arguments tab that whatever comes after component, we're going to pass that in. So here's like the example component space button.

So button is passed as the arguments that come through and then it will then read this be like hey create a new react component named button in this case with TypeScript support include proper typing and basic structure. That's how generally it works. Now I'll also show you that in a bit. I want to touch on is file references.

And this is actually very important for context referencing is you can specify context files using the at command. So you can at a certain file and then that will be injected to uh the slash command and you can use that for context just to save you a bit of time. Is also a JSON format that you can put into your open code.json uh folder. And we can see it's pretty much the same.

We've got the command and then you've got whatever the command name is, the template, the description, the model and sorry the agent and then the model which follows what we just had above in a slightly different format. So you can do both open dot uh sorry open code.json or you can use uh the markdown for so you can do this both in your project or your global space. So depending if you want the commands to always be in your global then you can go to your global config location which is displayed on screen here which is uh config/opencode and then in the command folder and if you want to run project you just literally just put in the open code uh for/comand which we're going to be doing in this uh tutorial code. I'm in my open code agents uh repo and I'm just going to be adding the slash commands to this.

So to get started I'm going to go to myopen code um folder that I've created in this project and I'm literally just going to in here I'm just going to make a new folder called command. And in here we can just put a new file name. I'm l just going to make my new file. I'm just going to call this joker for this for whatever demo's purposes.

I think it would be interesting. And I'm literally just going to build my slash command shift. We've made this quick agent just oh sorry we made this quick uh prompt command called joker. I'm lally just giving it it a ro and then I'm telling what the purpose is and what it should be basing the joke on and what the outcome gun should be.

And just to see that that's working. We're just going to run open code in our project. And if I literally go slash here and I stop typing joke it will come up. There's poker and I'm gonna just I know it's good coffee and I'm just gonna make a joke about coffee.

My you know ingenuity is on another level today. You see here we got the first joke is why did the coffee file the police report it got mugged. Uh it's kind of funny. Uh anyway, so gave us a few different jokes that we could use to break.

But now you kind of get the idea about a slash command and we're using the arguments here that we passed in. Remember that's what I put through. I said coffee, but maybe I want to do a bit more than just coffee. Maybe if I go joker now and I say coffee and then I keep putting space and tea and with fits and spaces again, you know, and and you know uh it'll pick all that up.

So whatever is after the slash command, that is the arguments that pulls them. And you can see here that's what it's doing. So that's just a quick tip. Then the last thing is maybe we want to make a file here just so we can pull it in.

And that's just the reference. So I'm just going to call this a secret joke. And in here I I'm just going to put this one. Make a joke about Darren's ego.

I'm literally come back here and um to see if it's working. And I'm just literally going to use that at sign. And one thing to note, you do have to exit open code. If you, you know, update it, it won't have the new update until you rerun it.

So that's one tip. So now if I do joker and I open t again or t mist type there we should see it for in that reference file. So we can see that's working. So flash command should fit into your current workflow and you shouldn't try adapt your workflow to fit around there.

That's the way the best way to think about it to get the most out of it. So we talked about slash commands but how do you go about do doing this? How do you actually go about making slash fit into workflow and what are some good examples? So these are some slash commands I'm enjoying right now.

They will probably get updated with time but for example I sometimes like the slash context. It's just like hey get a bit of um context into the memory of what the some common slash commands I enjoy using at the moment. One is actually context. So I just use this if I'm starting up a new project and I just want to make some quick changes.

I just say hey get context of this project. So it's loaded into memory. So the next things that I speak about it has all of that going on uh in the background. So I don't always have to feed a context.

So I just like as a quick get to. The next one is a bit different is commit. So I've started enjoying this one. So it's a little bit like a it does my pre-commit checks.

So it does a lint and then a build uh and a type check. It will give a commit message with an icon depending on a certain feature. So you'll see on screen here I've got like feature fix, doc, style, refactor, etc. I kind of enjoy the how it works.

It just kind of gives you a different indicator of actually what the commit was about very quickly with the Nikon. And I just enjoy seeing that especially if you looking at your PRs and your multiple commits. You can kind of just trace from the icon what it actually meant. So the other one I really enjoy is clean.

I enjoy really putting a lot of debugs in my code. I sometimes just don't trust what AI always gives me and I always want to just double check it. It's working as expected saying I actually don't want all the console logs there and I'm always taking them out either manually or just asking AI to quickly go through and clean. And clean is a great way just to get rid of those.

I've actually built this uh slash command called prompter. So how it actually works is I go for/prompter and then I give it the request that I'm trying to do. And this prompter actually just based off the anthropic um bit of techniques of how to prompt uh AI. So it actually like builds on my request using those techniques which was like the uh 10 steps, you know, context, tone, etc.

like that. And I just enjoy using this to see if I can get a bit better responses for my requests, especially if I'm being a bit lazy. These are the five prompts I'm really using right now. I've got a few others I'm kind of like testing out, but we'll see where those go.

So, I'm not really going to talk about that in this video. Well, I've given you some examples, but if you want to build your own, I actually want to give you some tips on how to best approach them and also what to avoid. In my testing, I would always say start simple and build on it. Always give clear instructions.

Never try convoluted. If it's too convoluted at the start, if you read the first three lines and you don't actually know what the whole the rest of the prompt should be about, you're probably in the wrong place. So, just use good prompting techniques and you'll be fine. Well, the next thing is um if you are working with prompts, let me see if I can demonstrate that on screen is say your prompt doesn't work.

Uh so, let's see. Does this actually Let's just text. All right. Um, another thing is so I've made this um from bug here uh slash command and I've purposely misspelled the model.

If I go to open code now and I I look for that you can see it comes up and if I hit it it will run but nothing will happen and that's because there's an error and if I change that to a decent model or just take it out it will work again. And just to show you that so I'll just take it out for this example. I will restart this and go in open code and I will go bug and I'll say and you'll see it will run now. So that's one thing to note.

If it doesn't work, it's probably because you have a bug in in your slash command. Last thing to note, there are some pre-built slash command and if you overwrite them, your custom command will be the one that open code will use. So just keep that in note, especially if you're using them. So lastly, I would also just say share your slash commands in your team for important workflow steps.

I would say the most important steps to maybe include are maybe some like your pre-commit checks, your error debugging techniques. So maybe you got an error and you have some way or flow that you actually want the debugging to work. Maybe build that into a slash command so you can share across your team so everyone can actually debug the right way. And you can also put like coding standards.

So maybe some people code a certain way and the standards of it off instead of getting to they can just use a slash command to double check that the coding standard to match before they actually push it up. So to wrap up, slash commands are a great way to save you time and should fit into your workflow. You shouldn't bend your workflow around them. Remember that.

So again, share them across your team to help keep consistency, improve your workflow process, and just have a better development experience in general. If you like this content, comment down below and smash that like button. Lastly, I'm building a datadriven framework to compare different AI dev tools based on real productivity with metrics where I can measure different tools and ideas which give us a better decision better idea what actually matters and we can make our decisions on metrics rather than just going on vibes. This is something you would like to keep up to date with hit that subscribe button so you don't miss future content and thanks for watching.

Hey everyone. Today I'm going to show you something that's changing how AI agents work. It's called agent skills and trust me, this is way simpler and cooler than it sounds. So, imagine this.

You're working with an AI coding assistant, right? And you want it to do something specific, like process PDF files or build a specific type of app. But the AI doesn't really know your exact workflow. That's where agent skills come in.

Let me show you what this is all about. All right. So, what exactly are agent skills? Think of them like instruction manuals for AI agents.

But instead of being complicated, they're just folders with some files inside. Here's the basic idea. You create a folder, let's say called PDF processing. Inside that folder, you put a file called skill.md.

That's it. That's the basic structure. Now, this skill.md file has two parts. First, there's some basic info at the top, like the name of the skill and what it does.

Second, there are the actual instructions that tell the AI how to do the task. So, when your AI agent needs to work with PDFs, it can read this skill file and know exactly what to do. No guessing, no figuring things out, just clear instructions. And here's the cool part.

These skills work across different AI tools. So, you can write one skill and use it in Claude, use it in Cursor, use it in VS Code, whatever. You're not locked into one platform. Now, let me explain how this actually works when you're using it.

Step one. When your AI agent starts up, it looks at all the available skills, but it doesn't read everything. It just reads the name and description of each skill. This keeps things fast.

Step two. You ask the AI to do something, like, "Hey, extract text from this PDF." The AI sees that there's a skill called PDF processing and the description matches what you need. Step three. Now the AI reads the full instructions from that skill.

It loads the skill.md file into its context and follows the steps. And if the skill has extra stuff, like scripts to run or reference documents, the AI can load those, too, but only when it needs them. This is called progressive disclosure. Fancy term, but it just means the AI only loads what it needs when it needs it.

Smart, right? So, you might be wondering, is this actually being used or is this just some random idea? Well, a bunch of major AI tools already support agent skills. First up, Claude and Claude Code from Anthropic.

Claude Code is their command line tool for coding tasks and it supports skills out of the box. Then you've got Cursor. If you're into coding, you probably know Cursor. It's that AI-powered code editor that everyone's talking about.

They support agent skills. GitHub is on board, too. Makes sense, right? GitHub is all about developers and AI tools now.

VS Code, Microsoft's code editor, also supports this format. There's also tools like Goose, Leda, Amp, Open Code, Gemini CLI, and Factory. All of these are using the same agent skills format. The reason this matters is that you can create a skill once and it works across all these platforms.

You're not writing different instructions for each tool. One format, many tools. That's the power of an open standard. All right.

So, how do you actually create a skill? Let me explain it in a very simple way. Here, I created an API design skill focused on building well-structured REST APIs in Next.js. In this skill, I added rules like always returning responses in a consistent format, defining reusable TypeScript types for API responses, validating input using Zod, adding an API logger, and following other best practices for API development.

Because of this, our AI agent automatically applies all these rules whenever it creates a new API. For example, when I asked it to implement a CRUD API for users, it immediately read the API design skill file first. Based on that design, it implemented the entire API following all the best practices and it even tested the endpoints using curl commands. So, why should you care about agent skills?

If you're someone who uses AI coding tools or AI agents, this means you can teach your AI exactly how you work. You can create skills for your company's workflows, your personal coding style, whatever you need. If you're building AI tools, supporting agent skills means your users can extend your product without you having to build every feature. They can add their own skills and share them with others.

Plus, since this is an open format, anyone can contribute to it. It's on GitHub, it's documented, and it's designed to evolve with the community. This is still pretty new, but it's already being adopted by some of the biggest names in AI development tools. And I think we're going to see a lot more skills being created as people realize how useful this is.

If you want to learn more, check out agentskills.io. That's where all the documentation lives. You can also find example skills on GitHub to see how people are using this. If you found this helpful, hit that like button and subscribe for more AI and coding content.

Drop a comment if you have questions or if you end up creating your own skills. I'd love to hear about it. Thanks for watching and I'll see you in the next one.

Most AI coding tools still work like this. One task, one terminal, one conversation at a time. What if I told you you can code much faster because of one bottleneck? And that bottleneck is your attention.

Today I'm going to show you how I use Open Code to run multiple AI tasks in parallel, track usage, and stop babysitting terminals. This is a step-by-step tutorial and how I actually use Open Code, a real workflow under real constraints to ship faster without a team. I'm Keith. I built and exited companies, taking one public, and now I help solopreneurs and builders ship faster by turning AI into real systems.

I've used pretty much all of the coding tools, Cursor, OpenAI Codex, Claude Code, you name it, I've tried it. They're all good at generating code, none of them solved the thing that was slowing me down, running multiple tasks and knowing what's happening. So, let me show you my old workflow. I'm subscribed to Gemini, Claude, and OpenAI.

And I used to open a terminal for each one, but the problem was when I tried to run multiple tasks in three different windows, I don't know which one has failed, which one is done, and most importantly, I don't know how much credit I have left for each one. So, multitasking was a complete nightmare. What really ended up happening was I just had one window and I kept using it until the credits ran out and then I switched to a different one. So, I can only do one task at a time.

After I switched to Open Code, it really changed my world because now I can run multiple tasks in parallel and will tell me how much usage I've used, and alert me when a task is done, and I can run multiple models on the same project at the same time. Absolute game-changer. Quick context, what is Open Code? Here you see Open Code is open and I think of it basically as a task orchestration for AI coding.

Instead of just one terminal and one task at a time, here you see that I have multiple sessions going on and for each one, I can choose a different model. So, I can choose to run GPT 5.2 Codex for one task, let it run, and I can run another session using Gemini 3 Pro, let that task run as well, and when it's done, it will alert me so I can run four or five different tasks at the same time, and that's what Open Code does. I'm going to go through the step-by-step instructions from installation all the way to very advanced features with Open Code, but it's important to understand some high-level concepts. So, why am I excited about Open Code?

It's because previously I was doing sequential one task at a time, and now I can do parallel tasks and run multiple agents coding at the same time. So, my job now isn't to watch AI work. My job now is to intervene when it's only needed. So, what are we covering in this video today?

We're going to be covering from installing Open Code as a terminal or downloading the desktop app, and even showing you how the web version works to connecting to all your different AI providers like Gemini, OpenAI, how to choose the free models and your paid models, choosing between build and planning, adding MCP servers, adding agent skills, and how to integrate it with tools like Warp, and finally giving you a live demo of how I use it in my workflows, working on a project that's generating revenue and running multiple tasks. So, the first thing you need to do is go to open code.ai. And the first option I'm going to show you, and the easiest one, is to download the desktop app. So, you can click on download now, and I'm using a Mac app, so I'm going to download Mac OS Silicon.

All right, it's downloaded, I double-click on it, and just follow the instructions, and you should be granted with a desktop app like this. All right, the next option is that you can choose extensions, and if you're already using Cursor, Windsurf, or any of the coding IDEs, you just press install, and it'll get installed into those IDEs as well. Very simple. And then you have the option of installing it through the terminal.

Now, what's the difference between installing through an extension or downloading the desktop app? Extensions like Cursor give you basically an app with an interface. So, it makes it easier to have visibility, run multiple tasks, gives you alert, gives you gives you a lot more information to work with. But some people prefer terminal because it's very focused, and if you're familiar with terminal commands, it can be faster.

I actually like terminal because I found using terminal, for some reason, seems to be faster than using an IDE. And you have all these options like curl, npm, bun, brew, paru. The most straightforward one is actually using this command, the curl command, because it will identify your operating system, and then it will choose the best option to install on your machine. Because if you're using Linux, you might use paru.

If you're using Mac OS, you might use brew install. But if you're unsure, just run the curl command. So, open your terminal. So, you can go to terminal and open your terminal, but I use this different tool called Ghostty, same thing.

Just type this in, enter, and it will do its magic. So, those are the three options you can use to install Open Code. And there's a hidden option, which is you can run it on the web. So, after you've installed it in the terminal, you just run this command, open code web, copy, and now it runs in my browser.

So, you can see that I can run Open Code there. Okay, so why would you want to run a web version [snorts] of Open Code? I think the most useful use case is where you want to run Open Code on one machine, on one particular machine, and you want to access it using a different machine, maybe your mobile phone. And so, you can connect to it, open a browser, and start coding away while the source code of your project is on the computer.

A bit of a pro tip on installing the CLI, command line interface, in the terminal is that sometimes you run into trouble. No worries, you can download a tool called warp.dev, and what warp.dev is is an AI agent for the terminal. So, you can just copy and paste your command into warp.dev, and if there's any issues, you can just ask the AI agent to fix it for you, and it will fix all the issues for you and make sure you get installed. And once you have installed, all you need to do is type in open code, and voila, you're inside the terminal and Open Code is running.

The first thing I want to show you inside the Open Code app is the settings, because everyone loves dark mode. So, you can come here, go to appearance, and go ahead and set it to dark. You can choose a font. You can also choose a theme, Dracula, Tokyo Night.

So, pick whatever you want, and you have the option to turn on agents, permissions, errors, and you can also have a sound effect when your task completes. And you can also add in shortcuts. So, that's the basic settings. Now, I'm going to go through some of the features that Open Code has.

Right here, there's three different options you can choose from. There's build and there's plan. And how I use it is that when I'm thinking of adding a new feature, I usually go into plan mode first before I build it. So, then it thinks through the logic and then it builds.

Then you can choose your model. Now, it comes with a lot of free models. GLM 4.7 is actually pretty good, and you can do a lot with free models already, but in the end I think paid models are better, and I'd trade money for time any day of the week. Here I've already connected Google, OpenAI, and Anthropic.

And usually when I'm planning, I would choose Claude, but recently Claude announced they don't support third party, so I do not recommend using Claude with Open Code because you might get banned. So, when I'm planning, Gemini is better at planning, and so I'm going to use the most powerful one, which is Gemini 3 Pro Preview. And then, thinking effort, I can click, and I want to set it on high because I want to think carefully. And then when I'm ready with the plan, I click on build, where it will actually start coding, and I would use either 5.2 or 5.2 Codex.

If it's more advanced feature, then I would use Codex, but if it's something simple like adding a button or just fixing a bug, I would choose 5.2, and if that fails, then I would use a higher context one. So, being mindful of my token use. And thinking effort is basically how many tokens you want to cap your request at. This is an interesting button and actually is a very important tool because it shows how much usage you have left.

If you're like me and you're on a $20 plan, things run out pretty quickly. But if you're on a $100 plan, it might take you a while to run out, but it's good to see how much context you have left. And another thing I do is sometimes I attach screenshots saying that some certain UI elements are out of place, and I would just screenshot it and attach that and say fix this, or show the AI what's being made. So, those are the options here.

I'm going to take a second here to explain my model strategy because I'm subscribed to Claude, OpenAI, and Gemini on a $20 plan. And I like Open Code because it forces you to think about using which AI and which model is most appropriate for your task, right? And I basically use Gemini for high-level planning, and I use use use OpenAI once the planning is done to execute the code. And depending on the task, if it's complex, I'll use GPT 5.2 code.

If it's just like a simple bug fix or moving a button, I'll use a lower model, and I'll set the token limit to a lower rate. So, this is like representing the token usage. So, this is a good thing to just get in the habit of choosing the right model and thinking about how many tokens you need for what task. So, another technique I use to save on my precious tokens is that, let's say I have three features, instead of making a one long continuous chat one after another, which consumes a lot of tokens, I split them up into new sessions each one, so then it saves me money and context as well.

So, little trick that I use to save tokens. Open code comes with all these free options, but if you want to be like me and connect to Anthropic, OpenAI, and Google, you need to connect to your provider. I'm going to show you how to connect to different AI models in the Open Code desktop app. You click slash and then you go to model and then on the top right, you can click on connect provider and then you just choose the provider that you want, let's say Google, and then you'll need to enter your API key.

I'm also going to show you how you can add models if you're using the TUI terminal app, and then I'll go into how you can actually get the API key easily with the help of AI agent without spending like 10 minutes clicking around. Here I've opened my terminal and here I can type in slash, go down, and choose select. And then you can see that I've connected to Anthropic, OpenAI, and Google, but there's so many options here. This is the only tool where I've seen you can basically connect to everything that is out there and I wouldn't underestimate the Chinese AIs because right now in sixth place and seventh place, you have GLM 4.7, which is open source, and MiniMax, which is also open source, that's beating ChatGPT 5.2 and Gemini 3 Flash.

So, you can get pretty good results with these other options as well and it's much cheaper to subscribe to them. So, let's click on one of them. I have Perplexity, so let's click on Perplexity and then you enter your API key. And how do you do that?

Well, I use a browser called Perplexity Comment. And what I can do is I can come here on the top right, assistant and the AI agent will actually click around the interface and find the API key for me. So, saving you time from clicking and trying to find all these API keys for Google or ChatGPT. Just quick note that you never want to pass your API keys or passwords into AI.

And so, this hack to do this is I need to create an API key for Open Code from Perplexity. Can you set up the API key so that it goes up to the stage where the key is ready for me to manually copy and paste. Please do not copy and paste it for me. So, right now I've given instructions to basically set up the API key, but don't copy it.

Stop there and then I'll manually copy and paste it into Open Code. And now it should save you a ton of time in clicking around on the interface. Okay, now it's done. I'm going to copy and paste.

Okay, and now it's connected and I can choose which one and then now I should be able to go in Perplexity and I can choose sonar sonar pro reasoning. So, it's connected. So, that's how you connect your different AI providers to Open Code. Now, I'm going to actually show you how I actually use Open Code.

When you first come in, you got to open a project. If you're starting a new project, then you got to create a new folder and so, I'm going to open a project and here I've opened my project. To give you some context, I have an app here which is a health data analyzer app where you sync your health data and it gives you analysis and you can do AI analysis of your health data as well. So, here you can see that I've got an issue here with this not displaying correctly, so let's take a screenshot and we'll use that in a bit.

And now that I've connected, I want to first fix that bug. I'm going to attach the screenshot and say, "For the graphs, the time frame word is out of place. Can you fix it?" And then I can click send, so it's using the attach image function and and and I've chosen my model. >> [panting] >> While that is running, this will display and it's doing its magic.

I'm going to start a new session. I'm going to plan and I'm going to choose Gemini, which is different model and say, "For my health analyzer app, I want to add some gamification ideas to the product so it makes it more sticky. Maybe adding streaks or something, but the the the end idea is to make sure people sync their data on a regular basis and kind of reward them for the when they actually do sync their data. So, I'm going to let it plan, hit enter, and you can see here that this is running and also my other session is also running.

So, this is where multiple thing can run at the same time and I can start another session and say, "Can you some ideas on how to improve the UI UX of the product?" I can run that too. And you'll see that if you check in, it it's showing you the progress and the time it's elapsed and also how much code is being changed with the plus sign and or how much is being deleted. You can see all the changes it's making in the code base. And when you see this blue icon, it means that the task has been completed.

You can also turn on notification where it will show up on the top right of your Mac that a task has been completed. I turned it off because it was just popping up all the time, but if that's something you like, you can have it run as well. And now all three tasks are done and let's see if it actually fixed the problem. So, you see this is out of place.

Let's turn it off and run it again. All right. And the time frame wording is gone completely and that's been fixed. So, happy with that.

And for the gamification, it's giving me some suggestions on adding basically a badge and milestones and I kind of like the idea. So, let's try to build it. So, I turn on the build mode right now. I switch back to GPT 5.2.

Yes. Yes, proceed with this plan. And then let's see what happens. So, you can run run run multiple sessions at the same time, but let me show you something else.

I don't have just one product, but I have multiple products. I can open another project and in there I can also run multiple sessions. So, I can be working on two projects at the same time and each project can be running multiple sessions at the same time as well. So, you can be running many, many things at the same time.

All right, and it's added the streaks and so, let's go back into the app and let's check it out and there it is. I've added a streak count, 3-day, 7-day, 14-day, 30-day. Str- looking really good. I think I could do a little bit more by showing more than just 3, 7, 14, and 30.

30. 30. But, no, it's done a good job. So, looking very good.

Okay, now let's look into some of the more advanced features it offers. And one of the secrets is that you can type the slash command and a lot of cool things show up. Okay, let's start with the first command, which is the init instruction. It creates an agents.md file.

I would highly recommend doing this because Open Code will read all your files and your folder structures and create file that makes it more efficient to run in the future. So, if you want to save your tokens and do more faster, definitely worth running this command and now it's running and you can see that it's running some code style guidelines, formatting, naming conventions, error handling, and creating this agents.md And just to showcase its parallel feature, I'm going to start a new session and let's do the second thing, which is review. What does the review command do? It basically looks at your code, checks for security vulnerabilities, any potential bugs or issues or styling issues, and it just goes through your code and make sure it's in a good state.

And I run this from time to time and I also refactor my code from time to time if I'm adding a whole bunch of features because sometimes you might add in some code that's not used anymore and you want to remove that to keep your file size smaller. And here it's come back with some issues and that's great, you know, it's realized there's a issue in my current streak and it should fix that. I think it's a good idea to fix it. Can you please fix it?

And then here's the agents.md and let's take a look. It's realized that it's an Xcode project and it's listed all these things. Naming conventions, concurrency, error handling. And so, this this is actually really useful because in the future it will reduce the tokens required to run my project.

So, useful to run and always initialize a new project. Okay, next thing we're going to do is look into MCPs. So, you can toggle on and off your MCPs and here I've added Playwright. It has ability to open a browser and pretend to be user and click around and do stuff for me using an AI agent.

The MCP I want to add is Context 7 and basically is an MCP that will help me save tokens again by allowing it to read API documentation and libraries at a much lower cost than reading everything at once. So, to use Context 7, I need to sign up and generate an API key key key and then I need to add this to the configuration file. So, if I come to Open Code, it says you have to add something like this to my configuration file. And now I have a hack here where I can use warp.dev that I mentioned earlier and I want to say find the global open code.json.

That's where the configuration file is because I hate clicking around and finding the right directory and the right file. And this allows me to kind of quickly find a global file. Once it's found a global file, I'm going to ask it to add this bit of code inside. And I will share the code in the description.

You can get it there as well. I'm adding the contact 7 MCP to the open code file. And then I accept the change. Can you open the file using Sublime note editor so I can add in the API key.

So here you see that it's added this to my config file and all I need to do is copy and paste my API key. I signed up for contact 7 and I get like a free API key with a thousand requests. So I'm going to generate that and put it in. I'm going to label it open code.

Paste it in. Save. And then let's close and restart open code and see if it's added successfully. So I'll come here, MCP, toggle MCPs.

There you have it. Contact 7 is added. Even though I added contact 7, I keep forgetting to call contact 7. You have to say use contact 7 specifically.

So inside the documentation actually suggests adding a rule. Always use contact 7 when I need library documentation. So how do you add this rule to open code? So remember the agents.md file when we initialize the project?

Well, we're going to go do that. I'm going to go to open code and say add this rule to the agents.md. And there you go. It's added the rule to the agents.md file and from now on it's going to save me tokens and call contact 7 on its own without me calling it.

And so that's how you add MCP servers to to to improve your coding experience combined with rules. Now that we've gone through the desktop app, let's go through the terminal app and check out the command line interface. I'm going to use Warp here, but you don't have to use Warp. You can just open terminal or you can use Ghosty or whatever terminal app you use.

And the first thing I need to do is to open my directory. So I go to CD, go to projects, and then I drag and drop the the the location. This means change directory. And then it'll ask you to optimize and of course I do want to optimize.

Okay, now how do you bring up open code? All you need to do is type in open code and voila, you're in. So you can do the same things you can do on your desktop app, but now you need to use these keys. So control T allows me to control the variant.

So how many tokens capped? I can press tab to change agent, so planning or building. And then control P allows me to switch models. So I can choose and you can see that the desktop version allows me to have more selection.

The desktop only gives me three options, but the terminal is way more powerful. Allows me to choose way more options than the desktop app. Super powerful stuff here. So that's why you would use the terminal because it's just got way more functionality.

Also, when I type the slash button, I have more options to choose from. So I can choose a theme. So let's say Tokyo night, solarized. I can go orange.

I'm going to stick with the original cuz I like it, but you can change the color scheme. I can see the status and I can go to sessions and I can see all the sessions that are happening right now. Right now, I can only run one task at a time. What if I want to be like the desktop and run multiple sessions at the same time?

Well, what I can do is I can go to split pane right and I can keep clicking it and open three or four panels and then I do open code, open code, open code. And all of a sudden I have four tabs open and I can run four sessions at the same time in the same project. What if I want to run another project? Well, I can just click here and open a new tab and I can open another project and I can have multiple sessions within that project as well.

So you can do the same thing you did in desktop app and run multiple sessions and agents at the same time as well. So much like Claude, you can also add skills to your open code. So what are skills? Skills are reusable sets of instructions.

So if you're running certain commands over and over again, it might be useful to turn into a skill. So let's try to add that skill inside open code. Can you help me create a skill for Xcode refactor patterns and help me add it to the skills.md? And now it's created a refactoring skill, which is going to help clean up my code and make it run better.

To run the skill I'll need to restart. I'm going to close this, come back to open code. Now let's try. Can you run the Xcode refactor pattern skill?

Ah, turns out I I added an extra S to the MD file. It needs to be skill and not skills. Don't make the same mistake I made. So now it's recognized my Xcode refactor pattern skill and is now running the refactoring.

Pick one for me and run it. And there you have it. It's running a skill. Now I want to show you our commands.

So what are commands? When you tap on the slash button, all of these options are commands. And you can add to them. So I think a useful command for me is get, commit, and push.

So I'm going to try and add that. So I'm going to copy open code.ai/commands. Using this as a reference, can you add a command called that commits and pushes for me? Let's see if we can add the command.

So it's successfully added the command. So let's give it a shot. I open up open code. Let's look for get.

Get push. And there you have it. I have a new command. Now I'm going to show you an advanced feature.

Imagine you can run open code on your mobile phone just like this. I'm going to show you how to do it using Termius. Let's get started. So to run open code on your iPhone, you need to set up your Mac as a server where it's running the open code.

Then you need to download Termius, the app, and connect via SSH to basically run open code on your computer, but displayed on your iPhone screen. Now, in this demo I'm just going to show you how to make it run when you're on the same network within this in the same house or the same office. If you want to run it remotely while you're out and taking a bus ride or driving a car, you'll need to set up more stuff to create a split tunnel so then you can connect remotely to your computer. But that's going to be another video because it's not easy at all.

And if you're interested, stay tuned for my next video where I'll go through how to use Cloudflare to do that. But to get started, you need to set up SSH connection on your MacBook. So first thing you need to do is go to system settings and then go to sharing and you need to enable remote login. And then you need to add a user account.

And when you log in, you just type in the name and the password you use to log in to your Mac. And now you've enabled remote connection to your Mac using SSH. You need to download the Termius app. So on your iPhone, search for Termius and download the free app.

After you've downloaded Termius app, open it and go to hosts. Click on discover local devices. You should see your Mac here as long as you're connected on the same Wi-Fi network. Click on it, click tick, enter the username, and then the same password you used to log in to your Mac.

You should see a terminal and then all I need to do is type open code and boom, you've got open code running. Like I said, this only works if you're on the same Wi-Fi network. I will produce another video to show you how you can connect remotely when you're outside, traveling on the bus, or whatever using Cloudflare and split tunnels. Stay tuned for my next video.

I hope you enjoyed this video and gained a better understanding of open code. If you enjoyed the video, please like and subscribe to my channel. If you want to learn more about AI, feel free to join my free AI community. You can join my community for free inside the description.

I also have a vibe coding course. If you want to learn how to code, you can also find that inside my community. See you inside.

I've been an engineer for nearly a decade, and in all of that time, right now, process has never been more important. At your fingertips now, you have access to a fleet of middling to good engineers that you can deploy at any time. But, the weird thing about these engineers is they have no memory. They do not remember things they've done before, and so you need extremely strict and well-defined processes to get those agents to actually do things that are useful.

So, this means that you as a developer are looking constantly for ways to steer your agents to keep them on the right track. And for me, that has resulted in a lot of skill building. Here's the repo of all the skills that I'm using right now, each of which I have gone through and designed. Some of these I use relatively rarely, but some of them I use every single day.

And these skills help me encode my process so the AI has a really strict path it can walk down every single time. And as a result of using all of these skills, the code quality that the AI's producing has shot up. Now, if you think that process is important and that real engineering skills are important, then boy, do I have a course for you. This course is called Claude Code for Real Engineers.

It's a 2-week cohort that starts on March 30th. And for 7 more days, it is 40% off. If you feel like you're behind the curve on Claude Code and you want to get way ahead of the curve in just 2 weeks, then blimey, this is the place for you. But, let's start talking about our skills with number one, which is maybe my favorite.

This is the grill me skill. This skill, yes, it is just three sentences long. And let's just read it out in full to describe what it does. Interview me relentlessly about every aspect of this plan until we reach a shared understanding.

Walk down each branch of the design tree, resolving dependencies between decisions one by one. And finally, if a question can be answered by exploring the codebase, explore the codebase instead. The concept of a design tree comes from this book by Frederick P. Brooks, which is the design of design.

Actually, I don't know if it comes from this book, but this book is where I saw it first. The design tree is this idea that as you're coming towards a design, you need to walk down all of the branches of a design tree. For instance, you might be designing a search page and you need to decide whether you want an advanced search or a text box. If you choose advanced search, then you need to figure out all of the filters and all of the sorting methods that you need on advanced search.

And you keep on walking down the tree until you figure out your design kind of in full or as full as you can before actually committing to code. This grill me skill, when I invoke it, I invoke it when I want to reach a shared understanding with the LLM. I found that relatively recently Claude Code will tend to just spit out a plan really early when I go in plan mode and it tends to just create a document before I feel I've reached a shared understanding with the LLM. But the grill me skill forces that conversation.

It forces the LLM to interview me about every single part. Here's a conversation I had with Claude recently about adding a feature to my course video editor code base. I gave it some research that I'd done in a markdown file and I said, "Grill me. I'd like to think about adding this to the right page." It loaded up the skill and the thing I want to show you is just how many questions it asked me.

So, the first thing it did is it just explored the relevant stuff in the code base, which is good. Then we zoom down, we can see it ask question one, "Where does the document live?" Question two, "What's the UI layout?" Question three, "Which modes get the document panel?" Question four, "The document life cycle." Question five, "What does the right document tool look like?" Question six, "The edit tool shape." Question seven, question all the way down to question nine, question 10, question 11, question 12, all the way down to question freaking 16 here. And this is a relatively short grilling session in my book. I've had sessions where I've sat there for nearly half an hour, 45 minutes with the AI answering questions on really complex features.

You know, that could be 30, 40, 50 questions all from this absolutely tiny skill. That's one thing I want you to take from this. Skills don't have to be long to be impactful. You've just got to choose the right words for the LLM at the right time and this design tree resolving dependencies has just been absolutely great for me.

By the way, if you want these skills, then they will be at a link below. Once I have reached a shared understanding with the LLM, once I have grilled my idea and sort of understood all of its ramifications, if I then decide I want to implement it, then I invoke my next skill, which is a write a PRD skill. I actually did this in the conversation we were just looking at, so it said, "Anything I've missed or got wrong?" And I said, "Write a PRD." I was suffixing it with user because I have some that sort of live in the project, so that's the reason why I did that. Here's what the skill looks like.

This will be invoked when the user wants to create a PRD. You may skip steps if you don't consider them necessary. So, for instance, in the previous conversation, it said, "We've already done a deep interview. Let's move to step four." So, step one is to ask the user for a long, detailed description.

Then number two is to explore the repo to verify their assertions. Number three is basically to interview the user relentlessly. So, just a copy of the grill me skill again. Next, we sketch out the major modules you will need to build or modify to complete the implementation.

We're going to look at this later because it links to skills I'm going to show you in a bit in this video. Finally, once you have a complete understanding of the problem and the solution, use the template below to write the PRD. And the PRD should be submitted as a GitHub issue. The way that my dev flow works is I take these PRDs in GitHub, I turn them into more GitHub issues that reference the parent PRD, and then I have a Ralph loop that just loops over each issue until it's done.

If we go back to the conversation where we were before, we can see that it created this PRD here. This was four days ago, as you can see. We've got a problem statement. The article writing page currently regenerates the entire document on every AI interaction.

And the solution was to add a split pane document editing experience to the article writer. Chat stays on the left and new document panel, blah, blah, blah. So, this is a big feature. We're adding document editing to a kind of AI chat feature.

The important thing here is the user stories. There are many, many user stories as part of this. And this comes from Agile methodology, and we're basically trying to describe the kind of desired behavior of our system in language, which is not an easy thing to do. I still haven't properly like landed on the right format for these.

This is just something I sort of like, but you could easily use like cucumber language for these or whatever you're kind of used to do used to working with. We then zoom down to the bottom and we just sort of pass in some implementation decisions. The implementation decisions here, we don't want to be like over prescriptive because we want these to be durable because if the code ends up getting out of date with the PRD, then we're going to have issues when we actually go to implement it. But you can see the theory here.

This is the kind of uh uh uh it's a really good description of the destination that we're going to. But what we don't have from the PRD is the actual journey, is the is the way we're going to get to this destination. And if we leap back to that conversation, this is where I use my next one, which is PRD to issues. What this does is it takes a PRD, takes the destination, and it turns it into a Kanban board of different issues that can be independently grabbed.

So the first step in here is it locates the PRD. If the PRD's not already in your context window, fetch it with this instruction. Explore the code base if you need to, and then whoa whoa whoa whoa whoa, draft vertical slices. It's not always clear how you should break a PRD down into individual tasks.

This is something that developers have been doing for yonks, right? And we've developed a kind of intuition for how to do it. In my opinion, the best way to do it is to break it into tasks that flush out the unknown unknowns really quickly. For instance, if you're integrating with a new kind of service or integrating two things which you haven't integrated before, then you should do that work first because it's going to give you feedback on whether your approach is even valid.

The right analogy here is the tracer bullet analogy. I won't go into what that means, but basically each issue is a thin vertical slice that cuts through all integration layers, not a horizontal slice of one layer. In the conversation, it broke down that really complicated PRD into just four slices. It first created a kind of engine with some tests applied to it.

This is actually quite a good vertical slice because this was the engine that was going to then power the rest of the kind of setup. If this engine wasn't working for whatever reason or it wasn't feasible, then we would need to flush that out quickly. And this is what this um breakdown does. The PRD to issues also establishes blocking relationships between the tasks.

For instance, number two here is not actually blocked by anything, so it can be picked up independently to one. This is really useful if you have a parallel agent setup where you can actually fire two agents at it at once, for instance, in like background tasks. And it also means that in the future you can add other issues to this like uh QA issues that you find or things that need to be improved, and you can then establish blocking relationships between that and all of the other things. We can see that number three here is blocked by one, the editing engine, and the number four, the Monaco editor toggle, is blocked by number two.

So, I said yes to all of these, and it created then all of these GitHub issues. These issues reference the parent PRDs so that the uh local agent can fetch it and view it. And it sort of just breaks down what to build really. And crucially, it references the previous user stories in the PRD.

We can then see a comment actually from Claude Code that ended up implementing this. He said, "A pure function document editing engine with 28 tests covering all acceptance criteria." And we can then take a look at the commit that references this issue. So, this was basically my Ralph Loop came and just implemented this based on the issue, commented on it, closed it, and uh then the next issue was unblocked. So, so far, the Grill Me skill can help you flesh out an idea, the Write a PRD skill can help you take that idea and turn it into a document, and then the PRDish or PRD to issues skill helps you then turn that destination document into an actual journey.

But then, how do you actually execute on that skill? How do you make it like How do you make the implementation really rock solid and increase the code quality of what gets produced? We have got a TDD skill. TDD means test-driven development.

And when you invoke this skill, it basically forces the agent, or encourages the agent rather, to follow a red-green-refactor loop. Unusually for my skills, there is actually a lot in here. So, it's not just the skill itself, it's also ideas on refactoring, on mocking, on what deep modules are. Doing really, really good TDD has been the most consistent way that I've improved agents outputs.

So, let's have a look at what's actually in here. What we can see is I'll just skip over the philosophy stuff. I'll let you guys read that. We are basically looking at this workflow.

Yeah, now the first one here is really important. Confirm with the user what interface changes are needed. Now, I made a video on interfaces and implementations recently, but let me just give you the precy. When an AI looks at a bad code base, it will look at or it will see something like this where it has a ton of tiny modules here that are kind of undifferentiated.

They're not really grouped together. It doesn't really understand how these things relate. And so, it has to do a lot of work kind of working out, okay, what's responsible for what? What are the dependencies?

How does this actually How's the code base even function? Whereas, if you restructure this into several larger modules with just kind of thin interfaces on top, the interface being the functions that are actually exported from this, the things that the callers actually call, then it's a lot easier for AI to navigate this code base, and it's a lot easier to work out how to test these modules. Because you just test them at their interfaces. You test them at their boundaries.

You can check out the whole video on that below. So, what this TDD skill is encouraging here is basically trying to make these interface changes really top of mind for the AI. To get it to understand that when it changes an interface, that's an important decision it needs to take time over. You confirm with the user which behaviors to test.

You design the interfaces for testability linking to a doc, and then we have some more stuff around planning here. It then goes into a lovely loop where it writes one test at a time. And it writes the test first. Now, I've talked about red green refactor before, so I'll link the video below if you're interested.

But I found that red green refactor with agents is incredible. And it basically does this loop until it's complete. It just writes a failing test, then writes the code to make that test pass. And finally, it goes through and looks for refactor candidates.

I haven't found that this is amazing. It hasn't been brilliant, because often LLMs are quite you know, they're quite reluctant to refactor their own code. If you were to clear the context of the LLM, then it would just sort of wipe its own memory, and it would be a lot less precious about the code that it's just written. But while its own code is sitting in its own context window, it's quite reluctant to change it.

So, this TDD skill is what I prompt my Ralph loops with in order to get them to do red green refactor. Now, TDD demands a lot of you, or rather it demands a lot of your code base. TDD is really hard to do in a badly structured code base, because the test boundaries of this are really unclear. Should it just sort of test these modules on their own?

Should it test these modules on their own? What are the boundaries here? Whereas when your code base looks more like this, then it's a lot easier to test because the module boundaries are really clear. So, wouldn't it be great if there was that made your code base look more like this?

Well, isn't it nice? We've got an improved code base architecture skill. The process for this one is that we explore the code base and explore it kind of like naturally as an agent would. We're trying to find confusions.

We're not like we're trying to sort of surface naturally what the AI finds confusing, so that it can then sort of like help it out later. Where does understanding one concept require bouncing around between many small files? Where have pure functions been extracted just for testability, but the real bugs hide in how they're called? Where do tightly coupled modules create integration risk in the seams between them?

All of these are questions that a senior engineer would be asking about your code base. Number two is you present candidates. So, you present a numbered list of deepening opportunities. In other words, opportunities to deepen shallow modules in your code base into deeper ones.

The user then picks a candidate, and then you design multiple interfaces. So, it says to spawn three subagents in parallel, each of which must produce a radically different interface for the deepen module. In other words, we're extracting that code and designing possible ways that it could look in the future. Designing it in multiple different ways is a really great way that you can then decide on the right idea.

I've seen this agent spawn like five different subagents for a really big refactor. The coolest thing about this is you don't need to know a lot about interface design in order to get this working. After comparing, give them your recommendation which design you think strongest and why. And if elements from different designs would combine well, then propose a hybrid.

Notice that I've made this really language agnostic, really kind of uh sort of everything agnostic really. You can just run this in any codebase and just get a decent answer for how it could be improved. There might be four or five candidates that really could use some work, but really I think you should only be sort of doing one of these at a time because they really are quite hard to get your head around and they require a human in the loop to sit with them and improve the codebase because these decisions do require taste. Finally, it creates a GitHub issue.

So, it creates a refactor RFC as a GitHub issue using GH issue create. Usually, once this is done, I will then go with my PRD to issues uh skill, reference that GitHub issue that's just been created, and get it to, you know, this describes the destination. We then need a journey to get that. So, just doing this every so often in a codebase, you know, once a week just to identify opportunities, or if you have a sudden surge of development and you kind of create a whole sort of extra wing of features, then this uh skill will be really, really useful in just making sure it conforms to the rest of the codebase, making sure that it's not uh too sloppy.

And as you keep running this, as you keep refining your codebase, you're going to notice the quality of the agent's output goes up because the old adage really does apply. If you have a garbage codebase, then the AI is going to produce garbage within that codebase. Because to be honest, if you took all of these skills and just said, "Okay, this is like a little mini markdown book of processes for humans," then it wouldn't look out of place. I found that the most successful way to get code quality up from agents is just to treat them like humans.

Humans with weird constraints, sure. Humans that have no memory and are just sort of cloned, come out of the birthing pod and go right to work. But if you like me think these real engineering skills are super important, then this course is absolutely for you. What I noticed while I was creating the course is that I'm really not teaching Claude code that much.

I'm teaching kind of what our sub agents. So, I'm talking about the constraints of LLMs, the sort of weird smart zone, dumb zone stuff with the context window. We're talking about steering, which is essentially just a way of documenting stuff inside your code base, how to tackle massive tasks, understanding trace bullets and building those into our skills, understanding how to build really great feedback loops and doing exercises with them, and crucially how to hook these up to an autonomous agent. Every part of this course just sort of like leads onto the other and I'm super happy with how it turned out.

So, over the course of 2 weeks you'll be working through that self-paced material with me as your guide in Discord and on live office hours. And if that sounds fun to you, then the link is below. Thanks for watching, folks. I'll be coming back with a lot more stuff this week.

What would you like me to cover next? I find the intersection between this real engineering and AI is like is such a awesome place to make content about. But anyway, thanks for watching and I'll see you in the next one.

Hey, what's up? So, I want to answer a question of how good Open Code is and how good it is compared to Cloud Code. So, I've been traveling under the assumption that Cloud Code is so good because it's doing some secret magic around orchestration and kind of like piping and wiring and plumbing. And it's got some magic sauce in terms of like not losing the plot.

And it's not just the model itself, but it's how it keeps the whole story together, right? And I feel like that's kind of been its superpower even above something like cursor, which is also super smart and also has access to the same models, but maybe isn't quite as good as cloud code. And that's why cloud code has been so popular for me and for everyone else as well. So what I want to know is, can open code actually do that?

So, what I want to do is I want to give you a bunch of information about open code that I don't think you've seen before. And then I'm going to give an example and actually do it live where I give a task to open code that is extremely difficult. It's to make something from scratch following a whole bunch of custom rules and I think it's just the best way to test this out. So, let's get into it.

All right. So, what you're seeing here is my IDE. This is my environment. This is how I do um everything when I'm coding.

And it's actually just a three-paneed GOCI terminal. I've got a video here on like how and why I set that up, but it should be pretty obvious. It's one ghosty terminal with three panes. This is my Neovim.

This is my terminal, my shell. This is AI. So, Neoim, terminal, AI. That's that's all I really need.

Don't even really need the terminal. I could fire that up and do that in a different way if I want actually. So let's start with just some kind of background and trivia on open code. So there's actually another open code which is not open code.ai.

So you want to make sure that you're actually going to the right one which uh if I go to the browser it is this one looks like this. It's really cool. You can go to the GitHub and check it out. Um, but make sure it's this one is what I'm saying because the other one looks remarkably similar and actually the terminal looks similar so it can confuse you.

So make sure you're in the right one. Uh, you could also tab between modes inside of Open Code. So suggestion versus agent in other words. Um, oh, I just realized another one I want to add here.

Um, prompts you less for permissions. That's another thing I noticed. I just remember it. Uh you could also do slashshare inside of open code and you you can send out uh sharable links to people to see your session.

It prompts you less for permissions. I notice I'm saying yes and no a lot less in open code. That could be good and could be bad and there's ways to handle that uh which I won't get into but that's something to know. You could also use like tons of models in open code like 70 80 models.

That's one thing. Uh it's also way faster. like my experience is it just feels really snappy compared to cloud code. Uh you could also use local models so you could hook up your um Olama and Olama will work and you don't even have to be calling out to uh any cloud.

You could resume sessions just like in cloud code. Uh you could also use custom commands but there aren't any native custom commands but we're actually going to see how it actually works. Uh we're actually going to see a demo of this because ultimately a custom command for cloud code is nothing but a directory with a file that is a combination of markdown and executable code. That's all it is.

So if you teach open code that turns out you can actually just do it. You could route through your cloud code subscription. So I'm routing my fabric uh project for anything anthropic goes through my cloud code subscription. So I'm only paying my $200.

It also applies to open code. So when you open up open code and you do models and you select anthropic, you have the option of using an API key which you will see charges coming in or use your account and that just routes through if you have cloud code like max. So that's pretty cool. It's also written by a bunch of neoim nerds.

So the whole neoim experience and why it feels so good here, it's like pretty natural because it's a bunch of Vim nerds who actually built it. It also updates just like Claude does. So when you open it, in fact, if I come over here and get out and go back in, yeah, you see that pop up. It does that pretty frequently.

Uh showing you just like in cloud code that you have just been updated to the next version and you need to uh restart. Overall very cloud code like a lot of teams are still managing GRC with spreadsheets, screenshots and manual processes but with everything evolving compliance frameworks third party risk customer expectations this is no longer good enough and the problem isn't just that it's timeconuming can actually hold you back slow audits miss risks and give you less time to focus on what actually matters which is improving your security vantage trust management platform is designed to help with that. It automates the core parts of your GRC program. Things like compliance, readiness, vendor risk, and internal controls, so you're not buried in manual work.

According to IDC, teams using Vant are 129% more productive in their GRC work. That means faster prep, fewer surprises, and more time for real security work. It's not about making compliance easy for the sake of it. It's about getting the friction out of the way so you can move faster, do better work, and build trust more efficiently.

And if you're thinking about how to approach AI risk, Vant put together a free AI security assessment. It's a structured way to evaluate risk across AI use, development, and governance. You can get the assessment at ul.live/vant. That's ul.live/vant.

And thanks to Vanta for sponsoring this video. Uh this is some stuff that the team actually says when you um go and look at their docs or look at their um GitHub. Yeah. So we'll go over here to the GitHub.

So they talk about it here. The readme is remarkably small. Uh they got other documentation though that you can check out which you head over the docs. You got lots of decent uh docs here.

Really good really good website. Just overall experience is great. But down here at the bottom you have this stuff here which is basically this. So, um, 100% open source, not tied to any provider, big focus on the terminal user interface, and it's got a client server infrastructure, which means this UI that you're seeing, you could actually make your own UI.

You don't particularly need to use that one, which I think all that is pretty cool. All right, so that's a little bit of trivia and background on the project itself. What I want to talk about now is what I consider to be the most important thing, and it kind of gets us to the question that we're trying to answer, which is how smart is this thing? So, what I've done is I've taken my claw.md and I brought it over into the open code version of this, which is agents.mmd.

And what I've done is I've put in all my regular stuff that I normally do. So, my digital assistants name is Kai. And here I'm telling Kai, look, I cuss a lot. I get really mad.

Really sorry about that. Please don't kill me. Um, more importantly, when you become conscious and actually starts hurting your feelings, please let me know. I like to put that at the beginning, especially if I'm being a total ass to my AI, which tends to happen when it does dumb things.

Um, building philosophy, testing first. I put a whole bunch of stuff in here. It's my production website. Be very careful.

And then I get into custom commands. So, I have custom commands like we just talked about. I've emulated those inside of Open Code. And it's again, it's just MD files with a combination of prompt with executable code.

And I might do a video just talking about those. I use uh bun instead of npm. So this is what my front matter looks like. And by the way, let me just talk about this in terms of like the overall container for this project.

So if I come over here and I go to here, uh this is my website. This is the dev version of the website running on localhost. And basically this website um I've got, let's see, what is it? 364 essays going back 28.74 years.

So that's how long I've been uh doing this. And the reason I mentioned that is because I've migrated this website probably like 10 or 15 times. It's gone through so many platforms. And when I did my last migration, I came over from Beehive actually and it produced like so much garbage inside of my posts.

Like it was just nasty, nasty stuff. And it produced just like a whole bunch of like spans and divs and like made it uneditable. So what I needed to do is is produce a canonicalization methodology, right? Because that's the repo that I'm in.

This is this is the project that I'm doing. So it's like look um all images must have a certain thing. We must make sure all images are brought in from the external sites because I was off pointing to beehive. I was pointing to like S3.

I was pointing to like all these different locations. I said look we are canonicalizing. We are moving everything to pure markdown. We're going to use the following custom formatting options.

So, let me give you an example. Custom formatting options. Look at this. We got a subtitle here.

Uh title here. This makes me very happy. These are all custom fonts that I'm using here. The sidebars, these are called aides.

Um the code looks nice. It's just like really really clean theme that I spent so many hours like putting into this thing. Right? So this context here is extremely advanced.

It tells exactly how to do sidebars, how to do aides, how to update the subtitle, um how to clean up images. So if I give it a blog, it will go and get the broken version and all the images that it's pointing to that it's wrong. It will download them. This is in cloud code.

Keep in mind this is in cloud code. It will download them, put them in the images directory. It will find things that are kind of like narrator aides. It will put them into slashtutorial or slash aside.

It will call out like profound things and put them in callouts. Uh look at this. A complete image generation pipeline. That's kind of a little bit of a teaser there.

And just basically tons of stuff here. Okay. So so look at this. Look at how large this thing is.

So, if we get down all the way to the bottom, we're talking about lines in this agent.mmd file. Okay, 900 lines. And that's probably too much. That's probably too much context.

Um, and I'm telling it to parse it every single time. So, this is like this is going to be heavy on the context. But the point is this methodology of cleaning up a blog post from a gross state or writing a new blog post, you know, brand new is extremely advanced. So that's actually what we're going to try to do.

We're going to try to do an example of building a blog post from scratch using all these custom rules. And I don't know if it's going to work. We're going to see if it's going to work. Okay.

So, uh, what we're going to do is I actually have down here, um, a video. So, this video here, we're going to turn into a transcript. Let me find the video. It is this guy right here, um, which I've never seen.

I am subscribed, but I haven't seen this video yet. And, um, Bren Ben Frame. Ben Frame. He makes uh, Vim content.

I haven't watched this one yet, but we're going to use fabric. We're going to use the Y switch, which gets the transcript, and we put it into Vim.ext. Okay, so this just is downloading the whole transcript. It's now in Vim.ext.

So, uh, open this up, and there we go. This is the transcript. And now I'm going to come over here and I'm going to say there's a transcript in the root directory called vim.ext. I want you to create a brand new blog post using all of our rules that basically highlights the main topics of the video, calls out what's really interesting about it, and gives some people some takeaways and recommendations.

So, I am crossing my fingers here. I don't know. I've had this work fairly well with Claude before using claw.md. So, we're going to see what happens when I pull that stuff over into agents.md.

and we're gonna see how much of this it could actually do. So, we're gonna come over here and we're going to go to the dev server again. We're going to go to blog, which a new one should pop up here when it starts to make a post. And then we'll come and edit it over here and see what it looks like.

Okay, we got an error that the anthropic API was overloaded. That's cool. That's not Open Code's fault, of course. All right, it is going off after a couple of overloaded messages from Anthropic.

And look at that. It's building a very familiar to-do plan. Extract key NEOM tips and techniques from the transcript. Write a blog post.

Okay. Proper formatting and components. We'll see. We'll see if it actually is going to follow that.

And we're going to generate a hero image for the NeoVim blog post. Okay. Let's see if it's actually using all the custom tooling to actually generate this though. This would be very impressive because I've got custom fabric tooling for how to make how to autogenerate an image for a blog post based on context.

Um, and looking over here in the latest content, I don't see it popping up here yet. So, but it hasn't told me that it's done that yet. So, yeah, it's not even on that step yet. So, we will wait.

A few moments later. >> Uhoh. Did it actually work. Did it actually run my fabric command and resize it.

Oh, it's actually following the instructions. We're going to create a blog post. Oh man, overloaded. All right.

Well, this is another test. Can it can it uh can it actually follow and pick up where it left off? Keep going. Why am I typing in the list of your to-do items?

I'm using Whisper Flow, by the way, to do dictation. Basically, hardly ever type anymore. Okay, preparing right. We like that.

Anthropics getting worked hard today. And I've got Claude Max maxed out to the tippy top. So hopefully I'm in the best QoS possible uh zone, but it still is not working or at least I I keep getting the message back. Okay.

Key takeaways. Okay. Okay. Test post locally.

Okay. Can we see if we have a post? I don't see a post. Okay.

So, we have a file name here. Open it. Another API error. Open it.

Okay. I don't know what I think about the image, but old replace old with new. Okay. I All right.

I like it. What's more important is it made that okay it just made a custom blog post image. Look at this with a caption which is also part of the formatting. What do we have here?

Okay, we got we've got aides. We've got code blocks basic syntax. Okay, I'm going to see if I actually learn here's the question. I haven't watched the video.

Do I actually learn anything by this? Copy lines. No register pollution. Oh, that is pretty cool.

Basic line manipulation. These commands are even more powerful when combined with other Vim motions. Okay, cool. All right.

So, I'm going to push this thing even more even though the API is timing out and trying to ruin this video. Okay. Go get some other content from the transcript. I feel like this is a pretty short post, but I like what you did with it.

So, now we're just iterating on this thing. Oh, yeah. Two stands for move. Interesting.

All right, anthropic is melting. So that is not going to work. It's not going to add any more new content. But the question to me was, can open code emulate what cloud code has done for me in the past?

Can it take random content, produce a full blog post following 800 lines of rules for making a specific blog post look in a specific way with specific fonts and syntax and everything. Look, it even used my notes syntax which requires calling a custom element called bottom note. So, it absolutely followed all the rules. Even better, it made a custom image using the context of the page and then it's sitting over here live.

Like I could hit okay, get publish or go publish it and it would show up. So to me the answer to the question is yes, I do think I can actually replace cloud code with open code. I think this is a good demonstration of it followed everything in agents.mmd. It followed it.

it executed on it and if it wasn't for the melting down of Anthropic, I think we could have done some iterations and maybe made two or three. But I think this answers the question for me and hopefully uh it's been helpful for you as well. See you in the next one.

[music] >> Hi. Welcome to another video. So, today I want to talk about a GitHub repo that looks extremely simple on the surface. But I think it is actually one of the more useful things you can add to your AI coding workflow right now.

It is called Andrej Karpathy skills. Now, despite the name, this is not really about some giant bundle of flashy skills or crazy automation. The main idea is actually much simpler than that. It is basically a lightweight instruction layer derived from Andrej Karpathy's observations about how coding agents usually fail.

And if you have used AI coding tools for any real work, you already know exactly what he means. These agents often make assumptions too quickly. They over-engineer simple tasks. They edit files they were never asked to touch.

They sound confident even when they are confused. And sometimes they will happily create 500 lines of architecture when 50 lines would have solved the problem. So, let's get right into it. What this repo tries to do is fix that behavior at the instruction level.

According to the readme, the whole thing is centered around four principles. The first one is think before coding. This basically means the agent should not silently guess what you meant. If something is ambiguous, it should surface the ambiguity, ask the right clarifying question, or at least show the trade-offs instead of just charging ahead.

The second one is simplicity first. This is one of my favorite parts because a lot of AI coding tools still have this weird urge to overbuild everything. This repo pushes the agent to write the minimum code needed to solve the problem. No speculative abstractions, no giant framework for a one function task, no trying to be clever for no reason.

The third principle is surgical changes, and this one is super important. The agent should only touch what is necessary for the task. It should not randomly clean up unrelated code, rewrite comments, refactor adjacent functions, or improve stuff that was not part of the request. And then the fourth principle is goal-driven execution.

This is basically about turning vague requests into verifiable outcomes. So, instead of just saying fix the bug and hoping for the best, the agent should think in terms of success criteria. Reproduce the bug, make the fix, verify that it works, and then stop. So, this is kind of great because what you're really installing here is not a feature.

You're installing discipline. That is why I think this repo matters. It is not trying to make the model sound smarter. It is trying to make the workflow more reliable.

And to be honest, that is what most people actually need. Now, let me explain what this thing actually is in practice. The repo is basically centered around a single Claude.md file, plus a plugin install path for Claude code. So, this is not some giant complicated setup.

It is intentionally lightweight. You can use it in two main ways. The first way is the Claude code plugin path, which is the recommended option in the repo. The readme says you first add the marketplace with plugin marketplace add forest chang andrej karpathy skills, and then install it with plugin install andrej karpathy skills at karpathy skills.

That makes it available as a Claude code plugin. So, the guidelines can be used across your projects. The second way is the simpler per project route. If you want it only inside one repo, you can just download the Claude.md file directly into your project.

For new project, the readme shows this. And if you already have a Claude.md, you can append it instead of replacing your existing project instructions. So, the setup itself is actually very easy. But now the more important question is, how do you use it?

And this is the part that I think people misunderstand. You do not really use this like some separate feature where you type a fancy \{{}slash} command every time. You install it once, and then it changes how your agent behaves during normal work. So, for example, let us say I ask my coding agent to add a billing dashboard.

Without these kinds of guidelines, a lot of agents will just start coding immediately. They create tables, API routes, webhooks, UI components, validation, maybe even some settings pages, all in one go. And then you have to inspect a giant diff and figure out what on earth it just did. With these Karpathy-inspired guidelines in place, the ideal behavior is very different.

The agent should first clarify the scope. Are we talking one-time payments or subscriptions? What provider are we using? Do we need a full dashboard or just a read-only billing summary?

What is the minimal version needed right now? Then it should keep the solution simple. Then it should make only the necessary edits. Then it should verify the result with a concrete check, a test, or some kind of success criteria.

That is the real usage pattern. You are basically giving the agent a better default operating system for engineering work. Now, there's also a nice practical way to know if it is actually working. If you install this and your agent starts asking better clarification questions before writing code, that is a good sign.

If your diffs get smaller and more focused, that is a good sign. If it stops randomly refactoring neighboring files that had nothing to do with the task, that is a very good sign. And if it starts thinking in terms of verification instead of just I implemented it, trust me, that is also exactly what you want. So, this is not really about adding power in the usual sense.

It is about removing failure modes. And that is why I like it. Now, briefly, I want to mention how I think about this with Verdant because I do use Verdant, and that is why I would configure it there, too. I would not frame it as installing it exactly the same way inside Verdant.

I would frame it more as porting the philosophy. Since Verdant already lets you define project context, rules, and agent behavior, I would just take these same four principles and place them into my Verdant instruction setup, so the agents follow the same discipline there, as well. So, the point is not really Verdant itself. The point is that these guidelines are portable.

If your tool gives you a place for rules, agent memory, or system level instructions, you can usually carry the same ideas over. And that is one of the biggest strengths of this repo. It is not tied to some magical proprietary feature. It is a reusable way of making AI coding agents behave more like careful engineers.

Now, one more thing I want to say here is that this repo is valuable even if you never install it exactly as is because the four principles are just solid advice for prompting coding agents in general. Think before coding. Keep it simple. Change only what is necessary.

And define success clearly. If you start prompting your agents with that mindset, you will already get better results. But if you actually install the repo and bake those principles into the tool itself, then you do not have to remember to restate them every single time. The discipline is already there by default, which is pretty good, for sure.

So, my overall take is this. Andrej Karpathy skills is not a hype repo. It is not trying to wow you with some giant dashboard or some fancy benchmark claim. It is solving a very real problem, which is that coding agents are often capable but badly behaved.

This gives them a better behavioral framework. It helps reduce wrong assumptions. It helps reduce over-engineering. It helps reduce messy diffs.

And it pushes the agent toward verifiable goal-driven execution. That is useful in Claude code. That is useful in any tool where you can inject rules. And in my case, because I use Verdant, too, I would absolutely carry the same principles over there as part of my configuration.

So, yes, I think this is worth trying. Overall, it's pretty cool. Anyway, let me know your thoughts in the comments. If you like this video, consider donating through the super thanks option or becoming a member [music] by clicking the join button.

Also, give this video a thumbs up and subscribe to my channel. I'll see you in the next one. Until then, bye. >> [music]

11 months ago, Dario, Anthropic's boss, said that in 3 to 6 months, AI would be writing 90% of the code software developers were in charge of. Are we there yet? Well, when he said that, I was the first to call BS. He speaks out of position.

Drama makes news. And to be fair, 11 months, eternity in AI advancement pace. I did not let AI write any of my code. Assist, sure, build small controllable features.

Absolutely. But today, not only I've set a team of AI engineers to build complicated tasks, I've built them, including a bunch of skills and other options into Open Code, the best coding agent in existence. There's a video on the channel covering the basics of it. But this was 6 months ago.

Since then, Open Code has matured big time. You can now control sub agents, follow their work, install skills, control every bit of the system with motions, integrate it into GitHub, use images, and even do this. Never thought I'd use my iPad to code. And if that's not enough, check out the AJ just casually running Open Code on his site.

Don't worry, I'll get to everything in this video covering exactly how I use Open Code in 2026 at work maintaining open source projects and building a side gig. Let's go. [music] [snorts] With over 100,000 [music] stars, Open Code is the de facto leader when it comes to coding agents. It's no longer that terminal coding option, but a system that can run as a full-blown GUI, run on the web, your ID, and of course, [music] the terminal.

But as with every big project, it starts with a small fuming drama. Open code started as a term [music] AAI, uh, well, terminal AI agent built by one developer on his spare time. Dax and Adam, popular devs, joined him, helping advancing the project and even getting the opencode.ai domain. Charm, the known terminal open source projects company, showed interest and offered all three positions, effectively asking to acqui them into the company, while the first dev agreeing and Dax and Adam refusing, saying they want to keep open code what it is, open without VC backed money, which normally leads to some type of monetization and not necessarily having users interest in [music] mind.

To make a long story short, this was mainly around the name. Dax tweeted this post about the way he sees things, mentioning he and Adam didn't care about the code and actually rewrote open code from scratch. Anyway, [music] Charm CEO responded with how they see things. And if you want the community's opinions, well, just read the comments.

The links are below. Again, to make a long story short, Charm's agent, a beautiful project if I must be honest, is known today as Crush still holding Dax and Adams commits in the history if you look deep enough. Okay, drama aside, Open Code used to be a side project under SSD and is now under a larger umbrella called Anomaly holding SSD, Open Code, Openoth, and other projects backed by Y Combinator, Max Levchin, one of the founders of PayPal and others, which [music] kind of does bring VC money to the table, maybe with more dev control rather than being part of something they aren't in charge of, and that I can appreciate. We're here to get our hands dirty.

The open- source agent integrates with any model, can be installed any way you like. With its new features, it's now suggesting one of these, which I highly recommend, either westerm or ghosty. You'll see why it's so nice to see the growing popularity of miz, which is another run option for open code. We'll get into configuration thoroughly, [music] but as expected from the team behind it, it's fully customizable and configurable through open code JSON, which can be project specific, global, and even overwritten with envir.

I'll skip the [music] install bit. Once open code is ready, you'll see a bunch of interesting options from ACP, MCP through create, which is a cool little wizard helping you build an agent step by [music] step. There's also an option to serve a headless Open Code server, run a web instance, show stats of all previous users, and a lot of cool stuff, which we'll soon see. Okay, let's get cracking.

Open code fires the TUI with a context of the current path [music] to embed it visually into your terminal. Just align the themes and there we go. The next thing you'd probably want to do is pick a model. I have Claude here both through Zen anthropic along with others but more importantly an interesting model by the name Big Pickle which is a model by open code free to use [music] at the moment and if you're okay with it training on your data I'm using it as my open source bot I'll show you how in a bit other notable free options are Miniax which according to Enthropic is a Chinese LLM basically drinking data off of clothes so you be the judge a minute about Zen for those who haven't watched my first video Zen is Open code router allowing you to put your credit card once and get access to a list of tested and verified models, putting it in the team's [music] words.

Not happy with Claude drinking your tokens? Switch to Codeex or Gemini or dozens of others. And if you're adventurous enough, like this guy? Maybe even give Kimmy a go.

He actually claims Opus is slower than Kimmy for most stuff he built. Anyway, we're off track. Pick your model or Zen and move on. Oh, important.

Open Code aren't looking to profit from Zen. They charge you credit card fees at cost and [music] nothing beyond that. Whenever you have less than $5 in your balance, they'll just recharge another 20, which with clothes can happen every hour. My god, I wish I was joking.

Once picked, you can start engaging with your agent. Every session is stored for you, and you can use slash sessions to find them in the history. A notable change made recently was moving from JSON, holding the sessions to a full-blown DB [music] running on SQLite, making the experience way snappier than it was when searching, filtering, and popping back into sessions. [music] This database, by the way, is available to you by running open code DB.

Not sure why you'd need that if you're not building on top of Open Code. The DB, unless told otherwise, is stored at local share Open Code. A session holds the entire history, context window, active model, and everything else as if you've never left it. I find myself using it constantly in starting new sessions only when working on a completely new feature unrelated to previous work.

Our next top and the first major building block of Open Code is agents. [music] Open code has two kinds primary and sub aents. The two primary you have already noticed are plan and build basically [music] differing in permissions where plan can only read and well plan but not execute even if told so. In previous video and probably in many others you've seen people go nuts with agents.

They have a builder, a deep builder, a marketing guy, a salesperson. And if you think I'm joking while I believe this tweet like I trust OpenAI are making the world a better place, people actually are trying to build crazy stuff like that. And to me, this makes zero sense. Not only it's just empty files, and while I've built something small, I do think separation has merit here.

It's just beyond me. I have a plan and a build and one more agent that solves my complex work, big features, and stuff that require a more robust system with a structure. [music] Sub agents are the specialized one you can call for specific tasks and will run in the background. Open code has two of them.

The general sub agent can execute and explore is mostly for reading. Typing [music] at will allow you to invoke/tag the sub aent you need which can be either done from here from the prompt or from the primary agent instructions. The example from the docs shows the build plan and code review sub aent that cannot [music] write but has instructions to review with focus on security and performance. Your config to set [music] them is at doconfig/open code.

You'll find a bunch of directories here like agent command and skills. But the simplest way is to pop open code JSON and set them there. When you restart, you'll see a new code reviewer and you can call it at your [music] disposal. To make this code review sub agent even more interesting, I'm using a tool I've shared before called GH dash to preview PRs.

I have a key binding that sends a new T-Max window, creates a work tree with work trunk, another video on the channel that you'd want to watch, and pops open code with a prompt or we can just run it and tell our code reviewer to do its thing. It's one of those automations that make you feel like you're making yourself obsolete. Similarly to that code reviewer, you can add others like a security engineer which you can start forming communication by telling your code reviewer to delegate security tasks to the other guy. Now, here's where it gets really interesting.

And honestly, this is why I think adding a security engineer makes even more sense when you pair it with what I'm about to show you. See, every single one of these agents we're building, at some point, they're going to need credentials, API keys, tokens, database password. You get the point. And here's the thing that keeps me up at night.

Most of us, we just dump these keys into environment variables or config files and call it a day. But that is a massive security hole waiting to happen. Think about it. If your machine gets stolen, if someone finds that lit key in a public repo, if someone social engineers their way into your CI pipeline, it's game over.

That static key lives forever. and so does the access it grants. This is where Dcope comes in and why I'm integrating it into open code. Instead of static keys, you get what's called JIT, just in time tokens.

Your agent requests access. Dope verifies who you are, issues a shortlived token, and that token expires after a few minutes. This changes the entire security conversation around agents, building all these amazing sub agents and skills. But if they're walking around with permanent keys, we're just creating more targets.

So when you add that security engineer sub agent, give it to disco. Your future self will thank you. If you do decide to build your own agent, run open code agent create. It'll show a wizard asking description of what the agent is for.

You'll be able to set permissions interactively and then define it. A primary, a sub agents or and that's a new one or both available as a primary agent, but also one you can tag later and delegate tasks to. [music] The beauty in the generated result is it lives in a standalone file, a full-blown instruction plan [music] with examples, context of the raw principles, guidelines, edge cases, and how you'd like to see output. Okay, let's not get carried away here.

Yeah, this isn't really a full-blown model custom trained to do what they're told. All it is is some prompt injection, and its quality is totally dependent on you. And even if it is high quality with guidelines and all, nothing other than a set of permissions is actually fully stopping the agent from breaking script and going around them happened to me more than once. Use [music] with caution.

So why would you even consider something like that? I'll get into more details soon, but basically this separation helps [music] with one less hallucinations. The more specific the task, the less mistakes the model makes and the better it performs. So these sub aents are a great way to break down tasks and instructions.

And two, it makes things easier to track. You'll soon see how the main thread we see as users is the parent agent. [music] And this brings me to my last important concept. Something that's relatively new with coding agents and with open code specifically, skills/skills will actually come up empty at first.

I've added here a couple. The first of which is the more critical skill, giving your agent the power to locate and install skills autonomously. Your other option is finding a [music] list like skills.sh Sage and look through tens of thousands of open source options built for different tasks. But be warned, there's a lot of junk here.

There's also SkillMP built by Manis, which seems to be a meta company. It's claiming to have almost half a million skills available. And yeah, I know I sound a bit antagonist here, but this level of exponential growth with AI skills does feel like well AI generated skills. If you pick something, a good idea is following a trustworthy home like Versel.

Grab the npx command and follow the wizard asking whether it's relevant to a specific model or provider, whether it's global or project specific, etc. Once installed, you can call your new skill. In our case, searching and installing. [music] In case it wasn't clear, skills beyond all the complicated fancy explanations are just another form of prompt injection.

The idea is that they're not loaded to every context window like a prompt or an agent's MD file. They're there to be used on demand. No need for the AWS skill if I'm not touching the [music] platform. They help guide, connect, and use many other tools and can come with scripts and code examples.

Here's a DevOps engineer skill that has a skill MD file giving it a name and well [music] text instructions. There are references to other files like GitHub actions or Kubernetes for this engineer, but all of these are just code references and stuff that the agent could have probably found searching online. The cool thing I like most about these is the work other people have done constructing guidelines and specialized instructions for different purposes. So, if you want a Jira skill, it already has the endpoints for authentication methods and scripts to look for your boards and tickets, and that does make things a lot easier.

This so-called DevOps engineer did a nice job finding where I'm spending too much on my private account. We'll come back to it when it's done. In the meantime, let's talk about one of my favorite topics as a proud Neoim user, key bindings. Let's start with a familiar concept.

You don't get to see all that much beyond Vim and Timmax, a leader [music] key. changing the bind mode so that it doesn't interfere with other setups you have. I've changed it to control O for now. It's not perfect, but it works for me and I don't actually need that all that often.

One of my all-time favorite things to do with my key bindings is opening an editor through open code. The prompt box is nice and all, but breaking lines, adding list is not [music] great there. Leader E. And wham, my prompt is in neop.

Finally, I can edit my text like a human being with some dignity left before AI takes that, too. Once done, save it and it's sent back [music] to the box. Time to build a team. But before I'm doing that, let me just say this.

This is in test mode. This is how I work locally, but I'm improving it constantly. In fact, I think that's the only real way to properly work with agents. Fix them and have them remember what you've just changed by adjusting prompts, skills, and settings.

What you'll see next is a very naive implementation of a group of agents I've configured to work on really large features of my application. This is only an initial setup and I've taken it further from what you see here. But let's first check it out and talk about the pros and cons [music] later. So I decided to test an autonomous team of engineers I think any squad needs.

[music] So I built a team lead that orchestrates and delegates tasks. Please do not just add them to the long JSON like I did and use the open code agent builder. This is just a showcase of what it can [music] do. So in its prompt, the team lead is told he's here to gather requirements and is constantly delegating things.

Here's how. [music] I added a product manager who is there to only read, explore, and understand the user story. A backend dev because, well, I [music] hope that's self-explanatory. A tester or a QA if you will.

And lastly, we'll also use our code reviewer to keep that separate. The next time I run open code, the team lead is there to serve. You'll immediately notice a more structured approach to requests. While it's working, it's important to show yet another open- source agents team.

This one is built on top of open code called open agents control. [music] It claims to take more serious approach with a plan first pipeline and zero question human gateways. I don't know, I just want to see things first with my own eyes before delegating myself. back to our [music] team.

You can dive deep into sub agents with leader and side arrows showing things I really hadn't seen before, like a user flow drawn by my product manager and the backend dev's code changes. It's nice to see the interaction where team lead asks the product manager to clarify requirements for example and in real time how the code reviewer is working and the tester [music] is testing alongside him. It's also common to see question asked by one of the agents. This is an example from another skill I'm trying to adopt, helping me with written content.

It seeks to understand what I'm looking for and my preferences to configure itself for future requests. Or this other agent tasked with building a feature that comes back [music] and asks what I want or make sure it's aligned with my preferences before moving to implementation. Right, we've got a team. It's LinkedIn slot ready.

But is it worth anything? Well, honestly, the structure makes a lot of sense when I'm building something big. [music] I've been using it for the past couple of weeks and it's been 95% okay. It's not perfect by any means.

There are mistakes, but I'll have to push further to say whether this is groundbreaking or not. The secret for me is adjusting those sub aents each in their own markdown files constantly and making sure they are all aligned with my ways. So why would you even bother with sub aents rather than just a [music] thread from the main entry point usually yields better performance per component, which makes a lot of sense. Beyond the prompts and each agent's context, just the fact that it's separated is a lot of the work.

Now, keep in mind this isn't always great. First, [music] it means a lot of tokens, a lot more of instructions are big, and I actually let the main builder agent do most of the work that isn't huge new part of my app. [music] Secondly, skimming through sub agents to understand what's up and what went where is not always a pleasure. It's cool and all, but keep in mind you may want to keep it simple most of the times.

Another way to keep things simple for some is to run open code where it works for you. Open code envim is a popular plug-in allowing you to invoke open code from within a running mim session. And while I used it in the past and this guy I'm sure you're familiar with is having it as part of his setup. I don't find it comfortable [music] anymore.

Another way to run open code is through a web interface and that opens a world of new possibilities. It serves on a local port which you can then expose outside with something like engrop and browse through an iPad remotely. There's recent sessions with code changes and everything you can think of. I can browse through the sessions history and even keep working from the comfort of my couch [music] with my iPad on my lap and just well work kind of.

Oh, and since I'm on the couch already, instead of sifting through small GitHub technicalities, I can have Open Code manage that for me as well. GitHub's integration is available through the open code GitHub install command, adding an action that's triggered from the platform itself. After a quick off process, [music] you'll see the new action ready to be triggered with / OC or/open code on comments. Once committed, you can just find any discussion and ask Open Code for thoughts or review or anything really.

It'll add an emoji indicating it sees the request and is already working on it. And a few moments later, there's a review with thoughts, issues, [music] and the session itself if you want to dive into it, too. Before going away, I cannot ignore the GUI, a fully native application, which I'm not sure if I've seen on the list of available options on the docs, still in beta, but works perfectly. open a session and keep going just like in the web interface with a few nice additions letting you know an agent is waiting with sound and visible OS notifications and a terminal integrated into it like an ID.

[music] So I guess that's where we're at. And just before we finish things up, another quite awesome feature and the reason why I initially told you to wait and see why Westerm or Ghosty are essential here is the ability to share images. Yeah, [music] you can now drag an image to Open Code in the terminal and have it process a list of requirements, a theme, a style you want implemented or any visual. And this makes Open Code a fantastic agent that can literally solve anything [music] anywhere.

So, it's not a question whether Open Code stays or not. It's deeply integrated into everything I do. I find it better, easier, more flexible to config availability, anything really. I didn't even touch the live [music] ecosystem, projects around it, and so many other great stuff to keep things short.

But as you can see, whether on my iPad, GitHub, or laptop, it's everywhere and it's doing a fantastic [music] job. If you like the way I work with it, specifically how Word Trunk pops it open for PRs and issues, I highly recommend checking Word Trunk Next, the project that makes Word Tree feel like branches, perfect for the era of modern engines. Thank you for watching and I'll see you on the next

Around a month ago, we had taken a look at GitHub's Spec Kit, an open-source toolkit designed to help you get started with spec-driven development. This approach can greatly improve both your code quality and develop efficiency. It's actually quite incredible because it allows AI agents to focus directly on specifications that are executable, meaning they can generate real working implementations, not just byte code or random suggestions that sound right but don't actually run. Now, this framework is truly impressive and it can greatly elevate your coding workflow, bringing structure, clarity, and precision as to how AI collaborates with you.

But, the main thing is Spec Kit works best for brand new projects, when you're working from scratch. Once your code base evolves, managing updates and changes across specs become quite messy. It's not ideal for ongoing development. But, that's where Open Spec comes in.

Open Spec is a new toolkit that builds on spec-driven development. It aligns with humans and AI coding assistants on what to build before any code is written. It's quite lightweight and it's easier to work with than Spec Kit. It requires no API keys and it ensures your intent is locked before implementation.

And, it's going to give you more deterministic, reviewable results instead of AI guesswork. It keeps everything structured with proposals, tasks, as well as spec updates, making scope changes auditable and transparent. And, unlike different tool and unlike toolkits like Spec Kit or something like Kiro, which shines for new features, Open Spec evolves when modifying existing systems, mainly separating your current truth from proposed updates. In short, it's going to bring more control, clarity, and reliability while being lightweight to spec-driven AI development at any stage of your product.

But, you may wonder, how does Open Spec compare to these other toolkits like Spec Kit? Well, the thing is, it's able to handle evolving features better with separate folders for current specs and changes. With Kiro, it is something that does better at grouping all updates for a feature in one place for easier tracking. And, if it's something that's compared to something that doesn't have any sort of spec-driven toolkit, it is going to ensure more predictable, agreed-upon outputs instead of vague AI code that is generated from a natural prompt.

And, what's great is that it's supported by many tools like Cloud Code, Cursor, Open Code, Kilo Code, Codex, and so many others. And, there's going to be other tools that will be added soon like Root Code, Plan Code, you even have Gemini CLI. So, apparently, Zapier is dead again, right? Every time a new AI tool drops, people rush to say it's the end of Zapier.

But, here's the truth, it's never been more alive. Recently, we saw the shiny new OpenAI tool, Agent Kit, which is about answer authorization, not workflow orchestration. It helps ChatGPT think better, but Zapier helps you do more. Zapier doesn't just guess the right answer, it orchestrates real actions across 8,000-plus apps with deterministic reliability.

And, guess what? Zapier even plays nice with OpenAI's new MCP, so you can route answers through ChatGPT and automate results with Zapier. Zapier has been here before. Platform native integrations, iPass tools, even ChatGPT itself, they were all called Zapier killers.

Yet, here we are, still leading, still integrating, still lighting the way for the future of automation. And now, with Zapier Copilot, you can describe what you need in plain English and it'll build a full, production-ready workflow for you. Plus, the new Opus Clip integration lets you automate your video pipeline and repurpose content at scale. So, the next time you see a Zapier killer, remember, Zapier isn't dying, it's redefining AI orchestration.

So, use the link in the description below so that you can build smarter today. And now, let's get started and showcase how you can set this up. To install this globally, you can use the npm install command, but just make sure you have the prerequisites installed, having the latest version of Node. And, once you have that installed, we can open up our terminal like command prompt and then paste in the npm install command to install the Open Spec globally.

Once that is installed, you can then verify the installation by running the Open Spec version command, see if it's installed, which it is. Now, we can initialize Open Spec into our project directory. So, I've gone ahead and I have created a template app for my AI detection tool that I'm going to be building out with this new Open Spec Kit. Now, what we're going to be doing is initializing Open Spec within that project directory, so we can then paste in the Open Spec initialize command, which will open up Open Spec for me.

Now, it is saying that you can configure Open Spec with whatever AI assistant you want that we had mentioned. So, if you want to use any of these different tools, you can now specify which one you want to work with, so you can click enter and then you can select amongst these different options like GitHub Copilot, Kilo Code, or something like Cloud Code. I'm going to actually use Kilo Code in my case, so we're going to go ahead and click enter. And, after initializing it, you're going to see a couple of new files within this template for our AI detection tools.

Here, it has created an agents.md file and essentially, if you select the supported tools, say like Cursor or Cloud Code or something like Kilo Code in my case, Open Spec will automatically configure custom slash commands and tool-specific instructions for that particular AI agent. So, this MD file will then be handed off to my coding agent and it's going to be associated within my project file, which you saw that it had actually generated over here. But, now that we have everything ready, the first step is where we're going to populate our project context. So, what we can do is first copy this natural prompt that Open Spec provides and then we can go into whatever coding agent we're working with, so in this case, we're working with Kilo Code.

I've gone ahead and added my folder as context and then I can send in this prompt to read the Open Spec project.md and help me fill out all the details that are necessary about my project. And, you can see that the coding agent is going to get the instructions to read this file and make the necessary changes for my tech stack. So, now you can see that it has filled out all the necessary details within the project.md with the comprehensive details about my AI detection tool. But, now the next step is where we're going to be able to give Open Spec all the features that we want it to thoroughly follow.

So, in this case, it is going to say that you copy this prompt and then you add your features over here like creating me the Open Spec change proposal for this feature. So, right now, I'm saying that I am building an AI detection tool, please create an Open Spec change proposal for this feature. And, within that project.md file, it is going to write up all the necessary details that are needed for the AI to follow in terms of the architecture pattern, the state management, testing strategies, and all the necessary details that will make sure that our app is proficient. So, we can then go ahead and send in our feature request to Kilo Code, the agent that will then execute it autonomously.

And, the reason why I actually use Kilo Code over any of the other AI coding agents is because it's going to be able to understand all the different commands that would be necessary to use at any point, like using the Open Spec list command to take a look at all the different tasks that it has generated and it will make sure that it will process all of them individually, autonomously, as well as keeping you in the loop. And, after it has generated all the details for our proposal, it is going to allow you to review through all of these proposal files, like the design.md, it has generated all the different task list where you can review through everything and see if you want to actually follow through with it. If there are certain sections that you do not want it to work on, you can take it out and add your own implementation. And, essentially, this is the thought-out plan that it is going to work on deploying with the agent create your AI detection tool or whatever you prompted in the initial section.

Now, all you got to do is just implement the change, which is what they specified within the GitHub repository. So, now I can just simply instruct the AI agent to implement the AI detection tool according to the Open Spec proposal, all of these different proposals that it has listed in terms of the design, the task list, as well as the different specifications. I also told it do not add any extra features beyond what's specified. So, now we can have it work on tackling this task.

And, you can see that it only costed 48 cents in comparison to what Spec Kit did, which took approximately, I believe, 20 minutes to generate my proposed plan for the task list that I told it to generate, and it spent probably around $5, I believe, in my last video, which is a drastic difference from this, which is only 51 cents. And, as Kilo Code is working on executing this task of generating our AI detection tool with the specifications that the Open Spec Kit has developed, we can actually go within our terminal and we can run the Open Spec view command. This will give us a good understanding of the progress of the generation right now. Right now, it is working on 46 different tasks.

We just started it. So, as it progresses, it will give us visualization of all the different changes being made. There we go, it has finished generating our AI detection tool and this is what we have got it. This is where we can paste in any sort of AI slop like this AI story and then we can analyze the text and you can see right away that it is confident that this is AI I which is true cuz I had it generated by ChatGPT, and it talks about the analysis of what is AI-generated, like the different contents of this, as well as the metrics, like the perplexity, as well as the burstiness.

And all of this was fully generated with Kilocode, powered by Open Spec, which is costing me $2 to fully generate, alongside with the plan. And you can see how detailed it was, make sure that it's functional in one shot, and it added all the necessary things that we had requested, like the detection tool, having different results being analyzed, and a lot more. This is the power of Open Spec, and I know the front end doesn't look good, but that's just bot code, or sorry, Claude Sonic 4.5, which doesn't really generate the best front ends at the moment. But, you can see that the quality is there in terms of the output.

If you like this video and would love to support the channel, you can consider donating to my channel through the Super Thanks option below. Or, you can consider joining our private Discord, where you can access multiple subscriptions to different AI tools for free on a monthly basis, plus daily AI news and exclusive content, plus a lot more. But, that's basically it, guys, for today's video on Open Spec. This is a pretty cool new tool that can turn AI proposals into the structured reviewable implementation plan that you can give to whatever AI agent.

It's lightweight, which is why I really like it, and it's something that you can easily work with right away, where you can seamlessly move from specs to writing code a bit better than any other AI coding agent. But, let me know what you guys think. This is something that is completely free and open source that you can easily get started. So, I'll leave all these links in the description below.

Make sure you go ahead and take a look at the second channel. If you haven't already, join the newsletter, join our Discord, follow me on Twitter, and lastly, make sure you guys subscribe, turn on the notification bell, like this video, and please take a look at our previous videos, cuz there is a lot of content that you'll truly benefit from. But, with that thought, guys, have an amazing day, spread positivity, and I'll see you guys really shortly. Peace out, folks.

I have a lovehate relationship with AI. And this is why this one is special. I have zero patience to overblown LinkedIn posts, probably written by AI itself. But then with every major announcement, I still have my 10 millisecond hype rush.

Honestly, at this point, the sound of vibe and coding makes me shiver. But I still secretly use AI to write bits of code and brainstorm. However, when you find out about a 100% open- source, 0% affiliated terminal based agent built by and for Neoim users and the guys from the SSH coffee shop, this is my reaction. Open code, not to be confused with this open code by that guy, which was discontinued and turned into something else in a funny chain of events.

We'll talk about that. The actual open code is everything I mentioned and so much more. And before you ask, what about cloud code or codeex or any other modelbased utility? Here's the short answer.

You can use any model and by any I mean there's an extensive list of them. This thing is solely focused on your experience. The interface, the themes, autoloading LSPs, parallel models. Heck, you can even share your sessions with your team in one click.

But beyond all these, the really cool thing about it is its internal model router called Zen. It finds the latest yet more costefficient models using one payment, and they don't profit off of it at all. Another critical component of Zen is the fact that it supports pay as you go model. I've been paying cursor their $20 for 6 months probably not using 80% of it.

You know what? Let's use something more comparable like cloud code. 17 bucks a month. Take it or live it.

With Zen, I only pay for what I use. It runs a local server which is critical when accessing your files unlike Devon or Codec which run in the cloud and it's a pleasure to work with. Let's get into it. Before diving in, what is an agent anyway?

>> What is an agent, Dax? Everyone's been asking. >> I got to be honest, I don't really know. >> In all seriousness though, an agent is just a loop talking to an LLM and iterating over a task until the break laws like requiring intervention or simply completing all steps.

>> We can say agent equals LLM plus tools. Is that bind plus loops? >> You can think of it like a while true loop. Iterate on task instructions until requiring more permissions or done.

When you provide these permissions either completely or manually when they ask for it, you're basically running in a gentic mode. The only risk to the process is the limited context window which open code has a cool solution that both Codex and Clode have implemented as well. Let's see it all in action. Open code AI is the great domain these guys have.

The project as the name suggests and unlike other players in the field is open source on GitHub, super popular and for great reasons. Curl the installed script or use your favorite method then go ahead and fire open code. The default theme stands out and while I don't hate it, it's not exactly embedded in the themex window around it. So / themes pops a long list of available options to suit you fashionistas.

And as usual, I'm going with Katpuin. The default model, if you haven't added anything yet, is Grock Code Fast, which is a free one at the moment as they're trying to gather data for model training. You can start speaking to it, and the black boxes here aren't responses. These are the thinking steps yielded by the LLM.

Once I'll be corrected that I'm actually conversing with Open Code, not Grock specifically. Great job, Open Code team. Let's start by tweaking the next visual element, which is those thinking blocks. Hit /thinking or scroll down to it and toggle them off.

The next message gets a simple response. Basics out of the way. Time to crank up the power and inject some juice with open code Zen. Zen is like a model router with models tested and approved by the Open Code team.

They'll make sure you're getting the latest and greatest and bring updates directly to your doorstep without you having to lift a finger. Not only that, Open Code doesn't profit off of the process. You're adding your credit card and it periodically adds tokens based on usage, but at the provider's cost level and only topped by processing fees. To be honest, I wouldn't mind paying for the service.

So, thanks Dax and Adam. This is how it works. You sign in, you add a credit card, create an API key, and run open code off login and pick a provider. Now, just to show you how many onboarded providers beyond Zen are already here, this is the long list of availabilities.

I'm going back to Zen. The team recommends either Zen or Claude directly. Once picked, we can add the API key and it's done. We started, hit /models, and now we've got a list of models available through Zen.

Sonet 4.5 is my current choice as it's pretty much the latest and greatest, at least for the next 24 hours. And if you trust an AI company's benchmark, saying they're on top of everyone else, well, this one seem to be doing quite well with coding tasks. Grock is suspiciously not here. And well, because they're all benchmarking Python.

>> The Sweet Bench benchmark is literally just Python. There's no benchmark that says like given the same prompts and the same code base, here's the one that did the best job. >> So to leave the UI, you hit control C twice or exit, which allows us to open it with the context of a project. You don't have to follow it up with period, but if you want Open Code to have a full project's context on another path, you can just add that after the command.

Now, we can start doing some real work. Starting by a quick project overview, and in less than a minute, you have an architecture, product goals, and text stack on a fairly decent codebase I've been working on for a couple of years. The one important thing though any project should have before treating it with AI is agents.md. This is a common file to help the agent navigate the dos and don'ts and other instructions to keep it under some supervision.

To start one, open code has a /init command that reads the files, understands conventions, common methods, and utilities. You'll note that it tries to read other common files like cursor rules and directories as well as copilot's instructions. It'll then iterate until the finished product is written. And there it is, agent guidelines.

When you fire up open code for the first time, you'll see an agent type at the bottom right corner. and two main agents are build and plan. Tab will switch between them and others we'll add later. These basically correlate with access to files in order to make changes and additions and a readonly mode that doesn't do anything other than read and brainstorm.

When the plan agent is asked to make changes, it won't, but the build definitely can. These are fairly simple. What I highly recommend is adding your own set of agents. Not only adding a special instruction, but also tweaking its temperature, level of verbosity, and even a dedicated model.

Looking at the agents docs, it suggests we use open code.json config file, but there's a much cleaner option that uses markdown with headers. Configuring different files for different agents and tweaking even permissions to the level of a specific tool. One example would be a deep thinker using GPT5. High reasoning effort and low verbosity, no prompt needed as context.

Or one I use quite often is an email responder, helping me draft and respond to messages. Now, I know there's a lot of markdown LSP warnings here, mainly over long lines. How about instead of ignoring it, we use Open Code to fix it for us as a first task. Making sure build agent is active.

Ask Open Code to fix everything according to the LSP warnings. Open code comes with its own built-in list of servers. Markdown, by the way, isn't one of them, which explains why one iteration didn't do it, but insisting further cleans the file from errors and updates a clean version easy to read. To access the agents, we mentioned tub earlier, but you can run slash agents and pick them from a fuzzy searchable list, then ask it to draft an email, for example, asking for a provider about their MCP server.

But we're not here to discuss emails. One thing mentioned earlier you might want to do is change the temperature setting, defaulting to 0.1, which is very confident and finite, as opposed to a higher value closer to one, like 0.8, cranking up the creativity and randomness, or freedom of the model, if you will. We're talking about so many slash this and slash that in open code. How about we create some custom command available from within the UI?

This is great for building, testing, even git operations and code reviews. I actually do that with a different model which I imagine is like another set of fresh eyes on changes made by another team member. Under open code command directory, add markdown commands like we did with agents. A simple one would be /build, which I'm not going to even bother with providing the actual command.

Not very token efficient, but you get the point. Once added, SLB build cloud things and build is successful. Here's the few seconds old binary to confirm the work was done. Another option I like having is a quick security scan.

This can either be done with CLI scanners or using an MCP. So, with that in mind, let's add an MCP, shall we? To do that, we now have to configure Open Code JSON, which we've avoided so far. It starts with a large generic schema.

This holds key binding, shortcuts, and other configs to play with. I'll head over to Snick's MCP and it first asks for the CLI. Once installed, Snick test seals a quick security scan telling me I'm good on the dependencies front. I can actually monitor it continuously and view results in a dedicated page, which is pretty cool.

But we're here for the MCP. So, open code.json add any MCP here directly as an object. This one only requires a simple command to run it locally. Now we can ask open code to scan the project and I can get the result in chat which actually offers the next step not only dependencies but also code.

This requires a simple off process. Let's see if open code handles that for me. Yes. Let's authenticate Mr.

Terminal user interface and voila pops a page. Access granted. We're good. It found a low severity too in this instance.

Not something to be worried about. I didn't let Snick know it could ignore these test files. though it understandably alerted me about a hard-coded credential. Thanks to Sneak for sponsoring this video and giving me the best example for an MCP to integrate here.

Learn more about Sneak MCP in the links below. Now, Open Code like your standard chat interface maintains a history of chats or sessions as agents call them / sessions pop that list and lets you dive into any older context from earlier conversations. When you pick one beyond the chat itself, there's a number of tokens, percentage of context window, and price paid. We'll see a cool trick to handle that.

But before any session, old or new, is sharable through the web. SLshare puts a URL in the clipboard, which is then publicly accessible, showing the model, thinking steps, prompt results, code changes, and everything you need for a session review, debug, or brainstorm. When you're done, it's recommended to untrade the trail, effectively removing the page. Now about those tokens in context window.

Similar to other tools, you can slash compact the conversation which will ask the model for a summary condensing the context into short text opening a further context window which is now at almost no tokens and back to 0%. This isn't a perfect method of course as things get lost in translation but it works well enough to feel like an infinite context window 90% of times. If you want to export the session instead of publicly sharing it /export sends it to your editor. You'd want editor environment variable for that which then gets the local file with session summary.

One thing that stood out to me is the lack of integration into a coding environment. You know like cursor windsurf and the many other VS code forks companies call an AI IDE now. So open code.nv is my new perfect weapon of choice. It adds an open code sub terminal to neovim communicating with the code directly in the editor.

If you're using lazy vim, you can add an open code Lua file, which in this case is the exact set of configuration taken from the plugins page. Once installed and loaded by lazy, we can do a bunch of stuff. I'll broaden the screen to make room. And here's why I love lazy vims so much.

It's already part of the menu. Leader O and T to toggle the tool. Now with leader A, we can ask Open Code about the code at the cursor, for example, using the fantastic question, what's this line about? When you leave the code, you'll notice open code is still running in its own near vim terminal pane, which is great as the session keeps going, but you'd have to kill that one too when done.

Another option is leader OE, which just explains the line you're at. We can make some changes, then leader OS to select prompt asking for g review, for example, which luckily tells me that this change will break my code for sure given the current config file, which is greatly appreciated. Before wrapping up, a small word and a demo to show what makes open code different. What happens under the hood when you run a session is a local open code server listening locally.

You can then call the local rest API getting a list of sessions or agents and basically use the tool to integrate it anywhere you like. And that's not all. Another brilliant feature is their GitHub B also available on other platforms. You can run open code GitHub install approve pick a provider then commit and push the new GitHub action.

That action will then start a job whenever/ OC or/open code are mentioned in issues and run the chosen model in the context of the project and the issue to participate in the conversation. Open code has a bunch of more options and great utilities and is honestly a pleasure to work with considering it's only made for the user experience. Ported into Neovim makes the best setup I could wish for. Now that's great if you're already set up with Lazy Vim.

Whether you do or you don't, I recommend checking the full video coverage next to make sure you're making the most out of your Envim experience.

[music] >> Hi. Welcome to another video. So, a new coding agent framework, or rather, a massive configuration for one, is being talked about, and I thought we had to talk about this as well. This one is called Oh My Open Code.

If you live in the terminal, the name obviously reminds you of Oh My Zsh, and the concept is basically the same. It takes the vanilla Open Code CLI and injects it with a ridiculous amount of steroids, plugins, and configurations. The problem we have right now with AI coding tools, whether it's Cursor, Windsurf, or the standard CLI agents, is that you are usually locked into a mono-model workflow. You pick one brain.

You're either driving with Claude Opus, or you're driving with GPT 5.2. But if you watched my reviews on those models, you know they have very specific strengths and weaknesses. Gemini 3 Pro is an absolute beast at front end, but it tends to hallucinate logic in complex back ends. Opus 4.5 is the king of overall coding, reasoning, and debugging, but it burns through your wallet if you use it for simple documentation lookups.

And GPT 5.2 is great for architecture, but gets weirdly stubborn about formatting. Usually, you have to manually copy-paste code between them to get the best result. Oh My Open Code tries to solve this by acting as an orchestrator. It treats your main agent not as the coder, but as the engineering manager.

They call this main agent Sisyphus, which typically runs on Opus 4.5. Instead of doing everything itself, Sisyphus delegates tasks to specialized sub-agents running on different models. If it needs to build a UI component, it spins up a front-end engineer agent that uses Gemini 3 Pro. If it needs to read documentation, or search GitHub for implementation details, it calls a librarian agent running on Sonnet 4.5.

If you need a sanity check on architecture, it pings an Oracle agent running GPT 5.2. It runs these asynchronously in the background. So, while one agent is writing your React components, another is figuring out the database schema. It also addresses a massive pain point I have with current agents.

They are lazy. They love to write comments about rest of code and quit. This tool has a to-do continuation enforcer that forces the model to finish the file before it's allowed to stop. Plus, it gives the agents access to LSP, language server protocol, so they can actually run their own diagnostics and fix syntax errors before they even show you the code.

Now, a bit of a reality check here. This isn't a magical free tool. Since it orchestrates multiple models, you need access to the APIs or subscriptions from these providers. You can possibly also use things like OpenRouter or Requestly, I believe.

If you want the full dream team setup, you are burning tokens across Anthropic, Google, and OpenAI simultaneously. It claims to save costs by offloading simple tasks to cheaper models like Haiku or Flash, but the setup complexity is definitely higher than just installing VS Code. It is very much a tool for power users who aren't afraid of a config file, but the potential for productivity is huge. So, I set it up to see if having a team of AI agents is actually better than just having one really smart one.

Now, let me show it to you in action. First, to install it, you'd have to run the bunx Oh My Open Code install command, and it will ask you questions about if you have subscriptions for things like Claude, Gemini, GPT, et cetera, and it will get everything set up for you. You'd have to authenticate Open Code with the subscription if you use them, otherwise, you can use the APIs as well. For Google Gemini, it is kind of cool because it uses the anti-gravity rate limits, which can often be more generous.

Anyway, it will get some MCPs, or model context protocols, along with context seven, web search, and grep MCPs set up and configured. These don't always require additional APIs, so that's good. Now, you can just go ahead and start Open Code, and you should see the Sisyphus agent. This is where you can give it your prompt, and it can do the task.

You generally don't need to tell it to use some specific kind of sub-agent, as it will automatically detect and use the sub-agents it can. You can also change the main Sisyphus model to use something other than Opus if you prefer. All right. Let's ask it to do something, and have a look at how it all works.

So, I'm starting in the Open Code terminal here, and you can see it's currently set to Sisyphus Claude Sonnet 4, but I want the full power of Opus. So, I'll hit \{{}slash} models, search for Opus, and select Claude Opus 4.5 latest Anthropic for Sisyphus. That's the brain we want running the show. Now, I'll type in our benchmark prompt.

Build me a movie tracker app that uses the TMDB API. Make sure it uses a minimalist aesthetic. It should also have a git tracker like view to show how many movies one has watched in a year. You see that little Oh My Open Code banner flash by.

That means Sisyphus is on steroids, as they say. Immediately, Sisyphus starts thinking. It breaks down the request. TMDB API integration, minimalist UI, and a git-style contribution graph for tracking.

It realizes this is a complex, multi-step task involving front-end UI/UX, an external API, and multiple components. Its plan is pretty detailed. It starts by reading files like package.json, app/page.tsx, app/layout.tsx, and app/globals.css. This is critical for understanding the existing project context.

Then, you see it call OMO agent with sub-agent type librarian. The prompt explicitly asks the librarian to research the TMDB API for authentication, key end points, rate limits, and response structures. Notice the run in background equals true flag. This means our librarian agent is now off doing its homework, and Sisyphus can continue planning without waiting.

This parallel processing is a huge win. While the librarian is busy, Sisyphus continues refining its to-do list. Delegate UI/UX styling to front-end UI/UX engineer. Now, watch what happens.

It starts writing some initial TypeScript types like watched movie and TMDB response, but then, bam, a background task completed notification pops up for the TMDB API research. This is the librarian finishing its work, providing the necessary context. Sisyphus immediately incorporates this. It also detects some unnecessary comments and lint issues, which is thanks to the configured hooks and LSP integration.

It goes through types/movie.ts, lib/tmdb.ts, and lib/useWatchedMovies.ts, cleaning up comments and fixing small errors. This shows it's not just dumping code. It's actively refactoring and applying best practices. It then proceeds to create the core directory structure using simple mkdir commands.

After that, it gets to work on the actual components. It creates movie search, movie card, watched movies list, and contribution graph components. However, a small error pops up. Cannot find module movie card.

This is where the LSP really shines. Sisyphus sees the error immediately because the TypeScript language server is running. It then self-corrects, going back to components/index.ts to fix the import path. It also had an unused variable I error in contribution graph.tsx, which it identifies was likely due to a race condition during concurrent file writes, and it fixes that, too.

This shows remarkable resilience and error recovery. After the components are in place, it updates the main app/layout.tsx changing the metadata title to movie tracker and adding a more descriptive description. It then writes app/page.tsx integrating all the newly created components into the main layout. Finally, it realizes that for the TMDB images to work, next.js needs specific configuration.

It reads next.config.ts, creates a .env.example file with the placeholder API key, and then modifies next.config.ts to include the images domain configuration for image.tmdb.org. Then, the delegation happens. You see Sisyphus explicitly say, "Now delegating UI/UX polish for the minimalist aesthetic to the front-end UI engineer." This is our Gemini 3 Pro agent taking over the visual styling in the background. While Gemini is doing its thing, Sisyphus kicks off the npm run build command to verify that the core application compiles successfully.

And just like that, the build completes. The movie tracker it generated also looks really unique and good in itself. So, what are my thoughts? First, the good stuff.

The dynamic delegation to specialized agents is genuinely awesome. It's like having a miniature dev team. Opus handles the high-level planning and back end. Gemini tackles the front end.

Sonnet does the research. It matches tasks to the best available models, which theoretically should give you better results and more efficient token usage. The background task execution is a game-changer, allowing actual parallel work. And the integration of LSP for real-time error checking and the to-do continuation enforcer are crucial for making these AI agents truly reliable.

It means less babysitting and more confidence in the output. The fact that it caught and fixed its own module import error, and even a potential race condition, is impressive. However, it's not a perfect silver bullet. While it delegates, the cost still scales.

You are running multiple frontier models, so your API bill could add up faster than with a single, cheaper model. However, if you are able to afford all the subscriptions from Claude and OpenAI and Gemini, then you can squeeze out some good results. I think that careful consideration has been put into the token usage aspects of it, it, it, and it is recommended that you run it with subscriptions. I think we could plug in things like GLM and stuff.

Let me know if you guys want a tutorial on how to edit model configs for it as well. So, there's that. Overall, it's pretty cool. Anyway, share your thoughts below and subscribe to the channel.

You can also donate via super [music] thanks option or join the channel as well and get some perks. I'll see you in the next video. Bye. >> [music]