opencode tutorial

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.

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.

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.

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.

Hey guys, welcome back to another new exciting video. This is another free AI coding setup that we will do and here we will do the setup with the Claude code and MiniMax M2.5 free model with the help of open code because inside open code you will see that MiniMax M2.5 are free to use. And why MiniMax M2.5 model? Here you see if you go to their blog post of MiniMax M2.5, they have compared this model with the Anthropic Claude Opus 4.6 and also Claude Opus 4.5.

And from this SW bench verified and also SW bench Pro and terminal bench 2, you can see that it has almost same kind of capability like the Opus 4.6 and 4.5. So that's why this model has a lot of capability to fight with this Opus 4.6 or 4.5. Okay. So how to do this setup?

First of all, if you are new to this channel, don't forget to follow me on Twitter. This will help you a lot to get all of the instant news, instant notification. And also, please follow me and please subscribe me on Code Dizzy YouTube channel. Okay.

So let's start the video step by step. First, go to this website opencord.ai. I have given the link in description and here you will find this NPM comment. So just copy it and open the terminal or comment prompt and run this.

And here you see that it will add some packages globally. After that, open code will be installed in your machine. And after that, what you need to do that open the CMD. Let me open that.

And here just write open code. Okay, open code. And press enter. Now you will see that it will start the open code CLI.

Okay. Now here we will do the API connection setup. So how can you do that? So for that, uh here you see that Jane option, okay?

You will see that Jane option. Go to this Jane and here you will find this login option. So, just click on this login and after that you will find this kind of page. And here on the left-hand side you will find this API keys.

So, just go to this API keys tab and here you will find this create API key. Click on that and here give any name, ABC. And after that click on this create. Now, you will get one API key and here you see that I have um this I have created this API key, Open Code Cloud.

Okay. Now, copy this API key. Uh it will be needed to do the setup with Cloud Code. Okay.

And also I will use this API key inside the Open Code. Now, what I will do that I will just uh type \{{}slash} and here you will find many option. You just select this connect. Okay.

And after that here you see connect a provider. Select this Open Code Jane and here you need to paste the API key. So, you can paste that API key here. Okay.

And uh let me just copy it again. And here paste it. Control V, I think. Yes.

Now, enter. So, now you see that all of these models like Big Pickle, MiniMax, M2.5 Free, Nemo Trendy Super, this model you will find it. And uh we are interested to go with this MiniMax M2.5 Free model because uh we need the same capability like the Opus 4.6. So, that's why MiniMax M2.5.

Okay. Now, we need to uh connect this with the Cloud Code. How can you do that? First of all, you need to install the Cloud Code.

There are many lot of videos you will find over the internet to install the Cloud Code. So, that's why I am not showing you that Cloud Code installation. Now, after installation of Cloud Code, you need to find the dot Cloud folder inside your operating system. So, I am using the Windows, that's why I am showing you the Windows uh that how to find the dot cloud folder.

And if you are on Mac or Linux, then please uh find that inside your machine. So, first of all, go to your user, and after that uh here you will find this dot cloud. And inside that, you will find the settings.json file. So, open that settings.json, and here you see I have already done the environment setup, and for that you need this JSON uh this environment, okay.

So, Anthropic base URL is this open code, and Anthropic model is this minimax m2.5 free, and Anthropic API key. So, the API key that you have got from the open code website, here this API key, you need to uh place it here, okay. And after that, enable tool search too. Okay, so now just copy this, and uh paste it here, okay.

Paste it here like this. Now, save this file, and after that, open your cloud code. Okay, so let me in front of you again open the cloud code, and uh let me close this session. So, CMD Okay, and here just write this cloud and and and press enter.

And trust the folder, and here I just write \{{}slash} model. And here you see it is showing this minimax m2.5 free, this custom model. Now, I'm selecting this, and press enter. And you will see that uh it will uh select this model, and uh it will use that.

Now, if I just write hi, and you will see that this model is also pretty fast, and you will get the fast response. So, it is uh responding here. So, if I just uh write again here, and press enter. And you see that you.

So, uh you can easily uh communicate with this uh cloud code with the help of Minimax M2.5 free with the help of open code. Okay. Now, another thing is that many of you gets confused whether there is any limit inside open code for this free model. So, I personally have not got any kind of message from open code that you have hit the free usage limit or your limit got exceeded.

But, on internet I have searched and I've found that there is a 16-hour cool down's a limit for the free models and you will get this kind of message free usage exceeded. So, any of you guys have faced this kind of issues previously with open code, please let me know in the comment section. So, other users also will get benefited will be benefited from your contribution. Okay.

So, please put a message in comment section. So, this is the procedure guys and if you found this video helpful and if you want to get this kind of videos more, don't forget to subscribe this channel. Don't forget to like this video also. See you guys in the next video.

Thanks for watching. Bye-bye. Take care.

My name is David Andre and here is how to build anything with open code. Now, this might actually be the cloth code killer because open code is currently the fastest growing coding agent in the world and as you can see on this chart, it just became more popular than cloth code. It's also completely free, works with over 70 different AI models, and you can choose any LLM provider you want. So, in this video, I'll show you how to set up Open Code, how it compares to Cloth Code, and how you can build anything with it.

So, if you want to be at the cutting edge of AI coding, watch until the end. Now, as you can see, Open Code has been blowing up recently. In the last 30 days, it went from popular to super popular. So, let me show you how to install it.

First off, go to opencode.ai, which is their main website. Now, you have multiple different ways to install it through a terminal, but the curl command is the most general one. So, just click on it and copy open terminal. Boom.

And all you have to do is just paste in the curl command, hit enter. This is going to install the latest version of Open Code. Now, as you can see, I had 1.1.10, and now it updated to 1.16. Now, it's very important that you have the latest version because this comes with some pretty big updates, but more on that later.

Now, after install finishes, the next terminal command we need to run is open code of login. This will let us select which provider we want to use. And just to show you how many there are, let me go through them. Yeah, you can see that open code really does offer so many different ways to use it.

Which means that if you have a subscription with one of these or if you have API key from any of these, you can use open code at no extra cost. This is completely open source. It's free software which makes it much more appealing than close code. Now, because I want to show you a lot of different models, I'm going to use open router and then it asks for API key.

So, go to open router.ai, create an account, takes 20 seconds. Go to top right, click on keys, then click on create API key. I'm going to name it subscribe. If you're watching this and if you want to see more AI tutorials, make sure to subscribe.

Takes 20 seconds and it helps out a lot. Okay, let's click on create and let's copy this API key. Let's go back to the terminal and paste it in. Boom.

Enter. And just like that, the setup is complete. It's literally that simple. Now you can use open code straight from the terminal but it always helps to have an IDE to kind of see what it's building right so I'm going to open an empty folder right here boom project and I'm using cursor but you can use VS code win serve anti-gravity doesn't really matter let me open the terminal right here and I'm going to type in open code and just like that boom open code is launched cool the first thing is setting a model you can do that by typing /models now remember we're still in the terminal so this is a CLI app but look at the UI very intuitive very nice so since we're using open router we can use any model on there which is basically every model But right now, Clo Opus 4.5 is the best.

So, let's use that. And the first thing I want to show you is oneshoting a 3D game. So, I'm going to paste in a prompt. Create a 3D endless runner game using Vanilla TypeScript and 3JS.

Then it explains the structure of the folders, features, player controls, and glowing cube that dodges incoming obstacles on a procedurally generated neon create road. So, this is a full 3D game, okay? This is not a simple, you know, single file HTML website. This is a legit project.

Now, let's see how open code handles this. First, it creates a to-do list, right? list of tasks that it's going to do. So, it doesn't jump straight into writing code.

It first thinks and creates a list of to-dos on how to best accomplish this goal. Then, it created a directory. So, it run command. And look at the UI, guys.

There's some people think that open code is even more polished than close code. But man, look at this. Very clean, very separated colors when it makes sense and also fast. On top of that, you see the exact amount of tokens in the top right as well as the percentage of the context window and the current cost.

Let's scroll down. As you can see, it marks the to-dos as complete one by one when it completes them. and highlighting anything instantly copies it to your clipboard. These little details really make or break these tools.

Open code is very polished. It's very clean and unlike close code is fully open source. So you don't have to be afraid of them collecting your data or not knowing what's the inner workings of it. You can literally go to the open code GitHub and go through all the files yourself.

Check out what's inside forkit. Build your own version of open code. Whatever you want to do with it. All right, let's see how the game is going.

still building and you can see even even the bottom left very nice UI like the loader animation to show you that the agent is still working. Okay, we're on the last to-do now. All files have been created. Let me verify the project compiles correctly.

It does npm install. And by the way, I'm in build mode. I didn't have to approve a single thing. You can switch between build and plan by simply pressing tab.

And if you're in build, the agent is very autonomous, very powerful, and requires way less input than cloud code. So let's see. Test server. Okay, server start.

And boom. All right, it's done. Took 3 minutes. Single prompt.

Let's see if it works. npm install and npm rundef. This is the command. So, let's highlight this.

And again, it autocopies to the clipboard. So, I'm going to do Ctrl +V to paste this and hit enter. There we go. Here we have our local host URL.

And here we are. No errors so far. Okay, incoming projectiles controls work really well, guys. This is a single oneshot prompt and we have a 3D game.

What if we crash? Let's see. Okay, crashing doesn't Oh, it works. Okay, beautiful.

Game over. Restart. Not bad. And again, single prompt.

So, we could work on this. We could add different camera angles, different obstacles, multiple levels. Yeah, not bad at all. But if you think this 3D game is crazy, just wait until you see what's coming.

Now, before I show you more open code features, let's talk about the recent drama which caused Open Code to get worse, but also get better because it blew up. Let me explain. Few days ago, Enthropic, the company behind Cloed third party apps, including Open Code, from using the cloth credentials. So before you could use your claw subscription inside of open code which was stealing away from users from cloud code.

Now this is a very aggressive move from entropic and it also tells you how valuable these models are to other companies. Simply put everyone wants to use enthropic models right now. Even XAI the you know creators of Grog were using cloth opus 4.5 to help them build software but Enthropic also shut that down to prevent competing AI labs from using cloth to build their own software and their own models. However, this move by Enthropic quickly started to backfire.

Then the team behind Open Code pivoted quickly and they partnered with OpenAI and GitHub so that people can use these subscriptions inside of Open Code. So if you're paying for CIGBD Pro or CIGD Plus, you can use that subscription in Open Code for free to use models inside of Open Code, which again this is a huge danger to the popularity of cloth code. And this goes to show just how ruthless and competitive the AI field is getting. Now, for the second build I'm going to show you, we're going to be using Gemini 3 Pro and we're going to build a CRM dashboard for email campaigns.

And again, I'm going to try to oneshot it with open code. So, open the terminal again. Type in open code. And first off, let me change the model to Gemini 3.0 Pro.

There we go. I'm going to paste in my prompt. Build a CRM dashboard for email campaigns using React, Vite, and Tailwind. So, again, we describe the structure of the codebase, then the features.

So, this is not a single feature. This is a full CRM that we're going to try to oneshot with Open Code. And again, I want to stress this. This is a single pro, right?

In the previous one, we didn't run into any errors, no issues, one prompt, and it was a full working 3D game. Now, we're trying more of a business application, a full CRM dashboard. So, let's see if Open Code can handle that. And of course, since Open Code is a CLI tool, you can just open another one.

Open code. Boom. And we can have two Open Code agents running at the same time. And just to compare the UI to cloud code, let me load up cloth.

Boom. So, again, even that one confirmation step where you have to give it access to this folder, it's annoying, right? So cloth cloth code is very optimal UI, very clean. It pioneered a lot of this.

It invented a lot of this. But open code I feel like it's it's more beginner friendly. It's cleaner and in some ways it's more polished and more optimized and gives you more info. For example, again you can see the tokens, the percentage of the context window and the cost in clo that's not possible.

Even this is a custom status line that I had to build myself to see the model and to see the git branch and the time. I had to create it myself. It doesn't come by default in cloth code. But all of these things that I'm showing you in Open Code come by default.

All right, again 3 minutes almost the same time as last time and Gemini 3 Pro is finished. So let's see if Open Code managed to oneshot this application. So again, we get clear instructions on how to run. So let me copy this.

And again, highlighting only copies it like such a quality of life. Simple highlighting automatically copies that text, man. Amazing. Boom.

Let's open our app. Here's our CRM. Okay, no errors. First try.

Let's see if the contact page works. Add contact. Testing agent zero. Create contact.

Okay, contact was added. Let's see if we can delete Alice. We can. Nice.

Campaigns. Let's see the campaigns. New campaign. Man, all the features work.

Let's see the analytics. But not bad. Personally, the UI feels a bit vibe coded. So again, we could use Gemini say like go over the entire front end and make the UI more unique.

Notice the details. Open code shows you the model and it shows you the provider. Stuff like this is just quality of life. It saves seconds when building.

But if you're serious and if you're building a lot of software with multiple agents running, you want to know which Open Code instance is using which model, which provider, stuff like that. And you can see the thinking blocks are a bit less uh visible, less opaque, which makes it very clear of what is internal thinking of the model and what are the changes that it makes. And by the way, this is the default theme. If you want to change the theme, just type in slash theme and open code has very wide selection of different themes that you can choose from.

For example, the matrix one is going to make you feel like you're in the matrix. So you can customize this a lot. Cloth code has like a couple of themes, but everybody uses default one. Open code is built from the people at Neoim.

So they know how to use terminal. They know how to use CLI tools and how to build them and how to make it as polished as possible and as customizable as possible. All right, let's see how these changes look so far. Man, much better.

This is way more unique, right? This doesn't look like a vibe coded default, you know, blue buttons. This has some personality. It has that CLI feel.

Very nice. So, yeah, Jman i3 is really good at front end. But again, this is only the second build. In this video, I'm going to show you five different apps that Open Code can build.

And so far, it's been able to oneshot the first one and the second one. So let's see if open code lives up to the hype and if it's actually better than cloud code, cursor and codex. Now let me clarify what open code actually is because people are getting confused since there's new AI tools coming out every single week. And especially if you're new to AI, you're not sure which tool does what and or when you should use each of these tools.

So Open Code is an AI coding agent. It runs in your terminal aka CLI command line interface. But they also have a desktop app which is more beginner friendly. And since it's a powerful coding agent, it can execute multi-step tasks across your codebase.

But it's not a full IDE like cursor. It's not a full ID like VS Code or anti-gravity or Windsurf. It is a coding agent. So once again, think of it as cloud code that is open source with more AI models and with no restriction on what provider you're using.

But let's go deeper. Let's actually compare it to clot code which probably is the most popular coding agent of all time. And I feel like I can speak confidently on this issue because personally I have well over 500 hours inside of Cloud Code. I made dozens videos on it.

I've been using it since day one. So if there's somebody who knows Cloud Code, it's me. So let me show you how Open Code compares. Now first off, both of them run in the terminal.

Both of them are coding agents that are in the CLI. But that's where the similarities end. Open code unlike OpenAI is actually open source with a MIT license. Cloth code is closed source.

There are some things that Enthropics has released, but closed code is closed, open code is open. This is huge if you care about privacy and security. Open code also supports over 70 different AI models. Anything from OpenAI, Gemini, Enthropic, XAI, Deep Seek, Kimmy, GLM, so many different models, closed models, open models, everything basically.

Well, closed code only supports cloud models, right? Because it's made by Enthropic. Also, there's a big difference between open code and closed code. With Open Code, you can use GitHub Copilot as the back end, as the service, right?

And that only costs $10 a month and you get 500 premium requests. This means it's very cost- effective compared to Cloth Code. Close code, while it has some extra features, is way more expensive, right? Most people are running either the $100 a month or the $200 a month plan in Cloud Code, which simply isn't affordable for most people.

And these extra features, they're coming fast. The Open Code team is developing quickly because of the fact that it's open source. the entire open source community can contribute and improve the project much faster which creates a very interesting dynamic of like enthropic against the whole world which is a tough battle for cloud code to win. So to summarize open code gives you all of the main cloud core features for a fraction of the cost plus it's open source.

Now let's go to the third build idea which again I'm going to try to oneshot with open code but this time we're going to use GPD 5.2 to Codex and I'm trying to show you that really you can use any model you want instead of open code which is one of the main selling points. This time we're going to do something very different. We're going to do a TLR/PF Photoshop clone for the web. So this is like image editing uh you know mirror dashboard drawing board.

You'll see I'm going to change the model to GBT 5.2.2. Okay, seems like GBD 5.2 CEX is not available on Open Router. So let's do /exit to exit the open code UI and we're going to try to login with my CHBD subscription. So again type in open code of login.

We're going to select open AI as the login method and you have two options. You can either use API key or you can use your CHD subscription which a lot of people are paying $20 a month for CHD plus or $200 a month for CHVD Pro which again makes open code completely free for you. So let's hit enter. It's going to redirect us to this website.

Let's open that up. Okay. Authenticator. As always, make sure to use TFA, guys.

Don't be sloppy. So, I have two options. Either use my workspace or personal account. Let's use personal account because I have the $200 a month JGBT Pro subscription.

So, let's use the best possible subscription. Now, we can return to open code. And we're done, right? Let's do clear open code.

And we should be logged in through OpenAI. Still says open router. That's weird. Let's do models.

I think that's a bug. But now we can use GBD 5.2 Codex. There we go. You can see that we're in OpenAI.

I think it remembers the Open Router. Oh, yeah. Because it's selected from before. There we go.

Now it shows OpenAI as the provider. Very nice. So, we're using GBD5. Codex, which is the best coding model from OpenAI right now.

And I'm going to paste in the prompt. Boom. Build a web-based drawing and design editor using React V CSS and Convjs for canvas rendering. Again, structure description of features.

And this is how your prompt should be if you want to oneshot apps, right? So this prompt, it's not short, but it's not super long either. It's like medium length, single paragraph with clear description of the text tag, of the build idea and the features. So if you want to build as fast as possible and if you want these coding agents to actually oneshot your apps without running into endless errors, feel free to pause the video and make sure to structure your prompts like this.

All right, so first again creates a list of to-dos. Then it checks the current directory, sees that it's empty, creates the necessary subdirectories. There we go. Writes the first file package.json.

JSON then it writes the V config moving very fast. GB 5.2 CEX is very fast. And since I already have the GBD Pro subscription, this is running for free for me. There's no extra cost, right?

So if you're already paying 20 bucks a month for GGBT or $200 a month, start using open code. You don't have to pay for cloud code. You can just use your subscription and leverage it in more ways because let's be honest, most of us are not hitting the limits. You know, this is not 2023 when GBD4 limits were super small and we were hitting it every two hours.

It's the big 2026 like limits are high. So we want to make sure we squeeze the most out of them and we run multiple coding agents in parallel leveraging our existing subscriptions instead of paying lots of money to enthropic which u yeah often times is not going to the best uh pockets. Okay so you can see that GBD5.2 codex is moving very fast much faster than Opus and Gemini 3. Let's see the total time if it's going to be around 3 minutes as well or if it's going to be faster.

And if you don't like something again, you can fork it. You can build your own version or you can do a PR to the official GitHub repository suggesting a certain change. And if your idea is good, the team will likely accept it. And notice in the top right, $0 spent because I'm using my existing subscription.

Man, amazing. Another benefit of using open code overload code is that you have single interface for all your models, right? So if you wanted to use the native CLI tools like Gemini CLI, cloud code, codec cli, all of these look completely different. All of these have different slash commands, you know, different tools.

Open code, you just get used to one tool. You pick your theme, you do slash init. Okay, that's another thing. If you start in a codebase that is existing, start with slashinit.

This will initialize the agents.mmd file. So it will analyze every single file and learn your codebase and put everything into agents.mmd. If you don't know what agents is, this is a convention that is like a readme file for agents. I think it's developed by OpenAI originally, but I think they gifted it to the Linux Foundation if I'm not mistaken.

Yeah, it's under the Linux Foundation and it's adopted by a lot of different tools including Open Code, but of course cloud code doesn't adopt agents.md. So all of these tools, look at them. Jules, Goose, Ader, Windsor, Warp, AMP, Root Code, GitHub, Copilot, Codeex, Kilo Code, they use the agents.mmd file. What that means is that inside of your codebase, actually, let me show you.

Let me just show you in practice, right? Let's launch a second open code agent. Boom. Let me put it up.

And I'm going to do slashinit. Enter. And it has this pre-prepared prompt, which is very nice. Please analyze this codebase and create an agent.mmd file containing number one, build lint test commands, especially for running a single test.

Number two, code style guidelines including imports, formatting, types, naming conventions, error handling, etc. This prompt is really good guys. Take note. The file you create will be given to agentic coding agents such as yourself that operate in this repository.

Make it about 150 lines long. If there are any cursor rules in that cursor rules or cursor rules or copilot rules, make sure to include them. If there's already an agent.mmd, improve it if it's located in root. Very nice prompt, concise.

Great job to the open code team for writing this. And as you can see, open code begins analyzing the entire codebase. Listed out directory. check out all the files and starts reading them and learning about this project and then it will create this agents.md file which more and more coding agents use.

So if you don't have an agent.mmd file, what are you doing? This is a super fast way of improving the performance of nearly every coding agent out there on your codebase. This is probably the difference why like a lot of beginners don't get the power out of AI while people who know how to prompt it, know how to use it do get the power because they have stuff like ages.mmd file. Now, Codex is still going, not because it's slower, but because it's probably overthinking like look how many changes it's doing, right?

It's writing so many files, so many things. And this is very uh this is very iconic of GPD 5.2 CX. It's a model that likes to think a lot. So, this is both good and bad.

If you're fixing something that is a problematic bug that you've been battling for hours or days, GBD5.2 CEX will put in the work. it will reason for 10 15 20 minutes which again opens or gemini do not do but if you're trying to build something quickly like I'm right now it's can be a bit annoying because GPD codex models have a tendency to overthink it's almost done and you can see how the second open code agent is running in parallel so both are running at the same time and this one is building the agents MD file and it's editing it one by one it's describing the history and again this means that any agent in the future you run this is loaded as the system code and it will instantly make that agent more powerful more aware where it will give it more context about this codebase which is essential. Context is the difference between bad performance and good performance when it comes to AI agents. So this is done 2 minutes 48 to create the agents.md file.

Pretty slow I would say but look at this very nice prompt. Very very clean formatting. Wow 145 lines. So the full app took almost 7 minutes.

So longer than Opus and Gemini but let's see maybe it's impressive. Maybe it's worth it. Let's jump in install again. And we need to do npm rundev.

npm rundev. Boom. Go to local host. And here we are.

So let's uh let's see what's happening. Can we like take a screenshot and paste this in? Let me take a screenshot here. Not sure.

Okay, let's do pencil. Pencil works. Let's change the color. Maybe it works.

Very nice. Rectangles. Rectangles work. And I can move around.

Okay. I can zoom in and zoom out. Let's do ellipse. Ellipse works.

Opacity. Let's do lines. See how good lines are. Okay.

Lines work as well. Let's do text. Let me change this. Not sure if we can change the text.

Export as PNG. Let's export this as PNG. Download this to the same folder. Nice.

We can actually export this as PNG. Not bad. So, obviously, this is not as advanced as Photoshop, but again, one shot, no editors, and it's a simplified version of TLJ. And we can see the layers right here.

And we can like log, unlock, up and down, do a lot of different changes that you could do in something like Photoshop. So, this is interesting because uh TL Draw doesn't have these layers. So, it already has one more feature that the draw doesn't have. And again, it's not as polished, but again, it's one-shoted, no errors, super impressive.

Open code free for free so far. There's two more to go. Let's see if it can keep up 100% oneshot rate with zero errors. Now, let's talk about what makes open code really appealing.

And a big part of that is the CLI experience. So, the terminal UI is generally impressive. This is what it looks like in the default theme. And again, they have like 20 30 different themes.

The CLI includes automatic prompt summarization, to-do lists, desk notifications. It's really, really good. Maybe even better than cloth code, honestly. And of course, just like in cursor, just like in cloth code, there's plan mode and there's build mode.

So, you can switch with tab. You don't need to do shift tab, just tab to let the agents try first. Really good tip for VIP coding. And the reason why the CLI experience is so good is because it's by past Neoim team, right?

So these guys know how to code. They know what the terminal, how to use the terminal, what it should look like, what a good interface for console should look like and it tells. Another benefit of open code is that it supports agents.mmd. This is a convention that was started by OpenAI, but clot code doesn't.

Right? So I already talked about this, but cloth code still doesn't support agents.md. Open code does. If you wanted to have global, it needs to be in the root of your computer.

If you wanted to have per project like I showed you earlier, it needs to be hgn. MD and just do slashinit in the project and it will create it by itself. But make sure to do the slashinit. Do not forget that.

If you're starting from a scratch, it's not as important, but if you were going to use open code on your existing codebase, definitely do so. So now let's get to the fourth build idea, which I'm going to use GLM 4.7, which might be the best coding model that's open source right now. And we're going to build an encrypted and private file manager software which is something that I actually need for myself because u as the world is becoming more centralized and governments and companies want more of your data. We should be very careful what we upload online because basically anything can be used against you since every country has like tens hundreds of thousands of laws.

Nobody knows what they are. Having your data encrypted and private is a really good idea. So we're going to build this. We need to type in GLM4.7.

There we go. Through open router. And as you can see, it remembers the sessions, right? So it remembers the connection to open router and it remembers the authentication to open AAI chd subscription and you don't have to like reoff every time.

It's very seamless to switch, very clean. Yeah, very convenient. So let me paste in the prompt for this one. And actually, let's start with plan mode.

Plan mode sometimes asks you questions which is very helpful to get more context. A lot of you are making the mistake of of not giving the AI enough context. And that's why you don't have the same results as me or other people who are building super fast with AI and who can actually build production ready apps that grow into real serious startups is because we know how to provide context. Right?

So as you can see, boom, it asked me six questions. So here are my answers. Boom. I'm going to do Ctrl J to go new line.

Value location should value keep it simple. Default to out vault. Number two, file naming. Keep original names remain until locked.

Number four, override behavior. Yes. Number five, recursive direction directory support. Should add support directories.

Let's do single files for now. Number six, backup strategy. Not needed for now. Let's keep this a quick and dirty prototype.

I really like that word. much better than MVP. Now, get to work and make this happen and build this app like a 10x engineer would. Boom.

Press tab to switch to build mode and enter. And let's see how good GLM 4.7 is. On some benchmarks, it's similar to Sonet 4.5, which is the second best model from Entropic. Uh, probably won't be good as Opus, but let's see.

Well, well, well. So, here we are. Uh, I quickly went to the gym and I'm back. But we seem to be stuck.

So, I'm going to escape. This is how you interrupt, by the way. You need to press escape twice, which is also better than close code. In closed code, you need to do it once and sometimes you hit it by accident, which is annoying, right?

So, I say, uh, what is the state? What happened? Now, I'm not sure if it actually ran into errors that it couldn't solve or if it's because I left the computer and went to the gym and, you know, it went to sleep. So I'm not going to quite dismiss it saying that it failed one shot because it might not be fair.

The user is asking me what's the state. [snorts] Let's see persistence issue. So it's trying something. Maybe it's not the best idea to use the least powerful model out of these because like Opus 4.5, GPT 5.2 CEX and Gemini 3 Pro are all better than GLM 4.7.

But again, GLM 4.7 is fully open source, more like open weights, right? the other three models are not. So yeah, maybe it's maybe I should have given the hardest build idea to the best model. But let's see if GLM4.7 fixes this, then it's going to be real impressive.

Not only on the model, but on open code as a coding agent, just giving it all the tools necessary and the prompting and the scaffolding to let the models cook. People don't realize the value of a good coding agent isn't just the model because you can have GLM 4.7 and you can just run it, you know, by the direct API call and it's going to work fine. But if you use it inside of open code, it's going to be probably a lot better because open code gives it the tools, the prompts, the environment to let it do its thing and it's goes in loops until it figures that out. So yeah the it remains to be seen what is the value of AI agents uh like against each other you know whether cloud core or or open code in a year will be much different or whether they'll be basically same because oh permission required I'm not running that command I am not running that command that is very risky I'm going to reject that and actually I'm going to rerun the idea uh in a new open code.

So there is two feces I can say model. I'm going to do opus and it remembers the recent models. Wow, this is amazing. This is such a quality of life.

If you use wind surf, oh my god, hopefully they fixed it. I used wind surf a few months ago. You had to retype the model from scratch. It's so bad.

All right, so I'm going to give it this. I will say first analyze the state of the project then finish it like a 10x engineer would because we already have something you know we have SRC we have virtual environment but yeah the speed of software development is uh decreasing so like the the gaps are decreasing the speed is increasing and within 12 months it'll be like you know one prompt literally seconds to implement whole features so if cloud code implements something that people Open code is going to have it the next day or within a few days at most. Same thing vi vice versa. But there are some things you cannot change such as the privacy first approach, right?

I mean this is why people love agent zero. It's locally runnable. It's open source. It's free.

It's privacy first. It's security first. These things you cannot change, right? Enthropic is always going to be closed source.

Enthropic is always going to train on your data. Enthropic is always going to do the best interest for the Silicon Valley crowd. Open code is open source, right? It's in the name.

I mean, okay, it's in the name. That's not the best argument because OpenAI used to be open source and it's also in the name, but hopefully open code stays open source forever. But my point is that like the features and the speed of change can change, but the underlying print principles will not change. Closed code will likely always be closed source and will always collect your data and train on your data.

So I I think these things will become more valuable in the future. The the underlying foundations that cannot be changed. We have some questions. Okay.

And this is this is different rather than like Yeah, I like this. So before it asks me questions that I have to manually respond to, but now this is like the way Claw does it, right? Where you select the ones that seems good. Okay, keep it.

And then we do confirm. Beautiful. Yeah, I really like this way of input. Rather than like having to type it, just multi select.

Okay, so now we need to give it the go ahead. get to work and make it happen. Now, one thing that I will say about clot code, it's really good, is the prediction. They added it recently of your next prompt.

So, see, look at this. The first thing cloth asks you is if you want to send more data to Enthropic. You're already sending them data and they're like, "Do you want us to train on your prompts?" No, I want you to train on my prompts. [\h__\h] I'm paying $200 a month, stupid.

And you but anyways do you see this? All I have to do is tap and it's like predicting my prompt. Uh I don't know why it's not working. Try write a test for file path.

Hey okay let me send something but this is a really good feature inside of cloud code. I say yes there you go. You can see it predicted my prompt. All I have to do is press tab and it writes it there.

This is a very useful feature that I would love to see in open code or in other tools because a lot of the time it's not correct every time but like I say 60 to 70% of the time it actually predicts the next thing you want to do and again saves you 10 20 30 seconds having to type the prompt which compounds quickly given how good and how fast the AI models are. So here we are in open code. It's still running into some errors but we're using a better mold now. So let's see if it does it.

We can probably uh like this is a fail like I'm not running this that vault. That's crazy. Um I'm yeah I don't know what's in this folder. I don't know if it's a new folder here.

It's not in this project directory. This is a global on my MacBook. That would be very risky to run a remove command. And this is a recursive deletion.

Uh that's yeah that's bad. Don't just auto accept commands from AI agents. Okay. And this is another benefit of agent zero by the way.

It runs in a docker container. So it wouldn't [\h__\h] you up like this. Okay, so Opus is suggesting the same, but I really don't like that. Um, uh, these RM commands are super risky.

How can I be sure this is safe to run? Is the vault folder used for anything else in our MacBook? Pink harder. Answer in short.

Use terminal. You use save terminal commands to triple check answer in short. I'm not doing this. Can I open that vault in my MacBook uh finder?

I really don't like these recursive deletion commands. Oh [\h__\h] What the [\h__\h] I didn't know open code could do that. It can open your finder like that. Wow, that is pretty good.

I mean, it's just a terminal command, so maybe I'm just u not educated on terminal commands, but I didn't know it could like do that. Well, this saves a lot of time. Okay, sometimes in cursor you have to like click and like show in u reveal in finder and stuff like that. Well, damn, this is good.

This is good. I'm impressed by open code that vault folder. Where is it? In David.

Okay, so it's hidden folder. Open it again in Finder. And I want to see that again. This is fast influence on Opus, by the way.

Did they improve it? Metadata. Okay. All of this was created now.

Looks safe to delete. Try again. Try it again. There we go.

That vault and echo cleaned up. Okay. Allow once. Yes, we don't want to allow remove commands always.

There we go. End to end test code secret test content 34 creating new encrypted vault. So opus is doing better than GLM as expected. All right.

I'm not sure how we're going to test this one because it's there's a issue consistency problem is that save will generates a new salt infernet but the file was encrypted old format. Okay. So it's fixing some inconsistencies. The type checker is catching these errors.

See, I have no clue how the technical implementation of this is. So, what I'm going to do is I'm going to use this one. Boom. Clear.

Open code. And I'm going to say explain the technical side of this project. How does it actually work? Be concise.

I'm going to switch to plan mode so it analyzes more files and reads it. And by the way, this is how I actually build. I have one agent that's the builder, the coding agent, and I have one that's like more of an adviser, more of a consultant that explains things. And I really try to upskill myself.

A lot of you guys are just using AI to build [\h__\h] for you, and you're not improving yourself. That's a huge loss. The best thing is, as the AI is exponentially improving, is to also exponentially improve your skill set. Change password.

Verify file decing the RM command. All commands work. Okay, nice. So, it updates the to-dos.

very nice and seems to be good. Even though it ran into some errors while building it, it managed to self fix them. This is really nice about open code is like it doesn't give up too early. The hardness is really good.

All right, so let's see. Okay, what is this? Encrypted file CLI tool let you securely store retrieve files using as 256 encryption. Okay.

Architecture user CLI vault class crypto vault encrypted files worker modules. How encryption works. All right. This is beyond the scope of this video, but all right.

How do I test it? How can I actually test this myself with some files? Give me step by step. Answer in short.

I'm going to give it some bigger file. I don't know how long it takes to encrypt. Maybe one of these video files. Okay.

Like half a gigabyte. Check the files. I added 500 MB MP4. Is this good for test testing or will this take forever?

I don't know if the encryption or decryption is slow. So, we'll see. Yes. Give me step by step how to try it with this file.

Answer in short. I don't know why it's scared. I mean, worst case scenario, it's going to take 30 seconds like it said. Doors.

Okay. And again, I'm going to show you the beauty of just highlighting Never mind. I'm just going to highlight the text and it's autocopied. Boom.

Terminal. Paste it in. We have the VNV active. That's good.

Now we need to Is it no vault? Okay. We need to do password. Okay.

Confirm. Nice. Good design. Set value location.vault.

Vault. Beautiful. I like that. Now we need to unlock it.

Vault. Unlock. Password. I mistyped it.

Uh hopefully it doesn't crash. Vault unlock. Okay, there we go. It's unlocked.

What now? need to add this old add file. It has spaces in the name. That's not good.

Okay, so this is the part that's going to take some time. It's in encrypting this file. We should have probably some um feedback in the CLI that it's showing that it works or like the progress of the encryption. Okay, that's wasn't that bad.

It was like 20 seconds. Wasn't bad at all. So, let's do vault list. I need to probably decrypt.

Doesn't need to decrypt the list of files. Probably. There we go. Original path.

So, it's encrypted in the vault. This is nice. This is nice. Recover it to /temp.

We don't need to do these. Oh, do these steps. It's fine. just tell me how to clear everything up once I'm done testing so that my MacBook isn't full of test files and uh that vault uh file that vault stuff whatever I'm going to be general I don't want to finish this like halfway okay we're going to remove the vault okay this they need to fix this one thing I don't like about over code is the scrolling.

If I'm on my touchpad, it's super sensitive. Like look at this. I'm scrolling very slowly and it's like going crazy. So I really need to use a mouse with the scroll wheel.

I have no clue. In CL code, this is not an issue. CL code has smooth scrolling. So they need to fix that.

Also, sometimes you highlight stuff and it goes crazy up and down. So yeah, I don't know. Let's delete this. And that's it.

Cool. So this was the CLI tool. Most complex one so far. Took the most amount of time.

But uh Open Code managed to do it. Now, one thing you should understand is that Open Code works everywhere. It is a native desktop app, not just the CLI. I was showing you the CLI, you know, the tool for the terminal, but it has a clean desktop app.

I'm going to pop up a screenshot right here. It also has an ID extension. So, if we go back into cursor, which of course is for of VS Code. If we type in open code, there we go.

You can see it has the extension. So if you prefer using VS Code cursor and you just want to have the simplest way to install open code, maybe the extension is the way to start. And uh I like the terminal. It's the most developer friendly.

But this the desktop app is definitely the most beginner friendly. So if you want to use open code, but you're scared of terminal, just install the desktop app. It's uh very very nice. And it's almost an ID.

It's it's not a full ID, but it's getting there. It has a built-in terminal. You can change the project folder. You can change Git branches.

Pretty good. As I said, the desktop app is surprisingly nice. It doesn't require you to use terminal or know anything about CLIs. That makes it great for beginners.

But the CLI, if you are not afraid of the terminal, is one of the nicest designs and one of the best UIs out there. It might even be better UI than cloud code. There's a strong argument for that. Now, you should also know about open code Zen.

So, Zen is the gateway service from Open Code. Now, again, it's optional. Open code is completely free. You can use your JGB subscription.

You can use open router. But if you don't have any current subscriptions and you want to have something that's like price efficient and has the best models, then this could be your solution. Open code Zen. Now the best part about it is that there is no like markup, right?

So whatever the model cost is like let's say you're using OpenAI models. Well, whatever that model costs in the API, that's how much you pay on the open code. Then open code doesn't charge you extra and it's usage based. So it's not like you pay $20 a month.

You pay $20 and you get $20 worth of credits and you don't pay until you use those up. If you're paying for cloud code, you're most likely not using all your subscriptions, right? Like I I was paying for the $200 month cloud code and then I was never hitting the limit. So I downgraded to $100 a month and I'm still never hitting the limit, which means that I'm not using all the money I'm paying for.

With Open Code Zen, that's not the case. You only pay when you use up those credits. And those credits are the actual price, not more expensive, no like extra markup. They also offer a model called Big Pickle, which is a fine version of GM 4.7.

So that probably would have performed better than GM 4.7 open router. Actually, they also have Gro code fast one and Miniax M2.1 for free. So these models are free on Open Code Zen to attract users. Uh but they have other models as well.

Let's dive into the fifth build idea. We're going to use Grock 4.1 fast for this. And the idea is a bit more complex. Probably the most complex out of these.

Not technically, but like in terms of my vision for it and the features for it, right? So, it should be like a recursive narrus 4.5 for prompting. This could be useful for product photos for for personal photos in many different ways. We're going to test it as well.

Let's get started. Yo, this codeex is crazy. Openi keeps opening that. Very annoying.

Uh, OpenAI fixed that. I I don't know why it's opening five times when I'm like I'm going to uninstall Codex just for that. Like what is that? Boom.

Going to use Grog 4.1 fast. Wait, is it code? Okay, I think it's better. I'm not sure which Grock which of these Grock models is the best at coding, but let's use the 4.1.

Then we're going to do straight to build and going to do get to work and build this like a 10x engineer would. Also, Grock 4.1 fast should be fast. This should be the fastest app so far. Let's see if it nails it.

Now, when you're using the GPD502 model, let's launch a new open code. So, I'm going to show you one disadvantage compared to Codex. So, let's open a codex, right? Like opens spamming this try if we go and you do the 5.2 CEX, which we can use as well again uh model and we can use the 5.2 the codex, but we cannot set the reasoning effort.

Right? This is one thing that's really good about the codex extension, the ID extension from OpenAI is that you can select the reasoning effort. The issue with this, I think it's set to probably high. I don't think it's extra high.

It's probably high. That is overkill for most problems. You want to stay to like medium for default or like low. High and extra high just man, this is like for the the deepest errors.

Extra high can run for like 30 minutes. Even high can run for 15 minutes. So for most stuff you want to use medium. Here when you use it in open code you cannot set reasoning effort.

So that's one advantage to using codex extension from openai. I'm trying to give you honest objective assessment of open code right. It has a lot of pluses but it has some minuses as well. These companies are always going to protect their native apps and tools, give them some benefits that are not available through the API so that others cannot uh build a better product at least in theory.

Right? Obviously the the bonus of open code is that it's open source and it it uh lets anybody contribute. There's million there's literally millions of developers in the world who are contributing to open source projects and uh you really need to have a great engineering team if you're a closed source company to compete with that is finished or what's going on? Why did it stop?

Why did you stop? This might be an issue with Grock 4.1. Like look at look at this task list. You know it wasn't done.

It's on the third item of like 12. Yeah. So Grog 4.1 fast is nowhere near as good as Opus or Gemini 3. It's just not.

Even though you'll see Xi team posting benchmarks and Elon posting benchmarks, uh the reality is it's not. You know, I don't know any person who's using this model actually to code. Everyone's using either Opus 4.5 or Gemini 3 or GBT 5.2 Codex for bug fixes. These are the three best models right now.

It's done as well. Continuing step by step to doist. This is very disappointing. Wow.

While I'm switching back to Opus, I guess to finish this. Finish this. Also, I'm going to do one more thing. I have this Plexity D research, which gives it more info on how to use the API.

I say info. Boom. In whatever above is more info about how to actually pass files to the Nanob Pro model on open router API. Make sure to follow this.

Now, get to work and finish this app like a senior developer would. The fewer lines of code, the better. Boom. There we go.

So, this deep research just uh I can show you the prompt. It's asking for how to properly pro inside of open API. How to pass images correctly. Answer the short perlexity deep research.

Check 28 sources. that way. Uh I mean look these you know they have web search tools right open code as web search tool code as web search tool but they're not going to be as good as a deep research that checks 28 sources and uh yeah gives you a detailed answer. So when you're building with AI and you're getting stuck or you're doing something risky make sure to do a deep research and feed those results to your coding agent.

This is one of the main things you have to do when being an effective AI coder. lot of a lot of you are not paying for any tool you know whether it's perplexity Gemini L JBD all of these have deep research you're not using it even if you are paying for it you're not really using deep research which is a huge mistake not just for coding but in general in life because a lot of you like to be practical you currently watching this are facing some problems whether it's your personal life your business whatever some of them some of those most of those are probably not coding related but you can still use the most powerful reasoning models and deep research to help you solve them in creative ways, figure out solutions that that you aren't aware of, stuff like that. But you probably aren't and that's why you're missing out. That's why only a few people really squeeze AI to the fullest and improve their life from it.

Most people use CH GBT. They think they're good at it. They have the free plan. They don't know how to prompt it.

It's terrible. So yeah, even like legit most people who think they're at the cutting edge of AI are nowhere near and they're completely clueless. Okay, let's see. It runs the build.

Yeah. So, cloth opens 4.5 10 times better. I mean, probably like 50 times better, 100 times better than u gro 4.1 fast. I mean, it's not not even in the same league.

So, don't don't listen to these benchmarks where Grock 4.1 fast beats Opus 4.5. It's just use it, okay? Use it for yourself and you'll see. Uh that's the main thing.

the vibes test the in production test and like it's not an open code issue because with other models it didn't happen you know with Gemini didn't get stuck GPD 5.2 to codex didn't get stuck. Opus didn't get stuck. So we cannot give that L to open code. We have to give it to the model which was doc 4.1.

All right. So we have the project structure. Let's see. This is how we need to run it.

Copy. ENV local the example. We're going to copy that file again. Very nice.

You just highlight it. It's already copied. Such a quality of life thing. So we need to give it to what?

Open our API key. Let's do that. This one we have create API key. Let's say testing.

Give it $10 limit. Boom. Again, do not share API keys with anybody. Treat them as passwords.

So, we have the EMV local. Let's replace this. Save that. What do we have run def?

That's it. Okay. So, clear and pm, pm, pm, right? Let's open the local host.

Let's see if this actually works. Uh oh, error. We have errors. I'm going to screenshot.

and I'm going to paste it in. We are running into a bunch of errors. The screenshot also I'm going to copy the whole terminal. Terminal.

Boom. Paste that in terminal. Let me Lord of Super Whisper is kind of slow. Think harder and explain what exactly the issue is.

We're running into a bunch of errors when the app opens and it goes into a wide screen. Give me a very simple and concise explanation. then implement a clean and minimal fix. I'm gonna do this.

Boom. Plan mode to figure out what's going on. And again, in plan mode, it doesn't execute changes, but it's incentivized to read, learn about the codebase, to think harder. So, really learn to switch between plan and build.

And these are really the only two modes. One thing about open code is that it removes all the clutter. It simplifies, right? You see all these different AI tools.

They have like 10 different modes blah blah blah. Like all these extensions like there's so many coding extensions that have like seven different like architect debugging overwhelming, right? Open code is like simplified. That's that's the way to explain it.

You have plan and build. That's it. Like what else do you need to do? You plan the change and you build it.

You have a you have error, you plan how to solve it, then you solve it. Like so clean, man. There's no like even in claw there's that third default mode. What is that?

I never used the default B in cloth code. So useless. And say yes. Execute.

Issue app compiles. Fine. Conserus. I don't know.

We'll see. Okay. Why is it asking? Oh, I switch back to plan.

No. Use opus. What? What is going on?

Okay, my my bad. So, I'm going to show you one thing. You can click on previous messages. Very good.

So, I'm going to do revert under messages and file change. Just enter. And now we're in this. And now we're going to do build mode.

I didn't switch the mode. That's my bad. But the the UI is very nice. Like you can all of this is highlightable.

You can click on previous messages. And uh you know this popup, let me show you again the copy message to clickboard for create a new session. And you can search as well. Man, so nice.

So nice. You might not see this as big thing, but like if you spent hours with these coding agents, these small updates really do add up. And why is it using the wrong model name? Oh my.

Oh my, it's trolling me. I'm going to create the spec.md. Going to put it here is the original prompt. I'm going to say stop trolling.

Read spec.md and use the exact same model slugs as in there. I'm going to do five exclamation exclamation points because again they have these models have a outdated context cut off and uh yeah see like it use 2.5 flash like that's not nana pro also the opus one it it tries to be sneaky tries to be sneaky here okay it did update opus that's good now tell me how to test the app again we have it started what am I It's already started. Boom. Reload.

This is terrible UI. Okay. But the the front end is terrible. You can do a much better job than that.

Keep it simple. Keep it minimal. Like a combination of Google Drive and Dropbox. We cannot We cannot do this.

This in the big 26. Where's this front end? This is not 1992 website. What is this?

I'm I'm going to screenshot it. Like this is embarrassing. We might need to do another open code with the Gemini 3. Fix our front.

Okay. Wait. Let's Let's give shot. Give this guy a shot.

Oh, okay. It's improving. It's improving. It's getting there.

Okay. So, the UI has been redesigned apparently. Let's reload. Okay.

Much better. Much better. Upload an image to start. Let's do some product photo.

All right. So, we're going to take this iconic you are absolutely right mug. There we go. Oh, it works.

Okay. All right. So, here we are. Look at this.

We have the canvas. Now, we should be doing API call to opus. Look at this. So, it's the improvements.

Natural lighting enhancement, cleaner background, dynamic angle, shut life. Yeah, let's do lure lighting enhancement. This looks like fake. Looks too inserted.

Now, we're waiting for Nano Banana Pro to create the variations. Okay. Uh, we don't see them yet. This can take 10 to 20 30 seconds.

Generating image is much slower generating text, but we didn't get the outcome. I don't know what happened. Oh, we have some 500 error, but it's progress. Again, this is the most feature complex app.

So, I'm going to say uh logs. Paste it in. Logs. Switch to plan mode, by the way.

We give it the screenshot so it has full context. Right now we have a strange Oh, why are we in Grog 4.1? What? We're running into an issue where everything works until the point where I select the variation I want to generate.

Right? So the first agent, the prompting agent with Opus 4.5 correctly generates the variations. They get displayed in the UI. I can select the one I want.

However, after that, we never get the output from the Narabara Pro. That's the issue. How we're passing the file to Nabara Pro. Maybe the file format is the issue.

But yeah, there's there's definitely some issue. Also, I have a suspicion that is not following this deep research. So, I'm going to create a new file. Actually, I'm going to create a new folder named docs.

And I'm going to move this and open it up. New file as well. I'm going to do uh open router files MD is just documentation so I can reference it. Make sure our code follows open router files.

All right. Okay. So basically I'm tagging the file to remind it and I'll say think harder, explain what is likely happening and implement and prepare a stepbystep fix plan. Yeah.

So it wasn't following the documentation. That's why it's very important that if something is essential, you create a markdown file inside of your codebase and you can tag it multiple times. I'm going to switch to Google say yes implement this so employ these free fixes we'll see honestly it's amazing watching these AI agents work like when you were looking at this in you know 2022 2023 nothing like this even existed but even last year early last year clo code still didn't exist wild now it works let's go you're absolutely right is generating variations how to improve this image what was But improved lighting. Yes, that's what's the worst about this image is like the inconsistent lighting.

But does it generate the images? Okay. Oh, why did it reset the whole canvas? Oh, this is still going.

Why is this still going? Oh, my bad. That's crazy. Open code just reset my session because uh uh uh yeah, whatever.

Let's try again. Make sure no AI agents are running. What is going on? This should be like a recursive improvement of any image, right?

So can use this for Shopify, e-commerce, for dating, whatever. Natural lighting enhancement. Let's see. Let's see.

Can we get the nanob probe to work? We need to add more debugging if it doesn't work. But as you can see, like don't give up after first shot. You still need to upskill yourself if you want to build like very impressive apps, right?

Most people are avoiding the pain of learning anything technical and that's why they're not getting the best results of AI coding. Yeah, you can oneshot most of simple apps, but you cannot oneshot like unique software that nobody has ever built before. You can see we're not getting the generation. Yeah, that's crazy.

What's going on here? Let's do deep research. How to correctly can nano banana row accept the webb files? If so, how do this properly?

Open router API or should we convert to PNG? Maybe this we're fighting an uphill battle here. Maybe it's easier to convert to PNG. Okay, it supports WPS input.

Just going to add this to here. Boom. There we go. Are we fully following open router files plan mode?

Okay. Yes, we are. But we still are getting errors. That's crazy.

All right. Whatever. We have the new console logs. So, let's rerun that.

I'm going to kill the server. Clear and npm around. It wants to delete the next folder. Uh, remember that next.

Okay. So, I guess uh this one is an L. So, four wins, one L. Um, yeah, that's the accurate.

I mean, I could spend 30 minutes on this and fix it, but I think it's safe to say that it didn't one-shot it for sure. And yeah, it didn't even finish it in like 30 minutes. So open code four wins 1 L in terms of building these apps. This was definitely most feature complex one but uh yeah 80% win rate is not bad and they have a very nice scaffold.

Question is whether it's better at using opus and cloth code. It's very hard to say. I would say probably not because enthropic has knowledge of how cloud models work. But it will definitely be better at using other models than you just uh using them randomly in some chat app or direct API calls.

Open code has a very nice environment that it puts the AI agents in. in. in. It has a nice interface.

The prompts are optimized. Will I stop using cloth code? Probably not. But for other other models, I'll very likely use open code.

So let me explain plan mode and build mode a bit more. I already went over it on surface level. But let me explain it deeper. Plan mode is read only.

Yeah. Can analyze your codebase and create a strategy, but it cannot touch your files. It cannot make any changes. So, it's safe.

You can talk to it. You can chat with it. It won't mess anything up. Build mode let the agent actually write, delete files, create files and stuff like that.

And you can switch them with tab. So, not shift tab, just tab. There's also lots of quality of life features inside of open code. And this is why so many people are switching to it.

Not just the fact that it's open source, not just the fact that it's free and that it, you know, offers so many different models. so many different providers. It's all the little stuff like this, the message actions. This is what impresses me the most.

So, for example, the headings automatically summarize your pros. If you paste in a lot of stuff, you can see like it says 32 lines instead of making it actually long. Makes it easier to navigate. There's also to-do list.

We look at that. And clicking messages gives you useful popup like this. We also looked at that. So, yeah, this has been open code.

As you can see, it's a very capable, very powerful cloud code alternative, especially if you care about using open software and especially if you already have a subscription. As I mentioned, if you're already paying $20 a month for CHIGBT plus, you can use Open Code completely for free and it's a strong competitor to cloth code. So, yeah, there's a it's no secret why Open Code is blowing up over the last two three weeks because uh it is one of the most powerful coding agents out there. That being said, if you are serious about AI in 2026 and you want to use tools like Cloud Core, Open Code to build an actual business, I just made a full video about that on what is the best AI business model for 2026.

Go watch it here.

Hey guys, in this video I'm going to show you [snorts] how you can install and set up open code on your Windows operating system. So we are going to see how we can install the desktop version of open code and also we are going to see how we can install and set up the TUI or terminal user interface version of open code. So let's get started and let's see how we can do it. So first of all open your favorite browser and search for open code and the first link which will appear here will be from opencode.ai.

So we are going to click on this link and on this homepage you can see this line at the top which says desktop app available in beta on Mac OS, Windows and Linux. So first of all we are going to download the desktop version. Also after the desktop version we are going to install the terminal version or terminal user interface version using this command. So first of all let's click on this download now button which is going to redirect us to this page from where you can click on this uh download for Windows button which is going to start the download of this executable file.

So let's wait for the download to finish. And once this executable file is downloaded, let's click on this executable file. And let me minimize the browser. And first of all, I can see this message which says Windows protected your PC uh Microsoft Defender Smart Screen prevented an unrecognized app.

So I'm going to click on more info here and then I'm going to click on run anyway. And this is going to start the setup of open code. So at this window I'm going to click on uh next here. This will be the location where open code will be installed on your Windows operating system.

So if you don't have the good reason to change this location, just leave it as default and then click on next. And once you click on next, it's going to start the installation of open code on your Windows operating system. And once this is finished, you can see installation complete. At this point, we are going to click on the next button.

And on this next window you can see this run open code checkbox is checked and also this create desktop shortcut option is checked. We going to leave both options as checked and click on finish which is going to launch open code on our Windows operating system. And now I can see the simple user interface for open code. Now first of all before starting anything I'm going to click on the settings option and from here I can change the appearance and do some more settings.

So as you might see uh the appearance is the system appearance for now. So I'm going to uh make it dark here. And then the theme here you can select from many themes which are available here. For now I'm going to leave it as OC1 here.

You can also change the font from here but I'm going to leave it as uh it is. Now in open code under settings you can also configure your providers and models. So when you click on providers you can see uh all these providers here which are listed. So open code has its own providers like open code zen or open code goore.

But you can also connect with the frontier models uh providers like anthropic or github copilot, open code, google and so on. Right? So from here when you click on uh connect you will be able to connect to those providers and then you will be able to choose the models. Now under the models section you will see all these uh models which are available.

So right now big pickle and miniax m2.5 is available and this version is free you can see. So for now I'm going to go with those uh default models which are already available and uh I'm going to just click anywhere on my open code other than this window which is going to close the settings window. Now in order to work with your open code you should open some kind of folder in which you can start working right it's similar to opening a folder in your visual studio code where you can uh start creating your project or organizing your project right so let's open a folder I'm going to click on open project and under documents let's create one more project and I'm going to name it as node demo for example and then press enter and then select this folder and here I want to create a very simple NodeJS app uh which will be a CRUD app and I want to run this app with some kind of a local database. So let me write this kind of prompt and the prompt is something like this.

So act as a senior full stack engineer build a complete crowd rest API for user task product management system and then I have provided some requirements. So here I have provided the stack requirement architecture and some of the features which I want right. So let's see how uh this works. You can see the model is big pickle by default.

You can also see there are two modes here. Right now it's a build mode but I can start with the plan mode also. So plan mode is for planning and the build mode is for uh creating your code. Right?

So let's start with the planning mode. So let me select this planning mode. And this plan mode is selected. Let me click on send and let's see what it does.

And now it's asking me uh some questions. So it says which entity type should the CRUD API manage. I'm going to select product here. And then I'm going to click on next.

And it's asking me which kind of OM I want to use SQL. Next. and then which kind of uh validation library let's say joy and then click on submit. So now plan is created.

I'm going to just type implement the plan here and then I'm going to go into the build mode now right and then just send this message and now I can see uh it's working on my plan and first of all it's going to start creating the project and now initializing this project and now installing those dependencies and once it creates some uh file structure you will be able to see your files under all file sections. So I can see it has created the package files and then I also see this project structure has been created here which have the config and uh controllers middleware and other folders here. I can just uh click on one of these files and it's going to open this file in this kind of editor. So now everything is has been created and I can even start my server using the terminal option.

So you can see there is this shell option here. So I can click on this shell option and then I can just write npm start here or npm install here. Right? So packages are already there.

So I can simply write npm start here. So let's do that. npm start and then press enter here which is going to start our server. You can see our server is running on local host.

So everything is working fine. This is how the GUI version works. Now let's also install the terminal user interface version. So I'm going to go to the main homepage of opencode.ai.

So for installing terminal user interface of open code on your Windows operating system, I generally like uh this command which is the npm command. Now for this you need to have NodeJS installed on your Windows operating system. So if you don't have NodeJS just install it. If you don't know how to install NodeJS, I have already created a video on this and I'm going to put the link of that video in the description so that you can install and set up NodeJS.

And once you have NodeJS, you can go to uh this option which says npm and then I'm going to copy this command and then let's open the command prompt. So let me search for command prompt and once you see this uh result which says command prompt run it as administrator. So I'm going to click on run as administrator here and once this uh command prompt open I'm going to give this command and then press enter which is going to start the installation of this npm package. And once this npm package is downloaded I can simply write open code on my command prompt and then press enter.

And once I press enter, it's going to open the terminal user interface like this. Right? So this interface is similar to graphical user interface. So here you can see the build mode and the model and the provider.

Right? So to change the mode, I can press tab key. And when you press tab key, you can see it's changing or toggling between plan and the build mode. The model here is big pickle.

So when you press command P here you will be able to see all these options and one of these options are switch model option. Right? So I'm going to press on switch model option and these two uh options are free. So I'm going to switch to let's say minimax 2.5 free option and you can see the model is changed now.

Right. Similarly, I can also change the uh provider here using the same command Ctrl P and then I can even connect to the provider or switch the provider. And here many other options are available like toggle to a debug panel, toggle console and then you can see switch model, switch agent, toggle MCP and other options are available. So from here also you can start um just giving your prompts and see the output.

So let's say uh I give this prompt which says give me the specs of this PC and let's see what it returns. Right? So, I'm going to just uh press enter here and it's going to run some internal commands and it's going to come up with the specifications of this Windows operating system which I'm running. You can see it's running some commands on my Windows operating system which is going to give the response and then based on that response I can see this uh Windows operating system is the Windows 11 Pro.

The CPU is Intel Core i7. The RAM is 48.8. This is how you can use the TUI version of Open Code. So that's it for this video.

This is how you can set up open code on your Windows operating system in the form of desktop interface or terminal user interface. I hope you've enjoyed this video and I will see you in the next

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.

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.

What is going on, guys? Welcome back. In this quick video, today we're going to explore Open Code, which is an agentic terminal environment or an AI agent in the terminal, similar to Claude Code, similar to Codex, but open source and community-driven. It has a lot of interesting features, and I think, personally, it has the best terminal user interface.

So, we're going to explore how to use it and some of its features in this video today, and we do this primarily because I'm personally rooting for it to become the state of the art terminal agent tool. I like it more than Claude Code and more than Codex, not necessarily because it's superior, but just because I like the style and I like the fact that it's open source and community-driven. If you like this video, let me know by hitting a like button and subscribing, but now let us get right into it. >> [music] >> All right, so this is going to be quite a simple, casual, and straightforward video.

We're going to explore Open Code just by using it. I want to show you how to use it, what it can do, what the terminal user interface looks like, and primarily maybe to get you to use it, to try to use it, because actually you can replace at least Codex with it, because you can actually even use the ChatGPT subscription in Open Code. So, let us get started. I'm going to move here to my tutorial directory.

Let's go full screen here, zoom in a little bit. And now I'm going to just start a session with Open Code. Now, I'm not going to cover the installation. It depends on your operating system.

Um you will have different package names or different package uh managers, at least, that you have to use to install it. Just get Open Code onto your system. I think I'm using the AUR version, so I'm using yay to install it. And once you have Open Code on your system, you can just start Open Code.

And then it opens up a terminal user interface, in my opinion, looks superior to all the other uh terminal agents that we have. And what we can do here now, first of all, is we can press control and P. This is going to show us the commands that we have available here. Now, you don't have to use these commands uh by using control P, and you also don't have to use the shortcuts.

You can also use commands like \{{}slash} models, for example. This is going to allow you to switch the model. Now, you can use a bunch of different models. I think they also provide you here some Open Code models for free.

You don't even have to do anything in order to use them, uh as far as I know. So, you just use Open Code uh Zen. I mean, you have here MiniMax M2.5 free. Um or you can connect to OpenAI.

The reason I can use OpenAI models here is because I connected the provider. So, in my case, I did control A here, and I chose the provider. And as you can see, you can choose from a lot of different providers here. The only thing is, you cannot use Anthropic subscription, so you cannot use Claude Code or the Claude Code subscription in Open Code.

You can use the API, the Anthropic API, but you cannot use the subscription, but you can use the OpenAI subscription, at least as of right now. So, I'm not sure if I can do this. Yeah, I can actually do this here. You can see OpenAI ChatGPT Plus Pro or API key.

Both is possible. For Anthropic, it only says uh Claude Max. Okay, for Max, it seems like it works, or the API key. And of course, you can also do other stuff like Ollama Cloud, or you can also do Ollama locally.

I'm going to show you how to do that later on. But essentially, this is just your basic agent. So, I can do something simple like create a um simple Flask application with a simple HTML, CSS, JS front end. It should manage to-dos.

And now you can see what this looks like. We get this animation here for loading. We get on the side here uh the context, so how many tokens are in the context, how much of the context has been used, how much uh money we spent on this, and then also the to-dos here are listed, so you can track the tasks, and you can also see what's happening all the time. Now, if I want to, I can interrupt this by pressing escape twice, but I'm not going to do that right now.

You can see it automatically does the changes, so it doesn't ask me for uh confirmation. However, we can change that if we want to. So, right now it just creates the files, runs the commands, it doesn't ask me if I'm okay with that. It just does that.

I personally don't like that, so what I'm going to do is I'm going to tell it to actually ask me before doing anything. But I'm going to let it finish the task right now, so we have a basic version first. Now, you can see it uses the requirements.txt file. I don't like that, so I'm going to interrupt here with double escape, and I'm going to say, "Please use UV init, UV add, etc." And as you can see, it also runs these commands without asking for permission, which is quite dangerous, if we're honest, but we can easily uh we can easily change that.

All right, so it's done now. Let's go and try to run it. For this, I can do control C to exit Open Code. You can also see I can continue the session by saying Open Code \{{}dash} S, and then the session identifier, or I can say Open Code uh \{{}dash} C to continue the previous session.

So, the last session. This is going to do the same thing as providing the session ID, but if I have multiple sessions, it makes sense to provide the identifier. Now, let's go and say UV run. What is the file name?

app.py. Open this in the browser, and here we see now a to-do manager. Let's try something like test, add something else here, and then I can check them off. I can delete them.

Perfect. Now, let's see if this is already persisted onto disk. No, when I start this again, it doesn't have the to-dos persisted on disk. Fine.

So, the first thing I want to do now is I want to make it ask for permissions, no matter what I do. So, if it runs a command, or if it wants to run a command, if it wants to create a file or change something in a file, I want to approve this manually. This is just how I like to do agentic coding, because I'm not a fan of fully vibe coding, like telling it to do something and then believing it succeeded. I like to see what it's doing.

I don't necessarily have to write the code myself all the time, but I want to see uh what is happening, and I want to approve the individual steps. Um so, what I'm going to do here now, in this base directory, in this project, I'm going to create a file called open code.json. And this is going to contain my config. So, I'm going to use curly brackets here, and I'm going to start by specifying uh schema.

So, dollar schema. And this schema is going to point to a URL, and this URL is https, uh and then open code.ai/config.json. So, this is like a template or a base version of the config, and now we're going to extend it with our own settings. And for this, I'm going to say here permission.

This is the thing I want to change, and I want to have two different permissions. One is going to be the edit permission. So, when editing something, I want to be asked for permission. So, edit is going to be ask.

Now, in addition to that, I also want to be asked when it runs bash commands. So, I'm going to say bash, and here now I want to have a dictionary, because I want to white-list a certain command. So, let's say for all the different commands, so for an asterisk here, I want to be asked for approval. However, if I tell it, or if it needs to run LS for some reason, I don't need to be asked.

So, I'm just going to allow this by typing allow. So, this right here says, "If you want to make any change, ask for approval. If you want to run any command, ask for approval, unless this command is just LS." And if we go into Open Code now, if I say um Open Code \{{}dash} C, and I tell it to run the LS command, I'm going to be or it's going to be able to do that without any problems. So, uh run LS command.

This is going to now just execute LS. Perfect. And now if I say run LS \{{}dash} LA command, it's not going to work, because this flag is not um not allowed here. So, permission required.

It's going to ask me to allow this, allow always, or reject. So, I'm going to allow once, and there you go. Perfect. So, this is a very basic setup.

And also, if I tell it now to um make sure the data of the to-dos is actually persisted on disk, use SQLite3. Then it's going to now use a database to persist our to-dos, but it's going to ask me for approval when it tries to change something in the code. There you go. So, here it says now permission required, and sometimes it might have uh or it might want to try certain things, or it might want to change certain things, and I don't see everything uh in a convenient way, because this is not not the best way to look at code changes.

So, what I can do is I can say control F, and this is going to launch this in full screen. So, now I see this diff view, which shows me like on GitHub, what is being removed, what is being added, and I can see if this makes sense, and if I'm okay with that, I can just press allow once. And you can see it also reacts here to uh linter errors, because it also uses an LSP. This is a thing that you don't really interact with, so you don't really do anything specifically with the LSP, but Open Code itself uses an LSP, which means that it is much better at finding stuff.

So, it doesn't have to just use grep commands to find certain occurrences. It can just use refactoring, it can use um the LSP, essentially, um so, the language server, to realize what's happening, and also to find certain linter errors. Um so, here again, it wants permission. I'm just going to allow.

Now, it wants to run uh the Python script or py compile. I'm going to allow this as well, and then at some point, it's done. Now, if I'm not happy with this change, what I can do is I can undo. So, I can do \{{}slash} undo, and it's going to allow me to undo what has happened in the last step.

However, I can also, and this is I think the difference between uh between Open Code and Claude Code, because as far as I know, and I might be wrong about this, in Codex, I'm not even sure if you can undo it all. In Claude Code, you can undo, but you cannot redo. And here, you can also redo. So, I can also do redo, and it goes back to where I was.

And I think I can also jump. I'm not sure what the command is here. I think if I go to control P, uh there is a command jump to message, so it would be control X and G would allow me to do that, and I can just jump to any point here, for example, to run the LS command, and I can say, "What do I want to do here? Do I want to revert everything and go back to this state of my files and the message history?

Do I just want to copy the text to clipboard, or do I want to fork into a new session?" This is also a nice feature. However, the forking feature is not exactly what you might think it is. It is not exactly like a GitHub fork where you can just um where you can just have now two versions of your code on your system. Uh like you have a to-do application and in one branch you say, "Make it blue." In another one you say, "Make it red." It's not like that.

You don't have this kind of code fork. You have more like a conversation fork. So, at some point you might be asking, you know, you have the context of the whole application. You want to ask, "Okay, how is this feature being implemented here?" And then you want to ask some other question about the code base.

And maybe to not confuse it, you want to ask it in a fresh state with all the context but without the previous request. So, that is uh the idea of forking but you're not really forking um the code. So, if I if I go to a message, what was it? Uh control XG.

If I go to a message here and I fork this, I have a new session with the same history. But if I now do something, it's going to also be applied on the code of the other session. So, we're not treating this here like a independent thing. Um all right.

So, I can also take a look at the sessions that I already have by saying \{{}slash} session or sessions. This shows me here the different sessions I have. I have a fork and I have the default session. I can jump back to it here.

And by the way, most of these things can also be done with shortcuts as I said. So, here you can go to commands and you can see probably there's going to be here switch session and then I can just switch here like this as well. And the shortcut for that was was was uh control XL. So, control XL allows me to also switch the session.

Now, another cool feature is sometimes I might have very complicated prompts that I want to write. Maybe with some formatting, maybe I want to do markdown, maybe I want to do uh a lot of uh line breaks and so on. What I can do in this case is I can just open my favorite editor. So, in my case Neovim is registered as the default editor in the terminal.

So, what I can do here now or the default editor in general, uh what I can do here now, I think it was control XE, allows me to open Neovim. So, now here I have a markdown file. I can say, "Instruction and then this is my fancy instruction for Open Code." And then maybe I can also just copy-paste this because it's easier to do that in Neovim. Then I can write and quit.

And now I have here the entire message um in this field here. And I can also do the same thing again. I can say control XE and I should be able, as far as I know, to also remove all of this, write and quit. Maybe if I do it one more time.

Okay, seems to to not work right now but it actually worked before. So, maybe maybe that's a bug right now. But the idea is I don't have to do this myself. I don't have to write here in this uh text window.

I can also do that in Neovim and use the macros or whatever uh to make this happen. Even though right now I have to delete it manually. So, maybe either that's a bug or this is a layer eight problem, me using it in the wrong way. But that is the idea here.

Also, by the way, a lot of this stuff can be done with a mouse. So, I can also scroll up to a message that I sent like, for example, this one here and I can click on it and it's also going to allow me to take these message actions that I get when I jump to a message. Now, another nice feature here is switching back and forth between variants of the model and also between the modes. So, here you can see right now I have GPT 5.3 Codex and I can also press tab to switch to plan mode or tab to switch back to built mode.

So, this works easily. In plan mode, I only have or the agent only has read-only access. So, if I say um "Add a user model to the DB and application. So, users own different to-dos." Then it's going to give me a plan now.

It's not going to implement this into code yet. So, I have the plan mode and then I can go into build mode to actually do this. So, as you can see here, I get now a plan and if I'm happy with that, I can just go back to build mode and implement this. Also, with control T, as you can see down below, uh what I can do is I can change the variant.

So, I have low thinking or low reasoning effort, medium, high, and extra high, which is extra high. So, that's also quite convenient that I can just easily cycle through that with control T. Then maybe uh a feature that's not really too much of a feature, it's more like uh a styling thing. I can also change the theme.

So, I can go to themes and I can go with one dark, for example, which usually would fit my system more but I enjoyed the Open Code uh theme a lot. So, I'm going to keep it. But you can try all the different fields like uh or all the different themes like Gruvbox, for example, if that's your thing, uh that's kind of cool as well. Now, of course, I'll not show you every single thing about Open Code here but I want to show you two more things.

Uh one is how to do this with Ollama. This is the last thing I'm going to show you. But the next thing I want to show you is how to use plugins. So, you can easily use Open Code plugins, community plugins, by just specifying the NPM package.

So, I just have to specify what package the plugin is on NPM and then it automatically loads that. So, when we take a look at the Open Code documentation in the plugin section, you will see how to install plugins. For example, you can do that from local files by downloading them and putting them there, or you can just specify the NPM package like this: plugin and then a list of plugins based on their NPM package name. And if you go to the ecosystem section, you will also find a couple of plugins.

For example, here the one I want to use is the notifier plugin. So, Open Code Notifier. We can click on it. This is going to take us to a GitHub repository and here we can now just copy this and paste it into our Open Code file.

So, I can get out of Open Code here. I can open up the Open Code JSON and down here on the same level as permission, I can just add a comma here and then I can just paste the plugin. I don't need the curly bracket. is just a field here.

I can indent this properly and now I have the plugin installed here or specified that it should be installed and used. And what I can now do is I can close this. I can open Open Code again and I can go to a different workspace while giving it a command. I can say, "Run LS command." Then I can move to a different workspace here and I should get um here now the not a notification that this is completed.

There you go. Open Code tutorial session has finished. So, this is how easily you can plug and play with plugins here. And the final thing I want to show you is how to actually uh use Ollama models, so local models.

I'm not going to show you that exactly because I'm on a very weak laptop here. If we look at fastfetch, you will see that I have a very uh limited set of hardware here. So, I'm not going to do this. And also on Ollama, I think I only have uh basic models, not instruction models.

But the theory is the same. So, this is a screenshot of what you would have to do. You still have the schema and then you just say provider Ollama. So, this is how you plug in a new provider.

You name the provider Ollama. You provide the package here, uh NPM OpenAI compatible. You say that the name is Ollama via LAN. Then you specify the base URL.

In my case, this was now a machine that was running Ollama on this Ollama port here. And then I specified that I want to use the GPT open source model with 20 billion parameters. So, what this does is it registers this as a new endpoint, as a new model provider, and as the model that is available there. So, when I have this, I can just go back to Open Code, say \{{}slash} models, type in Ollama, find this, and select the right model.

So, that's it for this video today. I hope you enjoyed it and hope you learned something. If so, let me know by hitting a like button and leaving a comment in the comment section down below. Also, in case you're interested, on my website you will find a services tab and a tutoring tab.

There you can contact me if you need help with freelancing or if you need a freelancer, if you need some consulting, some one-on-one tutoring for any of your projects, startups, whatever. You can contact me via LinkedIn or email at the bottom of these pages. Besides that, don't forget to subscribe to this channel and hit the notification bell to not miss a single future video for free. Other than that, thank you all for watching.

See you in the next video and bye.

Fed up with subscriptions and usage caps for AI coding tools. Meet Open Code from the SST team. Completely open- source and fully customizable and free. Whether you want to run your local models like Olama at Serak and plug into your own API keys for Claude, OpenAI or Gemini, you're in control.

Today I'll show you how to get open code running under five minutes and why it's a gamecher for devs who value flexibility. Let's jump in. Here's the current landscape. We've got cursor, excellent multimodal support, includes claw, chat, GPT, Gemini, but it's around 20 bucks a month, but the pricing has changed and it doesn't actually get you as far as it used to.

And pricing seems a bit uncertain. I know for myself, I'm not getting as much usage out of Chris as I used to. And I've also been hit by some unexpected usage bills that I don't I don't know if I really want to keep too much with it, especially for massive projects. I think for small changes, it's still a great tool, especially for the auto tab and small edits that need to happen and giving quick context of what a project does.

I really like its embedding function, but it has its its cons. Cloud code. This is the leading industry CLI AI coding tool right now just because you can use C code subscriptions to get a lot more value out of it from what you pay and you can build it into multiple different de teams. And then we got Gemini CLI which is Google's CLI which you can has a free usage which you can upgrade to just pay using the API terms which is also a great product.

All these products I just mentioned are really good and polished, but you're either paying a monthly subscription, facing usage limits, or you're just locked into a single vendor's like workflow. Feels a bit clunky. For like example, I really like using Gemini for planning. But I don't always want to jump out my terminal to then ch change to claude to do the programming.

I want them to share context constantly. And open code allows this to happen. So open code from the SST team flips a script. It's 100% open source, no subscription fees, lightning fast terminal UI, built for devs who want control, 70 plus models supported, claude, G54, Gemini, OAMA, and more.

You can run local models for free on your own machine or use your own API keys. You pay for what you use and choose the provider you want. It's no middleman. A quick but critical thing, there are multiple open code projects out there and you want the real one, open code from SST team.

So, make sure you're getting it from the github.com/sstopenode. Do not, and I just don't want you guys to get confused. So, I'll link the description down below. Please use that link to uh hit the right repo.

The the main difference between the two is the one developed and maintained by the SST team is being actively developed and community supported constantly with all the features you're seeing here. All right, let's get SST open code running on your machine. No confusion, no wrong repo. If you're on no Mac, you can use brew install SST/TAP/open code.

Enjoy. If you're on anything else, I recommend using the Node.js JS installer which is the mpm installed - g open core open code- aai. All right, now we got open code installed. The first thing is you probably want to set up your model provider.

Use open code or login and choose the model that you want to support. If you do have a claude code subscription, choose claude and then choose sign in with claude code. And you can use claude with open code. Great.

Now that the model set up, we can now initialize as a product. So we're going to go open code in it. This uh this will give open code a chance to scan our repo just to create an agents.m MD file which is essentially the rules that it will follow to understand the text stack. This is the similar as the claw MD or cursor rules that you know and love.

If you want deep dives into Open Codes, advanced features, custom agents, local alarm setup, or multiple provider workflows, drop a comment down below. Thanks to the SST team and the contributors for building this tool. In the next video, I'll show you how to supercharge Open Code with custom agents and advanced automation. Don't miss it.

This will be a series of a lot of different AI tools that I'm scoping out for bigger projects.

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

So, most teams use AI tools for coding, but that's just the tip of the iceberg. There's actually more to it than that. You can actually use AI tools to help with automating research, content creation, and even team communications with it. This one setup that I'm going to show you helps turn Open Code into your team's productivity engine or your personal assistant.

And 90% of people don't even know you can do this. So, if you're using Open Code just for code, missing out on hours saved every week. So, let me show you what you could be doing with it. Quick shameless plug before we jump into it.

If you're looking to use tools like this for your own team and you would like to have strategies uh implemented, hit the link down below and book a call with me and we can talk more about it. Anyway, jumping straight to the code. Right, I've got an open repo here and you can see there's one file. I actually want to show you how easy it is to make uh this whole setup just using one file with instructions using open code itself.

You can do this with cloud code 2 if you wish, but essentially the instructions are we're going to build a planning and research and content creation workflow using different agents and slash command. That's pretty much it. I'll go into more detail about what this actual text comes when we running it. But to get started, we're just really just going to run open code.

And in open code, we're literally just going to reference this doc that we have here to build our whole thing. So, we're literally just going to say, "Hey, please build our personal workflows using the file we just stated here." And we should start seeing it build our open code um folder with all the settings in it. So, we can see here it's kind of getting all this context that I built how it's uh establishing this. While we waiting for that to build, I just want to quickly touch on some of like the thoughts behind the instructions here.

And it's around these three things slash command, context, files, and agent. So I don't know about cloud code, but I know a lot about open code and open code with slash commands. I know anything with the at symbol if I refer to an external file gets pulled in automatically as context. That's great.

So that's a great way of like you can pull a slash command to do a task and there's always going to be reference files that you always want in and you can manage those reference files using the at symbol. So it helps separate concerns and I know it's going to be pulled into the slash command. So the slash command is like your initial prompt not init your initial prompt with context that you can pull straight in and this is the kind of theories I'm kind of giving this so I can then incrementally change how it behaves very systematically which is great. So if you do the at symbol in agents, just know the agent has the option to pull it in.

It just has to do a tool call to bring it in in open code. And I just felt like sometimes agents don't always do that. So that's why I really prefer the slash command to bring in, you know, initial context that we really care about. And that's the main theory about these three going on here.

So, one thing I am going to touch in this video that I haven't touched before is we're going to install an MCP, a local MCP for this project, and we're going to be using the Brave MCP. And just to go into what that looks like is if we go to the Open Code documentation, we just go to the MCPS here, PP servers, we can see this is pretty much how an MCP is configured here. I'm literally just going to copy this and go back to my code. And you kind of want it in the main folder here.

So, you just want this to be open code uh JSON. And we're literally just going to paste that in. I'm going to get rid of this. All right.

And now we've got our general um MCP server here. And I'm going to go to the web again. I'm going to go the Brave MCP documentation. All right.

So, I'm going to be using this Brave search API. And this is the MCP instructions here to install. It looks a bit different. You can't just copy and paste this, but I'm just going to copy this and then import the commands this side.

So, I'm just going to just do this for now and I will fix it afterwards. So, we got the MCP. We want the Brave search here. That's correct.

So, we're l just going to change the name here. And the type is local because we installing it. And the the one is mpx, not bun. We want a dashy.

And we've got this is like the install package. We're just going to put that in. There we go. Enable.

Yes. Environment. We wanted Brave API. We're lally going to do that.

And we'll put the API key there. All right. Now, let me get rid of this. This is no longer needed to comment.

All right. So, we're going to go get the API key for this. We're going to go to Brave. This is the website here called brave.com.

You can sign up for a free API. You can pay $0 a month. get one query per second up to 2,000 queries per month. One thing to note, you do need to put your card in for this, even though it's free, I know, but that's what it is.

So, just sign up. But once you've signed up, right, so once you land on Brave and you signed up your account, you kind of want to go to subscriptions here. So, click on subscriptions. Make sure you click the the subscribe button for the free account.

It will ask for your car details. That's just I think how they want to stop abuse. So you can add your card details and then after that once you've subscribed it'll charge you nothing. Don't worry.

You can then press on API keys. You go to API keys. You'll see pretty much nothing here. But you can go to the top here and add your own API key.

Then from this you can copy whatever the API key is and go back to your code and paste it in here. All right. So we back after you know jumping around doing the brave thing and we can see our agent has built everything. So let's have a quick look.

So we can see at the top here it made the open code folder. It used it made some agents command and context and then it's made some just normal files where it'll store all of this. Let's have a quick look in agent strategy. We can come here and just have a quick look to make sure if this is correct.

It's this is a sub agent. I don't think that is correct. I kind of want this to be a primary agent. So, I'm going to change that.

And we can see it creates. It's got all the things. Great. So, it knows how it needs to write everything.

Not too bad. You got my life strategy agent. Great. And then we've got our research.

Is this also a prim? That's primary. And this is a sub. Okay.

Research agent as a sub. I think that is fine. We don't always need to use the research agent as a primary one. We can change that if we need be.

All right. But we can see it pretty much has everything in it which is awesome. And we can go to our slash commands because this is pretty much what we really care about. Say we want to pl you know plan a blog post.

We can just run this blog post here. The same with the daily plan for the daily and we can do research Twitter thread and we got our context of what the blog pattern should look like. Got our brand voice. We've got our Twitter patterns.

Awesome. And we've got essential patterns also. We'll put it here. And we've got some life goals and routine.

We can come in and go update all this. But all right. So one thing to note, we made this with open code. We actually have to exit the session because what everything we've just created here both with the MCP and all the agents aren't in the session yet.

We actually have to open it. Sorry, close it and reopen it. So I'm just going to reopen it. and we get open code starting again to see that it's working.

We can press tab to see if our agents change and we can see content strategy agent is there which is awesome. So I'm going to use this as an example and I'm going to ask it to create a So we got the blog post um slash command in there which is great and I'm going to do a top. All right. So I'm just going to ask it to make a blog post.

I want to make sure you know what AI tooling is picking up and pretty straightforward. And what we should see happen is it should reference the research agent. Don't actually hold on. I didn't know if it has that.

All right. All right. I saw one mistake uh before current uh carrying on in my content agent here. I actually see no reference to the research agent which is kind of core for what I care about.

So, I'm just literally going to come in here and say always use the research agent to gather information and for if a URL is provided. And I'm just going to press an at here just so it knows it's the research agent. And it should then and I just need to make sure research assistant agent. Yep, that's correct.

Now it should use So now it should just use this research agent constantly. So I'm just going to exit open code again and I'm going to build a blog post again. So I'm going to just ask to make a blog post about uh why AI tooling is so popular in 25 and the pros and cons. And what we'll see it should hopefully give some research the research agent and go from there.

So we can see here it is saying let me gather some research insights and we can see it's delegating which is kind of what we want. And there we go. We asking the research agent. Remember the brave API only allows us to do one search per second.

Sometimes that may be an issue and we might actually have to prompt that say hey when you do a search wait one section before you do another one and that's just something to note. So we can see here it is doing quite a bit of research here. It's grabbing a few different uh queries. I can go right left to see what's going on in it.

So we can see no no issues. It actually is giving us the response back which is great. No issues so far. All right.

And we can see what it's looking at. McKenzie. It's really trying to grab all the different bits of research here. We could actually do a better prompt on how research should be structured and filtered through, but for this demo purposes, I'm just showing you a quick way of doing it.

All right, so once it's done its research, it will come back. It's making a folder and then it'll save it. it. it.

All right, so it is done running. So we can see if we just quickly scroll up, you can see here it did the research. Then it actually made a file where we're going to put this. It actually went and grabbed the brand voice from what we wanted.

It actually then built our whole blog post and then saved it. And we can see our new blog post that's there. And this is just a draft. You probably want to come here and edit it and change it how you want it to be.

The last one I just want to show off is so this is do / new because we don't want this context. We want to probably build our life our daily plan. So we can just go daily plan. All right.

So we're l just going to use the / daily plan and we're just going to ask you to help us build each of this up. So we'll see how it does. So we're just running that and it's just analyzing the request. I'm actually realizing I ran the wrong agent.

Okay, we're going to just build up our life planner quickly. And at the moment, you can see I'm still in the content strategy agent. I'm just going to press tab here to go to the live strategy agent just so we're using the right agent here for the job that we specified here so it knows how everything works. And I'm then going to just use the daily plan uh slash command so it just grabs all the different contexts.

All right. So I'm just going to go slash uh daily plan and I'm going to give it what I'm trying to do here. And my focuses are just fixing code and content generation. And I'm just going to press enter.

And that's literally going to start building out my plans for everything. It will it should also make some templates that will help keep us on track. All right, so this is asking for our confirmation. And yep, I think this sounds good.

All right, we can see it's really going into a lot of different detail here. Probably maybe too much, but it's really nice to see how much you can just build with this very quickly. All right, we can see on screen it is finished with our daily update and we can start today. We can just run our daily startup and we can do September the 12th.

So let's let's do that. I'm literally just going to run this. Grab that and let's see what happens. So we can see it's telling me where to focus on and you know how to really block everything.

Very standard stuff. We can just refine this to do a lot more especially like how maybe journaling what I found what I did what I did well and then also keeping make sure that it's getting the metrics done for me. All right, we showed how we can use AI tooling not just for coding but actually for personal productivity. This is not just for individual productivity.

You can actually use this in teams and really accelerate your team's productivity and communication a lot more than it could before. You can get consistency across teams outputs, reduce context switching, faster stakeholder communication. Imagine every time you commit code, a message goes out to your Slack channel that hey this code has been committed and this is what I worked on. automatically giving all the relevant information that you didn't have to manually type yourself.

This streams line um development workflow. Briefly covered how you can do this, but the way you should always start is we start small. Pick one non-coding workflow like research or documentation to get started and then measure the impact. Does it actually save you time?

Is it actually giving you better results or is it actually taking time away from you? And it's not just the usage. This is very important. And a lot of people get caught up, me included, is it's the hype.

It's what we should be doing, but sometimes the results don't match what we expect. And that's fine. You can, you know, dial it back. Maybe try a different approach.

Really approach this in a systematic way. Once you've measured the impact and you know it's saving you time, then you're doing a great job. You're not just using it. Then the next step is you want to scale gradually.

So you can add different MCPs for maybe accessing different contexts or you know sending out different requests or alerts and that's great but always make sure it's value valuable don't just add it for the sake of adding complexity engineers we love to do this so hold yourselves back and really make sure it's work and lastly if you are putting this in a team setting show them the reasons why it works and why to use automation not just hey this is automation do this explain the reasons why and then once you got the reasons Try go into the details of how best to use it and make roll it out slowly. Don't try do it all at once. That would be my recommendation here. All right.

So that's how smart people and smart teams are actually using AI tooling like open code here. Not just for coding but also for workflow transformations. Most development teams are sitting on this gold mine and not even realizing it. So, if you're a CTO or a team lead wondering how AI tools like this can fit into your strategy, help teams navigate these exact decisions.

So, I got a link down below if you want to book a free consultation for 15 minutes. We can talk if it is even needed or how you could approach this in your own team. So, what non-coding workflows would you like to use to save you time? Like to hear in the comments down below.

Always if there's anything else you want me to cover, please, you know, drop me a comment and I'll happily engage you there. Thanks so much for watching and I'll see you next time. Cheers.

There's been a growing contention between cloud code and open code. If you zoom out and look at so many other coding tools that all solve similar problems in terms of AI coding agents, cloud code seems to stand out as the most favorite tool even with growing competition with open code. Today we're going to analyze the AI coding industry and ask why tools like cloud code and open code matter and see the progression of how AI coding tools got to where they are today. We'll also look at Enthropic's ban on thirdparty use cases and what this really speaks about the AI industry overall.

Welcome to Kale Bright's Code where every second counts. One of the first attempts made in AI coding was GitHub Copilot which was powered by GPT3 LLM likely post-trained with coding data called Codeex. Back then AI coding was mostly a glorified code completion tool like this. But it did blow many developers minds because it really set into people's minds of how AI could really change coding after all.

But as much as GitHub Copilot was impressive in just suggesting the right code, it had little to no effect on how work was done for developers. In other words, there was a productivity gain but not a complete change in the developers workflow. Fast forward to about four years later, cloud code was announced. And during this four-year leading up to clot code, there have been many attempts and form factors of how AI could exactly fit into developers workflow.

For example, GitHub copilot acted like an assistant where it helped you save time from entering code, but you still had to do the work yourself in writing the code. In other words, in order to develop code, you still did all the work in looking through the documentation, translating business requirements into architecture decisions and using the IDE to develop code. And in this flow, Copilot only helped you in the last stage of developing code while it desperately tried to infer requirements from the written code. Then we had other iterations but in different form factors.

Cursor and Windsorf emerged as one of the early players who well created a fork of IDE so that it allowed people to use Cursor and Windsurf to essentially delegate work for AI to complete. And for the first time, developers were able to work one layer up in the stack by translating a business requirement into a well-written prompt for AI to complete. Other tools like Klein and Rue that existed in a slightly different form factor as extensions also fit into this category where developers took turns back and forth to get the work done. But it wasn't until AI operated in the terminal that we saw a complete change in the workflow.

One of the first prime examples of this is Ader where instead of being an IDE fork or just extensions, Ader allowed developers to work in a separate environment outside of their IDE. In other words, working in terminal bifurcated work in a way where AI didn't really impose on developers IDE, but instead it allowed an alternative stream of how work could be done. Even though Ader gained mass popularity among more technical users due to its complicated user interface, they charted a direct path towards cloud code eventually. That's not to say ADER is a bad tool.

They were extremely good in terms of diff added accuracies, token efficiencies, context management and precision. But in my opinion, Ader remained as a task completion tool rather than being something much bigger than that. Which is where we come to cloud code. Cloud code despite being the same form factor as Ader changed things.

And here's why. Not only was Cloud Code just downright a solid product that just worked, but Cloud Code was a lot more approachable as a user with a variety of other tools like MCP tools and all the bells and whistles that you might want from a terminalbased AI coding agent. While Ader allowed for a more precise work to be done with cloud code, developers started to think projectwide rather than module or taskwide. And this transition started to reshape our view on how work could really be done differently with AI.

And for the first time, instead of bringing AI into how we like to get work done, we started to change our work to fit to how AI gets work done. We started using claw.md and skills.md that essentially pulled out tribal knowledge outside of developers minds into a well-defined document. And this very practice alone is valuable enough to change the industry upside down. What I mean by that is most people criticize AI adoption not because technology won't be ready but because organizations won't be ready because so much of their process is not defined not documented but lives in people's minds as tribal knowledge.

So implementing AI on top of hidden tribal knowledge can only take you so far. But as AI started to really draw these things out and changed developers to start dabbling into project management rather than just pure software development, AI adoption in the coding industry really started to change. Another perspective to keep in mind is when it comes down to cost. I broke down the difference between API pricing and subscription model in my previous video, but with cloud code, people could use their own subscription pricing with Enthropic to use high performing models like Opus 4.5 without worrying about the racking up API cost since Enthropic practically subsidizes subscription pricing to have more people hooked on their system.

Well, that is until Enthropic banned thirdparty applications from tapping into this subsidized pricing channel, but forced other applications to use the API pricing instead, which is a much more expensive way. And this caused a lot of contention between users since they felt like Enthropic enforced vendor lockin when it comes to pricing and thought that subsidizing should also apply to applications outside of the Anthropic ecosystem. While I tend to lean more into the camp where this was well within the rights for Enthropic to ban thirdparty apps to use their already subsidized subscription plan, we haven't really talked about why Open Code is the cause of all of this controversy. Open Code, unlike Cloud Code, is an open-source application, which means the public could potentially contribute to shaping AI agents that is similar to Cloud Code.

And I was frankly impressed by the depths of its features and capabilities as well as many free models it offered out of the box. But this debacle really does point to a growing contention in the AI industry. Clearly, Opus 4.5 is the holy grail of all coding agents. But price sensitivity among coding agents point to an extremely high competition in the application layer.

So we asked the age-old question, does the competitive edge come from a better model with better pricing or better application and better LLM wrapper? And meanwhile, Enthropic is also fighting competition in the LLM stack from OpenAI's coding models like GPT 5.2 codecs and open models like GLM 4.7, Minimax M2.1 and more. Another interesting on this is when it comes to inference speed, most notably OpenAI's partnership with Cerebras where some people are suspecting token speed up to fourdigit tokens per second. This kind of speed could make a huge impact since making three iterations faster could be a preferred method of getting work done rather than one iteration that takes a lot longer.

So what does all of this amount to? The cloud code debacle with open code isn't just about pricing dispute by gatekeeping thirdparty apps, but it's really a stress test in the AI coding landscape. We're seeing a battle in people's preference when it comes to LLM model layer or the application layer. And these are colliding and developers are now in the position to now choose whether they stick around for the better model or better application when it comes to how work gets done.

As of now, developers, including myself, are using multiple tools at once, depending on the complexity of the problem and the cost. But we are seeing a ripple effect of how 2026 really could be the year where we start to consolidate on all these LLM rappers and the AI agents that only a few strong remains given that so much is at stake. What do you think?

Hey everyone, Andreas here. So recently I discovered a new very cool awesome tool called open code which is basically the AI coding agent built for the terminal. It is basically an alternative to uh cloud code but it's open source and it was actually very easy to uh install. So I firstly wanted to u uh provide a quick tutorial on how to install this locally.

so that you can basically uh switch models and do a couple of other configurations. But you can honestly just open your terminal and based on your system. In my case, I use Mac OS and homebrew. I managed to uh very fast uh and easy uh open this on my terminal which basically means that you can u write ahead uh talk with the agent in the command line terminal which is very cool.

Uh, and this is called the CLI, basically a mini CLI application. And as you can see, it pretty much works like a classic terminal. You have your SL and a couple of commands you can um uh toggle and choose based on what you want to do. Uh, you can create a new session.

You have a list of available models at least with this type of installation. Uh we have Grog Quen 3 and uh basically those two. Uh let's keep it to Grog code fast one for now. Uh and you can basically be like uh what are the best or maybe what is the best possible way to build a to-do list application and you can start planning out whatever your idea is.

right from the terminal. And whenever you have a a correct implementation plan, as we're going to see uh in a couple of minutes, uh we can basically build apps right from the terminal using uh open code. So it's super cool and um so yeah, so it's basically doing some research now. uh navigate child session use react for J uh for front end implement crude with authentication add real time sync so as you can see it's basically replying to us with the best possible way and uh you can go ahead and be like provide a stepbystep uh implementation guide to build an MVP for this application for example And yeah, you basically have an AI agent working from your terminal.

And as we're going to see in the next few steps, you can also create full applications. So let's not waste time with this. I'm going to interrupt it and let's put it to the side. So what I did in order to uh basically install this properly locally was to go to GitHub, the official GitHub that open code has, and basically clone it quickly.

Open a new window in uh VS Code. Click on clone g repository and of course just um uh let's remove this actually and select as repository destination. Awesome. So let's give it a couple of seconds to load.

Let's open the new window. And now what we need to do is to basically open this terminal here just to have it ready. And as you can see here on our uh files and the codebase, we have a file called install. So if I just drag this inside the terminal and hit enter, you will see that uh open code will start to download which is cool.

Uh let me see if I can Yeah, let's zoom in a bit. So now that we are on 100% uh let's go back to our documents opencode.ai/doccks and let's let's actually get started with it. So as you can see here, the easiest way to install it is through the install script which uh we just run basically. And what I want to do is go to the Mac OS uh installation guide.

So I went back to the repo for open code github.com sdopen code. And in the instructions here it says the following. To run open code locally, you need bun and golang 1.24x. So bun is basically a fast JavaScript test runner.

We're going to be running some JavaScript tests in order to ensure that uh open code works properly. So we need this uh package for sure. And then go is basically a programming language that we need to use. Simple as that.

So what we need to do is to basically install those two things first. So, uh, let's go back to the repo and, uh, let's click on bun install. In my case, uh, it it will probably be installed, but sorry, bun install. No, it wasn't installed.

Nice. So, first step is to click bon install. Then we need to figure out a way to install Golang. So what I did I found uh a tutorial from hostman.com how to install go on Mac OS and it was very easy actually.

So if we follow this step by step let's first ensure that we do not have any uh go lang version working right now. So I'm copying the first uh line command line that the tutorial provided to check if there is a version. In my case there is because uh I installed it uh previously to test but we will go ahead and uninstall it just to properly install it again. So the next command is rmrf and we basically remove the local installation of go which uh was successful I believe.

Let's move to the next one. Permission denied. Oh that's interesting. Let me see.

permission denied. Uh it's not remove. Okay, I believe that we're not going to have a problem. Let's see.

We'll troubleshoot this together. So the official Golang also has a special page, but in our case, if you're using Mac OS, we can use a curl just to download this arm of Golang immediately. So this is what I'm going to do just because I'm using uh Mac OS. I'm opening a new terminal chat and I am pasting the command line and give it a couple of seconds for a full download.

And while this is happening, let's go to the number three which is to basically install the Go package. And you can do that via GUI. uh you basically run the downloaded package or we can open it through the terminal since the whole theme of this episode is terminal focused. It's very easy in the same terminal that this uh was done installing.

We can paste this command and basically it asks you for your uh user password for your uh system and after that it detects a previous installation here and the good thing is that the installer will remove any remaining uh stuff. So you just click um and and and go ahead with the installation. So I place my password everything is going correctly according to the plan and let's see setup environment variables is the next step. Awesome.

So let's give it a couple of seconds to fully uh be installed and then we will just follow the next command lines to install the variant the environment variables. Now that the installation has been successful and I hope it was for you as well, we can close this window. And as I mentioned, it's time to set the environment variables. So what I should do now is copy this simple command which is basically will navigate to the home directory.

Let's close the rest of the old terminals. Let's open a fresh one. So after this we'll just copy uh those three uh environment variables that are going to be created. So nothing crazy just hit enter and they have been created.

And after that uh this tutorial suggested test which I like. So to verify that Golang has been successfully installed to Mac OS, restart the command line and basically paste uh this checker just to see if we have the correct version. And we do 21.3 Darvin, which is great. And then let's create a new file with this uh mini app nano main.go.

So here is the main the mini app and let's basically add this hello world conclusion whenever we open this mini app and paste it in this line. This is just a test. Hit enter. Uh no not enter.

Um let me see. Ctrl X and then enter. So Ctrl X and then yes Y and then enter. And here's our mini app which says hello world.

So in order to test that now we need to basically compile this and run our program. So here let's go and copy the go run main.go main.go is the is the name of our minia and if I hit enter you will see that it says hello world. So it means that golang works properly which is cool. So now that we have Golang uh configured uh you can also hit go build uh wait go build main.go main.go I think nice.

So if you don't specify the name the command will compile the file with the standard name main.go which it didn't but it's okay. Uh but yeah you can go build test.go whatever the mini app is. It's whatever the test works. So it means that openl is properly installed.

So now the next step that you have ban installed and uh open lang installed. So go back to visual code. Let's clean up the terminal. So now back to our GitHub uh for open code.

The next step is to run bun install and bun uh notdev ban dev. So let's go back to our terminal in a fresh chat. Bon install package is installed and then ban um dev ban dev. And here we are.

Open code is officially live. And of course it would be nice to I guess install the go plugin here as well for VS Code. But let's go back to the terminal. Uh, wait.

I missed it. Where is it? Let's close this. What is going on?

Output terminal. Nice. So, here's the terminal where open Go exists now. And the cool part about it now is that this is basically the file, the code base where Open Code exists.

So, if you start chatting with Open Code here, it will probably start tweaking this code. So we don't want that. But now that it is properly installed, what we can do is the following. Uh we can for example open a new window, a new VS code project in a way.

Uh let's click on open. Let's go here to my uh data uh to my folders and basically be like uh test MVP chatbot. Let's create just like in the previous episode. Let's create an MVP chatbot and integrate it with Grock with Q and see if it works.

So now that we want to use open code, what we need to do is to basically open our terminal again. And if everything works properly, if I just type open code. Now we can have open code in our terminal. And now this specific terminal is basically registered to this uh folder this code base that we have.

In our case, it's super empty. But just like uh the previous video that I uploaded, I on one shoted kind of this uh MVP chatbot application in uh DIAD in a previous episode and I was using Cloudflare workers which is a very nice tool uh in order to basically integrate API fast and have a good back and forth between um the chatbot and the user. So, this is the prompt that I used, which is very simple. And the funny thing is that I spent so many hours um the other day trying to figure out how to build a chatbot MVP with like complex prompts and stuff.

And this simple prompt made it work. So I want to test out if I just copy this as it is and paste it to my new fresh empty folder uh with uh open code as my helper in plan uh agent I guess or maybe let's go build let's go build immediately uh if I paste this it basically register this as a as a pasted line which is good and uh I'm just going to hit enter but before I do that I want to show you how to build the actual Cloudflare worker that you are going to use. So, first of all, you need to make uh a Cloudflare account. You sign up and after that, this is probably your dashboard, your account home without the application names if it's a fresh account.

But what you need to do is go to the left side in this uh sidebar, hit compute workers, and then click on create a new one. In our case, we're going to use a start with hello world. So, an empty template basically. And the worker name is important.

In my case, I'm just going to name it test um MVP chat open code. So, it's just a test. I will delete this later. And we hit the deploy.

Once we do that, we just continue to project. And what I want to paste in uh inside open code now is going to settings and grabbing those two URLs and of course enabling the preview URL as well. So I want to grab those just to uh register with open code uh where are the actual URLs and uh which is my worker basically. So once I do that here the next thing that you want to do in my case I will use grock uh with Q with a Q.

So this Grock uh because I find it uh fast and easy to integrate AI models with it. I don't know in my previous test it it felt very easy to use and integrate. So what you need to do is sign up with an account on Gro as well and then just go to API keys create a new key. In my case, it's going to be a a dummy code that I'm going to delete.

So, I don't mind showing it now on camera, but you need to follow correct API key safety guidelines. So, I will also keep this, copy this, and basically go back to Cloudflare and my workers. And in settings, you will see um something called variables and secrets. Once you click this, you will go and add your own variable and secret.

In our case, it's going to be a secret as I mentioned. And it's going to be called Grock API key. And you're going to paste the actual value. Again, this API key is going to be deleted.

Never share your API keys. Follow correct guidelines and stay safe. So, I'm going to hit the deploy so that the worker can register the new uh API key and environment variable that we registered. And now all that's left to do is just hit enter here.

Um, and maybe yeah, just hit enter. I don't know. Let's let's yolo this. Let's see what happens.

So, as you can see here, let me try and make this a little bit bigger. Uh, open code is creating a plan. Set up wrangler configuration for cloudflare worker. Wrangler is a configuration that you also saw in the template process.

Uh, create durable object class. Implement the main worker script. Create an HTML page and add JavaScript for front- end chat functionality and API calls. So now what open code does is solely using this uh worker from Cloudflare to quickly build a light a lightweight front end application in the live preview URL and it will also add um AI capabilities to it.

So as you can see here it creates a directory in our local uh folder and it's writing index.js a lot of things happening. So here we are it also wrote a readme MVP chatbot packages for JSON. So there we are. I've created a minimal MVP chatbot for Cloudflare workers with Grog integration.

Here's what was set up. Lang wrangler worker configuration source.index chat history packages and readme. So what are the next steps? Replace your grog API key here in wrangler.toml with your actual Gro API key.

Run npm install to install Wrangler. Deploy with Wrangler deploy and then access your chatbot as the provided at the provided workers dev URL. Awesome. So, let's follow the steps.

So, let's go to Wrangler. ML and for Grog API key, we're going to paste. Whoops, I didn't have it. That sucks.

Can I actually get this from here? No. Okay. So, let's remove the current code that we have API key and let's create a new one so that we can copy it perfectly.

Nice. Let's paste this key and come back here. Edit this value. Um or maybe delete the value.

Delete and deploy. No problem. Let's add the value again. as a secret.

Let's hit deploy. And now let's go back inside here and change the key accordingly as well. Uh let's hit save. And after that, let's go back to our steps.

Whoops. There we are. So npm install to install Wrangler. Say less.

Uh can I open a new window? Awesome. So, npm install and then deploy with wrangler deploy. Awesome.

Let's paste it out as well. Not found. Maybe we need to create a fresh one. Uh let's remove this.

Let's remove this. No. Uh deploy with Wrangler deploy. Why does it not work?

Um, okay. Let's troubleshoot this with uh open code. Can you help me properly install Wrangler or any dependent C message because it says not found uh name MVP chatbot shell install. So there we are.

Open regular command. You can add this in your browser. Oh, let's see. allowing you to make changes in your cloud for account.

Awesome. Allow it. Awesome. So, what was left is granting authorization to Wrangler.

So, one quick message to open code achieved that effectively, which is nice. So, let's see if there's any other issues going on. on. on.

Um, downgrade Wrangler to version three. Okay, maybe some issues with versions going on. Let's give it a couple of seconds. So, after a couple of seconds, uh the key issue was our outdated Wrangler uh version.

Uh so, I guess that was resolved and it says that our chatbot is now live. So, without further ado, let's see if that's actually true. So, let's hit There it is. this MVP chatbot.

So now hopefully if I click on hey nice error call is not a valid JSON. So no worries. Let's hit on inspect. Let's go to our console and let's see what the error is.

Uh let's go back to Visual Studio Code. I'm still facing errors. Oops. Let's interrupt it and and paste the error properly.

Copy console. Come back here. Awesome. Let's see what the AI is going to say about this.

I feel like my Grog API key should be like that, right? or no, I feel like it shouldn't have the quotation marks if I'm not mistaken. I have no idea. Let's see.

It's going to be a nice a nice test. For some reason, I feel like it shouldn't have quotation marks. So, I feel like Yeah, we're getting models from Grock. We're changing some models now.

So I feel like there was some issue with our models. Wrangler version is still out of date. So I feel like I can run this quick command just to see if I can update this. So let's hit this quick command.

Nice. So I also updated um Wrangler. The chatbot should now work without any errors. So we fixed the fabricon issue an issue on the chat the decommission model and provided a new one and we also fixed API key quoting.

Okay so we need quoting good to know. So basically now we need to be good to go. Let's hit refresh. Let's hit.

How can I assist you today? Yes. W um I just build this up. I just built this up using open code.

You're excited about your new app. Open source development can be a lot of fun and empowering especially when you have the freedom to modify and learn from the code. Exactly. So this is basically a quick demonstration of how open code works.

Uh it's a very cool open source solution if you are if you enjoy using cloud code. I actually never used cloud code because I was kind of u afraid to get into the whole terminal thing but it actually feels super snappy, super fast, very lightweight and actually does a good job. So uh I don't want to make this video lengthier. If you want to see more examples of uh me using open code and maybe building a design portfolio or a landing page or anything similar that you might be interested in uh let me know in the comments below.

Also, if you want to become a better designer, utilize AI to your advantage to get paid more and get seen more, you can either book a discovery call with me to learn more about your blockers and how we can resolve them together, or you can join AI design club, which is a free school community that I own. So, without further ado, see you in the next one, and see you in the comments as well. Bye-bye.

What is open code? Well, open code is the AI coding agent that is open. It is flexible. It is not tied to any one provider.

You can bring your own AI provider. You can use your own API keys. You can use pretty much anything in this thing. And you can customize it to your heart's content via custom tools, custom agents, and all that stuff.

I've been using Open Code quite a bit for a long time now and really love several core aspects of it. So, I'm going to tell you a little bit about what the heck this thing is and why you should give it a try. It is free to use. So, uh there is a paid thing which we'll talk about that as well.

But, uh to use this, you just run a curl command or you can do bun whatever and this will install this as an application you can run as both a CLI or inside of a terminal UI. And the way this works, again, it has a really nice native terminal UI. Uh, multiple sessions, so you can have multiple agents running in parallel. All you got to do is just open up a new, uh, terminal tab, open code, and get going.

You can, uh, save and come back to various sessions. You can implement commands and run those commands that then trigger agents and do all that good stuff. So, I'll show you a little bit of this stuff in action, but it's a really great tool. And the one thing I really like about it is if you're paying for something like Copilot already, uh you can log into Copilot and get access to all of the Copilot models directly in open code or bring your own API keys from any of the various providers or they also often have a free uh model available for testing at any given point.

Like for instance, if we head into open code and I I do models right now, you can see that right now there are a a few free ones. Now, these might not be the best models, but if you're just wanting to give this thing a try, uh I do have a Copilot subscription. So, for me, from Copilot, I have access to all of these different models that I can use myself or again, like I said, you can uh bring in your API keys for various other things. Now the open code interface and the way that it works like if I'm in a site here and I say let's update to uh spelt 5 syntax everywhere.

Now now this type of command is obviously only going to be as effective as the model the tools that you're giving it especially with spelt 5 stuff. Uh but you can see there's a lot of nice things. There's a lot of built-in tools to this where we have things like uh to-dos. Now, I've always found to-dos outside of something like Curo to be kind of useless.

I mean, I'm sure it's not useless for the AI to be able to go through and do these things itemized, but like I like a to-do list that's a little bit more interactive where I'm able to uh tell it exactly which to-do and which variety. I think Hero really nailed that, even if their their spec flow is a little heavy-handed sometimes. But as you can see, it is going through some of this stuff and it is going to be updating it. Now, it it does actually seem like with Sonnet 4.5, it's doing a decent job of actually pulling out spelt 5 syntax.

You know, one thing it's not doing here is it's not prompting me to uh accept or do this or that. But this is just with the normal build agent. Now, in addition to a build agent, there's also a plan agent built in or you can customize your own and just hit tab to change the various agents that you have available. And likewise, when you run custom commands, you just hit forward slash and your custom commands are available as well as the commands that are baked into open code itself.

So, let's take a look at the docs really quick. Again, you can uh get going with most providers here. I mean, the directory is huge. It all is easy to set up.

Um, again, the terminal UI is nice. As you just saw, there's a number of extra built-in tools here like details, editor, exit, export, help, uh, initialize to create agents.md, which this does use an agents.md for their rules. So things are nice and standardized and normal as you might expect them to be. Uh you can always start a new session with new.

The CLI is actually really nice for one-off things. You can use the CLI just by running open code run. And what's cool about this is that means you can actually use this in things like GitHub actions if that's the type of thing you'd want to do, right? Like maybe analyze my recent pull request and generate a change set.

Um there's a number of things you can do here with the CLI that are super nice. Now you can also use it inside of things like VS Code or cursor um just by running open code in the terminal. It's a terminal UI, right? You don't have to have something special for that.

Now there's also the Zen mode. Now, Zen is a paid solution and Zen is basically you pay open code and then you get access to the models that are within Zed that are within Zen and you can see what these models are. You can see their pricing. Um, it's interesting.

I personally, since I do have a co-pilot subscription, I haven't looked into using Zen. But for people who only want to pay for one thing, one place, and you're like all bought in on Open Code, it's a nice system for them to have to just be able to have it be like no stress, sign up, just use the thing. Now, as far as configuring this thing, you can add your own tools, whether they are MCP servers or fully custom tools that are just TypeScript code. um it's really nice and you you're basically just defining things within a open code JSON.

Now the one thing I really love about open code is that sometimes these other uh CLI sometimes these other terminal UI things or AI systems in general they have like one very specific um provider specific way of doing things where with open code you can configure a lot of things and you can have uh config files that exist globally down to your root project that have different configurations. So you can have your default configurations, you can have your local project configurations, which is really great for setting things up once globally and then dialing in locally where you need to. Now also as far as rules go there is the agents.md file but just like most things in open code you can actually customize this as well. There's a global agents.mmd file in config open code agents.

However, we'll look for the local one then look for the global one which is really nice to have. You can also specify custom instructions via um an array here of various instruction files and then you can even glob every single thing inside of a directory. Now, obviously this is something you need to be careful with because if you add too many instruction files, like if you glob a whole bunch of MD files in on every single every single command, your context is going to bloat up really big and you're going to get terrible results out of the LLM. But it's really great that it gives you the option of setting up your own systems.

And as somebody who likes to do that, I I would not setting up my own systems to the point where it was probably detrimental to me. Um, you can also have custom agents and sub agents. Sub agents are specialized agents that primary agents can invoke with specific tasks. So therefore, you can have your main agent that that is like an orchestration that goes off and uses sub agents to do various things.

And likewise, I already showed you the two built-in primary agents. There's the plan mode and build mode, but again, you can specify all of your own like a spelt pro that um always wants to use the spelt MCP or has specific instructions for your specific uh way of working. And these things are great because you can give the agents uh individual permissions like you can only write, you can only read, you can run bash commands or this or that. Um it's great.

You can have access to this. You can use this specific model even if you want. You can control the temperature. You can dial it in.

Open code is really a tinkerer's dream in many regards because if you nerd out on some of this stuff, you can get in depth with it. Ultimately though, sometimes that can lead to just uh tweaking knobs on a sinking ship, right? So, it is it is like uh it's great that they give you those options though. As far as models go, Open Code uses the AI SDK and models.dev.

support for 75 plus uh LLM providers basically giving you access to most of the stuff most of the time and they're really quick on getting all of the new stuff into Open Code so you never are wondering what's going to like am I going to have access to the latest Gemini or whatever. There's themes which are great because man I love I love adding themes, right? You can just change your theme. Look at that.

You can even get a nice little preview. Uh, for somebody like me, I just like I like having that. I like having that. As dumb as it is, it it does nothing other than just makes me happy working uh with themes.

So, that's great. Uh, key bindings, you can specify your own custom key bindings if you would like. That's great. Uh, again, Open Code is very customizable, and I love that commands are super useful.

There's a number of built-in commands, but you can specify your own. Like let's say you want to have a command that just runs your your linting and then fixes things. You could just forward slash lint and fix and then uh that command is basically an MD file where you can specify some custom context for anything and it's going to be basically the instructions that the command should do. Now again these commands are not like JavaScript code.

These are markdown but you can use arguments which I actually really like. I found this to be troublesome in many other applications. But if you want arguments, you can use dollar sign the number for the number of the argument, which makes command super useful in a way where you can actually target things. When when we're working with LLM, so much of this stuff is nondeterministic that like, oh, it's really nice to be able to pass some arguments and make sure it knows what it's doing.

Uh, again, I really end up uh really liking this. The docs are great for this, too. By the way, there's also built-in formatterers so that uh your code can get formatted after changes. I yeah, I I haven't really uh used this too much because I'm I'm mostly like really in my code already.

So, the formatting is getting applied while I'm I'm not usually just like letting the LLM go to town on my code. Um permissions. You can give detailed permissions to all kinds of things from web fetch. Oh, doom loop is a uh new one.

approve whether or not a doom loop occurs where the same tool is called three times in a row. I haven't actually seen this when it was added. But that's really neat that it's there. You can also have ask permissions for anytime a file is changed or edited or anything.

So the permissions can be ask, allow, or deny. And I actually probably recommend always leaving it on ask for everything because I kind I I I kind of just like need to know what it's doing, right? I needed to ask me if it should do it. Uh there's also support for LSP servers, MCP obviously and ACP.

Uh MCP probably being the one that you use the most, but uh getting your MCP servers configured is just a matter of a very simple JSON configuration. It does not support OOTH for MCP, but it says that it will soon. So, that would be nice when that's here. One thing I actually didn't mention about agents and sub agents that I really like, as opposed to something like Claude Code where you're just like, "Hey, please use this agent and hope it does." You can actually explicitly at an agent and like if I have this quality reviewer agent, I can specifically at it and it's going to uh always invoke that agent without having to guess.

That is something that I feel like uh cloud code is certainly lacking is some of these explicit commands, explicit arguments, these types of things where uh even though they do work most of the time, you still feel like you're guessing a little bit. I like the deterministic nature of an at or an argument. And again, there's support for custom tools which can be just straight up JavaScript that is running and therefore you don't have to have it be done by an LLM and tools can be used to accomplish things all kinds of things return data in a deterministic way. Now what's cool about um open code also is that there are plugins and there is plug-in support.

In fact, like recently people were talking about, you know, Claude skills and and here's a plugin that someone created that matches claude code skills. So you can even sync skills and use claude code skills directly in open code. So having the ability to install things to augment and work with uh this system to me is one of the key features of open code. So, I recommend if you're using this stuff, if you like clawed code, if you like any of these uh copilot CLI tools or any of this stuff, I would highly recommend checking out Open Code because I do really like it and because besides being well thought of, I think it is very developer friendly.

It uh allows you to actually be in control a little bit more and it feels way less loose uh than some of the things I've experienced in some others. And the configuration options are pretty much endless and uh really great. So check it out. Open.ai.

If you hate this stuff, that's cool. If you love this stuff, give Open Code a try. All that. Either way, it's a fun project.

Something to be aware of. This is Scott. I'll see you in the next one.

What's up you guys? So, recently I've been looking for different ways to integrate AI into my terminalbased workflow with Neoim and T-Mox. Generally, I like writing my own code and knowing exactly what's going on in my codebase rather than having AI do most of the work. But, I do think it can be helpful, especially when it comes to speeding up repetitive tasks and quickly answering any questions I may have.

I've recently been trying out Open Code, which is an AI coding agent for the terminal from the people behind SST, and my experience with it has been pretty great. If you're using Neoim and T-Max like me, it's really easy to integrate this tool alongside your editor and any other running tasks you may have. Cloud code is another popular alternative for this, but I really like that with Open Code, you can just learn how to use it, how the key maps work, how to set it up, and then choose whichever AI model you want to use. Using a tool like this is really nice because it'll know the entire context of your codebase and be able to make changes, provide recommendations, or answer your questions much more effectively.

Stick around for the rest of this video to learn how to get it installed and everything you need to know to get started with it. I'll have a blog post linked in the description with all of the code and commands you might need. Also, don't forget to hit subscribe down below if you're enjoying my content. It really helps me grow the channel.

All right, so the first thing you'll need is a modern terminal emulator like Weserm, Elacrity, Ghosty, or Kitty. In my case, I'm using Weserm. If you want to learn exactly how I set up my terminal to look like this, I'll have a link for that in the description. Now, there's a couple of different ways that you can install Open Code.

You can use this command. You can install it through something like npm or if you're on a Mac like me, then you can use Homebrew. I'm going to go ahead and use Homebrew. I'm going to copy this paste it and go ahead and install Open Code.

Now, it's recommended that you sign up for Claude Pro or Claude Max. It's supposed to be the most cost effective way of using this, but again, you can use pretty much any AI model you want to use. And how much you decide to pay depends on how big your projects are. I've been using it on a relatively small project with the Pro plan.

If you sign up for one of these, then we can go back to the terminal and we can run open code off login. Then choose your provider. As you can see here, Anthropic is recommended, which is Cloud Pro or Cloud Max. And this is what I'm using.

So, I'm going to press enter here. And then you can use an API key if you want to. But in my case, because I'm using Cloud Pro, I'm going to press enter on this first option here. It'll give you this link here.

I'm going to go ahead and copy it. go back to the browser and I'm going to navigate to it and then I can click authorize here. Then I can copy this, go back to the terminal and then paste the authorization code and that's it. I'm done.

Alternatively, you can select a different provider here. For example, let's say you want to use OpenAI, then you would need to provide your API key so that you can use it. Now, as I mentioned, the beauty of this is that you can just use it alongside your other terminalbased tools like Neov and T-Mox. I've already navigated to my project and it's the default directory for my T-Max panes.

So, I can just create a couple of different panes here. I can create a vertical split and then on the left hand side create a horizontal split. I'll change the sizing with my mouse. And then, for example, I could run open code over here just by typing open code and pressing enter.

My font's pretty big so that you guys can see this clearly. So it doesn't look very good right now, but yeah. So you could have that on the right hand split. Then over here, open up Neoim.

And then down here, I could run my project. And then if I want to use the AI agent, then I would go over here on the right hand side. Then I can maximize this and then go ahead and start using it. I'm going to close open code by pressingtrl C andrl C again.

Another way of doing this, which I think I prefer, is I'm gonna close this split and then open a new T-Max window. If you don't know how to use T-Mox, I have a detailed tutorial on that, which I'll also have linked in the description. Then I can use my prefix do colon rename window. And I could call this AI for example, and then start open code in this separate T-Max window.

Then I can use my prefix A and press P to go back to my editor and the running project and control A and N to go back to the AI. If you have more than one window, then you can also use numbers. So A and zero for the project, A and one for the AI. Now once you have Open Code up and running, the first thing you should do is type slash init and then press enter.

Again, make sure you do this in the directory for your project. What this will do is have Open Code analyze your project and create an agents.m MD file in the project root. This will help Open Code understand the project structure and the coding patterns used. If I go back here to my project, maximize the editor, and open the file explorer, you'll see this new agents.m MD file in the project route.

And again, this just helps Open Code understand your project better. Open code has several different themes you can use. You can do slash themes and press enter. And then you can take a look at the different themes that are available.

In my case, I'm just using my system theme which matches the theme that I'm using for my terminal. Open code has a lot of different commands. If you type slash, you'll see a list of all the different commands available to you. Most of these have a shortcut.

Open code uses a prefix like you would have with T-Mox, for example. The default prefix is Ctrl X and then you type the key for whichever command you want to use. If I want to see the themes for example then it would be T or if you do Ctrl X followed by H then it'll show you the help. You can close this with Ctrl + C.

Now I could ask a question about how something works in the project. For example, I could ask what does and then if you want to specify the name of a specific file then you can press at and then look for the name of the file. So let's say I want to take a look at a layout file in my project. You can use up and down arrow keys to look through these or controll N and Ctrl P.

Then you can press enter to select one. And I'm just going to ask what does this file do and press enter. And then it'll give me some information about what this file does. You'll see here that on the bottom right hand corner it says that I'm using the plan agent.

There's two primary agents that you can use with Open Code that are built in. If I do Ctrl X and A, I'll see the agents. You'll see that you have the plan agent and the build agent. Again, you can go through the results with CtrlN and Ctrl P or your down and up arrows.

You can close this with escape. You should use the plan agent if you want to ask questions about your code or changes that you want to make, but you don't want Open Code to actually make those changes. It's best if you do this first. You can change to the build agent by pressing tab and go back to the plan agent by pressing tab again.

Now this is my speltkit blog. Let's say I want to make a simple change and I want to make these read more links to be a light blue for example. Then I would go back to the terminal here and I would ask it change the read more links in the home page to be a light blue color. Then it'll read through the relevant files and then explain the changes that it would make.

You can read through the suggestions. Then if I want to actually apply these changes, then I can press tab to switch to the build agent and just say apply the changes. Before I continue, I get a lot of questions about my keyboard. I use a corn version 4.1.

I run a small keyboard shop where you can configure and build your own. It's very straightforward. No soldering is required. I'll have a link for the video and the 3D builder to build your own corn keyboard in the description.

Now, if I go back to my project, you'll see that the links have changed to a light blue color, but it did change the watch video link as well, which isn't exactly what I wanted. If you want claude code to undo what it just did, then you can do slash undo and press enter. Or you can do Ctrl X for the prefix and press U for undo. It just undid the changes.

So if I go back to the project, you'll see that the changes are gone. If I wanted to redo the changes, then would be slashredo or Ctrl X and R. And now the change is back. If I want to see the change and make modifications to it, then I could go back to my editor over here in window number zero.

This is my home page in the project. It's in post listing and the change was made right here. I can also see it through git. I'm using lazy git with neoam.

You can see here under post listing we have the change here and I can make any modifications to what open code did. I'll go back to open code and do controll x and u to undo. Then if I go back to Neoim, you'll see that the code is still unchanged here. This might happen if open code modifies a file that you currently have open.

You can just do colon e and exclamation mark so that it refreshes. If you want to do this for all of your open files, then you can do colon buff do e exclamation mark. Just make sure that you've saved any of your unsaved changes. You can also share conversations that you've had with Open Code to other people in your team.

You could do slashshare to share the current session or Ctrl X and S for share. This copies a URL to your clipboard. And if you navigate to that URL, you'll see a summary of the conversation that I've had with Open Code. Be careful with this.

You shouldn't share any private or sensitive code. If you want to unshare a current conversation, then you can do slash unshare. Then if I refresh the page I have for my conversation, it'll just say page not found. Now you can also make changes to how open code works through the JSON config.

You can create a global config file in your home directory underconfig/openode or a config file for your project in the project root. You'll need to call it opencode.j. JSON. I go to the terminal here, go back to my project, and I'm going to add a new file called opencode.json.

And then you can change the models that you want to use with open code, what theme you want to use. You can create your own agents for specific tasks and even customize the keybinds. Over here, I can create a JSON object. Then you can provide the schema for autocomp completion.

It's located in this URL. And then let's say I want to modify the keybinds. I can go over here to the docs and copy the code for the default keybinds. Paste it in.

And then for example, you could change your leader key from Ctrl X to whatever else you prefer. And then all of these different keybinds will make use of the leader key. And you can modify these however you like. Let's say, for example, I changed the leader key to Ctrl S.

and I save this. You'll have to quit open code, open it up again. Then you'll see that Ctrl S here is my new prefix and I could use that to execute any of the commands. Now, another really useful feature of Open Code is being able to create your own commands.

So, if I'm over here in my project, you can create a new directory calledopencode. under it we create another directory called command and then I can create a new command with a markdown file. Let's say I want to create a command for creating a new spelt component. I can do component.md open this file up then you'll use some front matter like so and provide a description.

I'll do create a new spelt component and then I can specify the instructions. I can do create a new component called dollar sign arguments so that we can provide an argument. Then I want this to be written in TypeScript and have an empty props interface. Then I can save this.

I'll go back to open code. Close it again with Ctrl + Crl + C. Then if I type /component, we can create a new spelled component. I do need to provide a name for it.

I'll just call it new component. Now, if I go back to my code, it automatically knew to create it under lib/components. And you'll see the new component here. And this is exactly what I wanted so that I can quickly start working on a new spelt component without having to write all of that boilerplate myself.

I'll also point out that you can change the agent that it uses. By default, it uses build, but you could use the plan agent. And you can also change the model that it uses to something else. All right, you guys.

So, that's pretty much it for this video. There's other stuff you can configure and do with Open Code. I'd recommend you take a look at the documentation for each of the different things that you can configure. I hope you enjoyed this video and found it interesting and helpful.

If you did, don't forget to leave a like down below. Let me know in the comment section if you have any questions or feedback for me or other content ideas that you would like to see from me. Don't forget to subscribe to this channel. It really helps me out.

That way you can stay up to date with more content like this from me. See you guys in the next one. Peace. [Music]

So, you're a Neo Vim user and you've not quite figured out the best way to implement AI into your workflow. Here it is. So, the reason why I think Open Code is great is simply because it's made for the command line. It's made for the terminal.

If you're comfortable working in the terminal, this is the perfect way to implement AI into your workflow. It's got um some Nevin plugins which aren't official, but they are pretty good. And yeah, let's just go through them. So, first things first, you just want to install it.

Now, I've just installed it with Brew, but obviously just install with your package manager of choice. Now if we open a terminal here and all you want to do when you first start is do open code or login and then you can just pick any any provider that you want. So I've gone with anthropic and I've just uh purchased a month membership of claude for example. You can use GitHub, you can use open eye and you can actually use API keys if you don't uh want to pay a subscription.

You can just pay as you go as well. There are also some free ones if you go into the open router. There's some free models in there as well. Once you got your authorization set up, you can just simply run open code and you're now in open code.

Okay, the first thing you want to do is to slash models. Now, this will bring up all the models that you set up for. So, I've set up anthropic and I've set up um OpenAI as well with a with API keys. So, you're going to want to do SLM model and then just pick the model you want to use.

I'm going to use Claude. And then if you just look in the bottom here, it says build agent. Now, that means that I'm in build mode. If I press tab, if I press tab, I'm going to switch to plan mode.

Now, whenever you're in plan mode, it won't execute any commands. It will just suggest things for you to implement. And you can prompt it to sort of fine-tune the plan before you let it commit any code. And then you go into build mode when you're ready for it to start running commands.

Or if you don't want it to do that at all, that's fine. You don't have to do that. And I should also mention you can have a separate model for planning and a separate model for building. So when you're in plan mode, first thing you want to do is do slashinit.

Now this will give it um basically an opportunity to make scan your whole repo and make some context about how the repo works. So if we open up nevim here and we see what agents MD it's added, it's basically reference from the whole repo what this is. So it's a go flappy bird game. Here's how you run it, some build commands, etc.

The code style, error handling, things like that. So in whatever repo you're in, you're in, it'll make an agent.mmd file which basically gives the agent or the AI the context before it gives you any further in further instructions. So for example, if you say that you use constants in uppercase, then it won't give you any suggestions that don't follow that code in standard for example. So if I just run the application here, and I'll just show you exactly what we have so far.

So this is just a little side project I made a while ago just while I was learning a bit of go game development. Uh, but basically it's just a Flappy Bird clone. It's got some bugs, but you know, you can go through the pipes, you can crash into the pipes, etc., etc. Quite cool.

Uh, let's just get it to do some very basic things. So, as you can see up here, the score and the high score is very small. Let's see if it can fix that for us. So, I'll jump into open code here and I'll just say let's make the score and high score much more visible and let's see what it does.

So, it's going to talk us through all the changes it's going to do. It's going to give us a plan and then it's going to tell us what it would do. And then if you're happy with that, you can swap it into build mode and it'll add the changes or, you know, you can do it yourself. to give you some suggestions.

That's what AI is great for, bouncing ideas off. It's like speaking to someone without to disturb someone. You just, you know, you're bouncing ideas off it. You get some suggestions and you can obviously do it yourself.

So now, let's swap it into build mode and say yes, let's go through the plan cuz as you can see, it's suggested updating the font size and things like that. And that's exactly what I was going for. So now it's going to update the score rendering for better visibility with a bigger size, maybe change the position, etc. And let's see what it does.

So, as you can see, it has now made the changes and it's actually run the program. So, we can see what's going on here. And as you can see, it is much more visible and it actually looks a bit more like the official game. So, we have the two as the best score.

Now, it's zero. And as you can see, it's great. You know, it's working great. Now, let's say we want to increment this more with Neoim, right?

Because at the end of the day, we're users, right? So, if we open Neoim, I'll just show you uh my config. So, if I go to my lure file, plugins AI, I've got a plugin here called uh open code.nv. Now, this is made by a guy called Nick Van Djk, and I think it's absolutely perfect.

There's multiple ways you can use it. You can have it so you have um open code terminal running inside your neim. So, it'll be somewhere like here, you know, there'll be a big sidebar similar to like a cursor looks like. Uh but the way I prefer to use it is literally just with the key mappings.

So if I go to my main.go, let's go to my draw function which is what's responsible for drawing everything in um EB engine and I just highlight this function for example and I do leader OA. I can ask open code anything about this selection that I've just selected in the I say what does this do? I can send that message. And now because I've got open code open in another terminal, it's just asked it directly in this terminal.

As you can see, main.go main.go. What does this do? So, it's asked this in this second terminal as it connects to the open code instance already running. And as you can see, look, it's now reading the file, reading the lines.

It's telling us this code handles the bird sprite animation based on the player's movement direction. It checks if the bird is falling. If it's falling, it'll be a down flap. If it's rising, it'll be an up flap.

Now, this in my opinion is a great application of an AI. You know, you're just using it to quickly gain context. Obviously, you could give it a much, you know, you could give it this whole draw function and it would tell you exactly what the whole draw function does, breaking it down. Uh, very useful if you're joining a new repository and you want to know exactly what's going on.

You want to get the context quickly, you know, great great way to do it. Similarly, there's another thing you can do which I like is you can say give me a code review and let's see what it says. So, it's going to look at the git difference of the changes it just made. So, it made the UI better, right?

So, as you can see, strengths, yep, four times the scale, the current score, two times higher score, better UI, better UX positioning, uh visual depth, shadow effects, add contrast against the background, etc., etc. And then it also goes through issues, magic numbers, etc., etc., etc. So, this is great before you just push push your branch uh to a code review at your workplace. You know, give get yourself a little code review before you push it uh to catch the little silly mistakes you might have made.

And I'll just show you one last thing. So, you can do um a command called show prompt. So, I think it's leader op. And then you can prompt open code.

If you look down here, prompt open code to explain the code near the cursor, fix diagnostics, or review the whole buffer. This is another thing you can uh add um as well. So there we go. Open code.

Possibly one of the best ways to implement AI into your Neovim setup. I think it's great. Built for the terminal, made by people who actually use Neo Vim. It's perfect.

Let me know what you think. See you later.

Today we're going to be looking at how to code and build anything with open code which is an open-source AI coding agent you can download for free. So if we click on download over here I'm going to download this for Mac and then we can start getting access to this. All right you can get this available at open codeai and then you can download it for free and then from here we're going to start coding this out. Once you've downloaded it let's open it up and we'll test this out.

All right so we'll click on that install that open up open code as you can see. Click open. And now we can start coding out with this. Right.

So we're going to click on open project and we'll start a new folder here. And now you can see that's what it looks like. All right. Now if we go to this section, you can see we can choose between build and plan.

And then you can actually choose the model that you want. Now there are actually five free models you can choose between. So GPT5 Nano, Big Pickle, GLM 4.7, Grocode Fast One, and Miniax M2.1. Right?

And these are free models that you can actually code with which is absolutely amazing. And then you can always add more models from providers here. So for example, you could use open code Zen, Anthropic, OpenAI, Google, Open Routter. So you get the opportunity to connect these other things as well if you want to.

Versail as well, which is pretty cool. And then you've got a bunch of other providers right here as well. Right. The other cool thing is you can use O Lama cloud.

So you could actually use free APIs to code with that too. Let's pull in an example here. Now, if you want to connect Anthropic, you would just add your API key and then from here, you can start building stuff, right? So, I'm actually going to use Anthropic cuz I'm loving Claude at the minute.

But if you want to use the free models, you just pick one of those at the top. All right. So, let's click on Anthropic. Then, we're going to click on Claude Pro.

Authorize app, get that code, paste it into open code here, and now we've connected it as you can see. All right. Now, if you're not sure what to build with this, maybe you have some ideas or you're not sure where to start, etc., Then what you can actually do is if you go into claude or whatever AI you use dayto-day you can just say something like based on what you know about me give me 10 powerful ideas apps websites tools and games I could build the prompts with right and then we can for example build this out so [snorts] what I'm going to do here is I am going to generate a quiz funnel right and this is going to be an interactive quiz ask people about their business and needs and recommends specific AI tools ending with the AI profit boardroom upsell as the ultimate solution for implementation right so we're going to copy that from Then I'm going to go back over to open code and we'll plug in the prompt right here. Now again, you can plan this or you can build this.

If I don't have a plan out yet, then I'm going to click on plan first. Right. Then we're going to select our model. So I'm going to go with claude.

Um we'll go with Opus 4.5, which I think is the most powerful. You can also upload and attach images as you can see right here. Um if you press command and plus on a Mac, then you can zoom in. Okay.

So if you have an idea of what you want it to look like or similar color schemes or branding then you can always attach an image over here as well. And from here it's going to start building this out. And now it's given us the full plan if we zoom out. So we can see what it's going to look like the file structure the key features and it's planned out like the everything else.

Right. So from here we're now going to change to build and we'll say build this out. So it's generating a to-do list of everything that's going to create for the project as you can see and it will build out all the features. Now, in the meantime, whilst we're waiting for that, what I'm going to show you is the 30-day system to build anything with open code, right?

And you might be thinking, okay, what is open code? How does it work? It's an open source AI coding agent. It lives in your terminal, your desktop app, or your VS code editor.

You tell it what you want to build and plain English, right? It writes all the code for you, debugs problems, understands your entire project, and connects to over 75 AI models, including claw, cheap, and gemini. And the cool thing about this is, you know, why this matters is here's what most people don't understand. It's like every business is now like a software business whether you know it or not, right?

Because the businesses getting the most leads are the ones that have custom tools. Lead mappers actually work calculators that qualify prospects. Automations and follow up instantly. And the old way was to like hire a developer.

That could be expensive. You could wait weeks and you'd have to hope that they understand what you wanted. The new way is that you describe what you want to open code, what you build in minutes, test it, tweak it, deploy it, and that's it. And so what we're going to do, for example, is we're going to build out some stuff like you see right here.

But if you do want a 30-day terminal builder blueprint, then you can get access to that inside the video notes from today, right? And it shows you, for example, how to create your own AI agents, tools, SAS, and all the prompts you can use to build that out, too. So, if we go back to open code now, it's beginning to work through each of the to-do lists. As you can see, some people are saying Claude Opus is not free.

Yeah, like I mentioned before, if you want to use the free APIs, then you would use Big Picle, GLM4.7, T5 Nano, Grocode, Fast One or Miniax M2.11, right? These are the free APIs. I'm using Claudeopus because I prefer it for coding, but you could always switch to T5 Nano, for example, and just use that as a free API. So, you can see it's working through the to-do list over here.

We can also have multiple windows opening and building at the same time, I think, as well. So if we click on the toggle sidebar at the top, you can see this is the chat for building out the interactive quiz. Now if we click on plus here, we can actually start a new session and then start building directly inside here. For example, you can go inside the chat and you can say okay build out a simple to-do list mini app.

It will create the plan first and then build it. If you do want to add a new provider later, then you can actually click on connect provider over here and then from here you can go on to to that. Also, you can open your existing projects as well. So you can select this and then open your existing projects.

So thanks so much for watching. That is basically how to use open code to build anything. I've actually got an extra tutorial inside the video notes from today. So if you go to the AI success lab, you'll see a community with 43,500 people.

And then if you go to the classroom here and then go to January, you'll see all the video notes from today. So, you've got the resources, all the video links. You have the full framework and the 30-day plan about what we've talked about today. Also included 30 different prompts that you can use to build with open code to build basically anything you want.

And that's basically how to use it as you can see today. Now, if you want to get access to a community with some of the best AI builders in the world who are winning with AI, then you can check out the AI profit bordering. All right, inside the community here, you'll get access to 2,000 serious AI builders who are interested in building and growing with you. You can post your questions and I'll personally answer it as well as the rest of the community.

You can post your wins and that sort of thing as well. Lots of people winning with AI here. And then also, if you go into the classroom, you can basically solve most of the issues that people struggle with, right? So if you want to for example get help with business and AI automation then you would check out the six week masterass that takes you from complete beginner to expert with AI right if you struggle with overwhelm then you can actually check out our focus manual which is a focus protocol and that helps you cut out all the noise and the shiny object syndrome that comes with AI.

On top of that, inside the playbook here, you'll get access to my process for generating AI avatar videos, which tons of people ask me for. And then also, you can get my full course on how to land more clients for your agency or as a freelancer right here. On top of that, if you want to learn AI SEO automation, we have a full course and breakdown over here. So, everything you need to win with AI is inside the AI profit boardroom.

And also, you can get access to four weekly coaching calls. You can jump four coaching calls a week asking the questions you have with a PhD trained scientist in AI and just get help and support whenever you need it. Now if we go back to open code let's check out the project that should be built out now and we'll open this up and there you go. That is the to-do list built with AI as you can see just as a simple example.

Obviously you could build much more interesting stuff from this and it actually works late. So we can click that off or we can X off that. And that actually gave us the instructions to run it on our terminal as well. Simple and easy.

Thanks for watching. Appreciate it.