Hi, welcome to another video. So I recently covered the Klein upgrade that basically added the new MCP support and made it quite cool, as it

allowed you to extend Klein even more by giving it tools that it doesn't have. You can check that video out and

understand how it all works because it's really cool. But recently, they have done some even newer upgrades, and it's now

the 3.0 version of it. So let me tell you everything about it, what's new here, and

how you can use these new features. But before we do that, let me tell you about today's sponsor, Ninja Chat. Ninja Chat is

an all-in-one AI platform that gives you access to more than 10 models, like Claude 3.5, Sonnet,

GPT-4, Gemini, and even image generation models like Flux and video generation models like Chroma, and much more, all in

one place for a price that's even cheaper than one ChatGPT membership, starting at only $11. Not just that, they have a bunch of

AI tools that can help you use these models in intricate ways. They have also recently added an Artifacts feature to

their platform that now allows you to generate code, preview it, and share it with others using preview links, which is

great. It can even run Python code and create charts. You can check them out through the link in the description and make

sure to use my coupon code KING2 to get an additional 25% off these already great deals. First of all, the major new feature

that this release added is the option to auto-approve steps. Yes, you can now just tick a checkbox to

auto-approve tasks in Klein, and if you send any task to Klein after enabling it, then it won't ask you to approve

anything and will just do what it sees fit. You can choose from a list of options about what you want to be auto-

approved, and what requires approval, like enabling or disabling reading files and directories, editing files, executing terminal commands using the browser, and

using mCP servers. So that's good. Another thing that you can now configure is the limit for how many API requests Klein makes

before asking for your approval to keep going. So you can now set a limit of API requests that it can make before asking

for your approval. This is going to be really cool because many times a client can go on a token rampage, but this will now make

sure that you are safe. Another thing is that it can now also send you system notifications to tell you when it needs approval,

intervention, or if it completes the task. So you can now put it in auto-approve mode, do something else, and then

get a notification when it's done. It's quite cool as well. Apart from this, it now also uses a diff editing format. Diff

editing format is actually very good, and AER uses it a lot. It basically just asks the LLM to give a small block of code

to replace, and also the code it needs to be replaced with. This saves a lot on tokens when used in larger files because

it doesn't need to stream the whole file again. There's also a new Klein rules file. This is super great because it

allows you to create this Klein rules file in any of your projects and then enter the rules that you'd want it to

follow. It's the same as the cursor rules file, if you want to compare it to something. Anyway, that's what it majorly

has now. Let me show you how you can use it and how everything in this new upgrade works. So first of all, make sure

that you upgrade Klein to the latest version. Once done, you will now have the latest features. First, first of all, you can now

see that you have this auto-approve feature. If you click this, you'll see options on the screen that allow you to

Configure what things you want to be auto-approved and what you think should be asked before being done. Let's say

that you don't want it to always ask for approval to read files, then you can just check this one.

And it will automatically read the files. If you also want it to autonomously edit files, then it can do that as

well. Or if you think it should also automatically run potentially safe commands, then it can do that as well.

It's quite cool. Here you can also set the maximum number of requests that the client can make autonomously before

asking you for approval. So this is also great. Apart from this, you also have the system notification feature which now

allows you to send system notifications if you want to use that. Now let me show you how it works, so

I have enabled everything here, including reading files, editing files, terminal commands, and everything. I also set a limit of 10

requests. Now let's ask it to make a simple new Rust project that takes in unsorted, comma-separated numbers, sorts

them, and returns them. Let's send it. Okay, it's now doing that. So now you can see that it won't ask anything from us

because we have it in auto-approve mode. You can see that it creates the project and everything, which is pretty great.

Let's wait a bit, and it's now done. So this is now done, and you can see that

running it also works fine. So this is pretty amazing to see. You can just let Klein do its own thing after giving it a

test ask, and then you can come back once it has done everything. So this is pretty amazing, to be honest. Now, apart from this,

there's the diff edit format that it can also use, and it's on the inside, so you won't see that here, but

One thing we can see is that we can now make a clean rules file in it, which allows us to define rules for a client to

follow. Then it can read this file in every task and make sure it doesn't do anything outside of the

rules. So, one of the things I do with my rules file is that I just tell it to log

every change and give a little detail about how it did the changes and how many files it changed in another

Markdown file called `changes`. So now I have this client rules file, and it should automatically write the changes it does to the `changes`

Markdown file. So let me ask it to print the numbers in descending order. Now it's again in auto-approved mode, and it will

do the same stuff again. If we wait a bit, then you can see that this time it is writing to the `changes` Markdown file. If

we wait a bit, then you can see that the task is now done. And if we look at the

`changes` file, you can see that it wrote the changes it made. This is a really good thing to have

in your rules because it allows you to keep track of every change it is making in a simple way. So this is a great

feature I have been waiting for for a long time, and it finally has that. It is just amazing to see such great updates

happening, genuinely lifting the tool to a whole new level. I won't be using the auto-approved stuff as much, but I'll

surely be using the client rules feature. It was already cool, and now it's even cooler. Overall, it's pretty cool anyway.

Let me know your thoughts in the comments. If you liked this video, consider donating to my channel through the Super Thanks option below, or you can

also consider becoming a member by clicking the Join button. Also give this video a thumbs up and subscribe to my channel. I'll see you

Cline 3.0 (Upgraded): This is the ULTIMATE AUTONOMOUS AI CODER that we need! (Auto mode, Rules, etc)

Facing the future with AI! 

Here you'll find content about multiple AI Tools that are actually useful and sometimes free.

AICodeKing

Introduction to Klein 3.0 upgrade and its new features.

Introduction of sponsor, Ninja Chat, an AI platform.

Ninja Chat features: access to multiple AI models and tools.

Klein 3.0 New Features: Auto-Approval and API Request Limits

Configurable limit for API requests before approval.

System notifications for approval, intervention, or task completion.

Implementation of diff editing format for code changes.

Introduction of the new Klein rules file for defining client behavior.

Instructions on upgrading Klein and accessing new features.

Configuring auto-approval options for file reading, editing, and terminal commands.

Demonstration of auto-approve mode with a Rust project example.

Example of using the rules file to log changes to a Markdown file.

Summary of the presenter's opinion on the new features.

Call to action: donate, become a member, like, subscribe.