The Only Best Claude Code Features You Need
AAI LABS
Computing/SoftwareSmall Business/StartupsManagementInternet Technology
Transcript
00:00:00It's the middle of the year and Claude Code has already released more than a hundred features,
00:00:04but even though most of them might look cool and sound useful, in practice you don't use them a lot.
00:00:09We realize this as we're actively working on projects, both external and internal like our
00:00:14custom-made community platform AI Labs Pro, because when you're actually building something,
00:00:19the setup for most of these features is too much and only a few of them matter.
00:00:23Now if you're new to the channel then welcome, we're a software company and this is AI Labs,
00:00:27where we show you how to optimize a business with AI using proven methods from our own team.
00:00:32And in this video, we went through the entire list of features and put together the ones we use the
00:00:37most throughout our process. Now most of the people here use Claude Code to automate their own workflows,
00:00:42but Claude Code isn't really user-friendly for non-technical people and other people here in
00:00:47HR accounts and recruitment find it hard. But to save on costs, we're not issuing everyone a separate
00:00:52$20 plan. Instead, we're setting up a chat platform for them which uses cheaper Claude
00:00:57models through API, because they don't need to use Opus or even Sonnet for their workflows.
00:01:02Haiku performs really well for their tasks, that way they can just interact with it easily and
00:01:07still get the MCP connections and their own department's knowledge and workflows. But the
00:01:11hardest part of building this platform was authentication. Connecting across multiple MCPs is hard for
00:01:17non-technical people and they get stuck going through the setup of all these tools. Claude makes
00:01:22it easy through connectors, but we don't have that. And that was why we used Scalekit, who is the sponsor of today's video.
00:01:28Scalekit is a complete tool built for developers building AI agents. It is basically one single login for all your agents.
00:01:35It lets the agent log into multiple apps and take actions on your behalf as the connected user.
00:01:40It keeps all your credentials in one place, so we don't have to deal with all that hassle ourselves.
00:01:45Normally you need to get API keys and connect MCPs using that, but this becomes a middle layer and the agent
00:01:51only needs to connect this one middle layer. And since each member of our team is connected to their
00:01:55own Slack, Gmail and Notion, their agents need access to those accounts too. So Scalekit really simplified that
00:02:01whole authentication process for us. We've got role-based access set up, so each role only gets the specific
00:02:07documentation and access that it needs. And to connect an app, you just click one link and authenticate it.
00:02:12That makes things way easier for non-technical people, and it simplifies a ton of the setup for us.
00:02:17Because everything the agents do runs through that one layer, Scalekit's not just handling the login,
00:02:22it also keeps a log of every action, like which app each agent interacted with and what actions were
00:02:28taken. That matters a lot because it is used by the whole team, so you want to be able to see exactly
00:02:33what the agent's been doing. And this ties right back to why we were building the chatbot in the first
00:02:38place. We're going to use the Claude Agent SDK with the Haiku model because that's what makes
00:02:42it affordable to run the whole team off one shared agent. To use Scalekit with Claude Code, you just copy the
00:02:48install command and run it in the terminal. It also connects the Scalekit MCP, so you don't have to manage any of the
00:02:55configurations yourself. Now the first feature that we've used a lot is Agent Teams. Ever since it dropped, we've been using it
00:03:01across multiple projects. It's not available up front in the product, it's behind a hidden flag that you set once, and after that the
00:03:08Agent Teams feature shows up. The way it works is that it spins up a bunch of different Claude Code sessions using Tmux,
00:03:14which is basically a terminal tool that lets you run several sessions side by side in one window. It then hands off
00:03:20tasks to those sessions. Now you might be thinking how is that any different from sub-agents? Well, what's different is that the
00:03:26agents in a team can actually talk to each other, which is something sub-agents can't do. So this way they can share their
00:03:30findings back and forth and coordinate their tasks. And this is especially helpful in workflows like adversarial reviews, basically where one agent picks the work apart and another responds to what it finds. So you can give it a prompt to create an agent team for a code review. One agent finds the issues and the other one implements the fixes. And this streamlines the whole thing by letting the
00:03:50agents collaborate. The alternative would be one agent writing its points into a doc and another one reading them, which takes time. That also makes the review serial, so you'd lose the parallel work that Claude Code is so good at. When you run it, the finder starts hunting for issues while the fixer just stays idle. And the moment the finder spots one, it messages the fixer, which implements the fix right away. But this is a really token heavy workflow, so keep that in mind when you're using it on your own projects. Another feature we use is the advisor feature, which improves the performance
00:04:20of Claude code, even with smaller models. It basically lets Claude consult a stronger model whenever it gets stuck and needs advice. This one's experimental, and again, another token heavy feature that's still in preview. So whenever it hits a complex decision or a problem, it takes advice from the advisor model, which is usually a stronger, more capable model, then it uses that guidance to solve the issue. We've set the strongest model available, which is Opus 4.8 at the time of recording, as the advisor, and Sonnet as the main agent doing the implement.
00:04:50So when we were building this chatbot, there were a bunch of issues it kept running into. And while fixing those issues, it would sometimes reach a point where it felt like it just wasn't capable enough on its own. At that point, it would call the advisor, which would then suggest the path it should take to implement the solution. So that's how it finished the implementation without needing much input from us at all.
00:05:10The advisor basically looks ahead, spots things that could cause issues down the line, and reports them. And based on the advisor's guidance, the weaker model then implements the solution. We've made a full video on Claude's advisor and how you can make the most of it, so you can check that out on the channel.
00:05:26Another one we use a lot is the goal feature. It was built to handle long-running tasks better. You just specify the condition and the metric your task needs to hit in order to be marked as done. If you don't know how it works, it's basically this. You give it a task and define an end state. Basically, a condition that tells the model the task has been done correctly. It then sets that as the goal and keeps working until it gets there.
00:05:47Now, this goal system works by having a smaller, less powerful model like Haiku do the cross-checking. It confirms whether the app or the feature got built the way it needed to and whether it actually works.
00:05:57So if you run the goal command, you'll see which goal is currently active. And once it starts, it begins building the things that are needed. Then it just keeps working until that smaller model marks the app or the feature you asked for as done. It might finish in a single turn or it might take way longer, all depending on the task.
00:06:13Another one we use most commonly is the auto mode feature. It's basically a simple long-running alternative to dangerously skip permissions. This one was important because agents started getting a lot better at handling long-running tasks and a lot of people started using them for big projects.
00:06:28And the most annoying part was that in normal mode, we'd have to manually approve every single permission prompt. And that basically kills the whole benefit of letting agents run on their own. So this works by giving you a middle ground.
00:06:40Dangerous skip permissions lets the agent literally run every command. Auto mode instead gives you way fewer permission prompts with a much lower risk of running something dangerous.
00:06:49And this is basically done using a classifier. It reviews each action and checks for risky commands like mass deleting your data, sensitive data exfiltration or running malicious code and it blocks them.
00:06:59So this classifier stops the agent from taking dangerous actions that dangerous skip permissions would have just automatically allowed. So that's what we do when we're building with agents.
00:07:08Since we're letting agents run on long-running tasks, we just let the agent run in auto mode and handle everything on its own.
00:07:14Now there's another feature that not a lot of people use, even though everyone really should. It's sub-agent isolation at the git work tree level.
00:07:22Normally agents spawn and work in the same working directory. But agents with this flag enabled basically spawn in their own isolated work trees by default.
00:07:31And work tree isolation is really important because every single change a sub-agent makes is literally in its own separate directory isolated from the rest.
00:07:39We use it a lot when we have to test multiple variations of the same feature like a UI. We can just let it work in separate work trees instead of editing the main one.
00:07:48And we also mentioned that we always create HTML mockups for design variation testing. But we use sub-agents with work tree isolation too, because HTML mockups are limited and aren't wired up to the backend.
00:07:59So if we want to test the whole flow of the app with the data and the authentication actually working, we go for separate work trees for those variations and interact with them properly.
00:08:09So when the flag is set, you give it a prompt and it spawns the number of sub-agents you asked for, then waits for each one to finish.
00:08:15Once they're done, each one gives a report on what it did. And after that, we can check the styles they created and see for ourselves how the different variations look.
00:08:23Then from the variations we like the most, we just ask it to merge those changes into the main design and throw the rest away.
00:08:30There are a bunch of other commands built into the product that are purely there for reviewing code, to make sure what you've built is actually good quality.
00:08:37And these are based on the skills and commands that the creators of Claude Code use themselves in their own workflows.
00:08:43The first one is the security review tool, which basically runs a complete security review of all your code based on a set of predefined guidelines.
00:08:51The second one is simplify, which basically reviews your code for reusability, simplification and efficiency.
00:08:57It simplifies the code and makes sure there's no leftover bits in there that aren't being used anymore.
00:09:02It also streamlines whatever it can based on the strict rules set by the creators.
00:09:06And then there's the code review tool, which basically goes through your code for bugs and places it can run more efficiently.
00:09:12And then there's ultra review, which came out recently.
00:09:15It basically kicks off a cloud agent that runs the reviews and bug checks up in the cloud.
00:09:19And ultra review works better than a normal review because it splits into multiple branches
00:09:24and each one gets its own independent verification pass.
00:09:27That's why it catches deeper issues than the local checks from the other commands.
00:09:31The security review command is one we run a lot, especially while building the chatbot.
00:09:35And that's because we needed to be really careful about prompt injections and other security issues,
00:09:40especially since we'd given the agent bash tools too, which let it run commands on the system.
00:09:45Now, another one we use a lot is the loop feature.
00:09:48Loop is basically a cron job, which is just a task that runs on its own on a repeating schedule.
00:09:53So you can tell it to run at a specific time and it'll keep running that same prompt over and over at that set time.
00:09:59The only thing is it keeps running only as long as the session is active.
00:10:03So the loop ends once the session ends.
00:10:05So we were keeping our knowledge base in a database called ChromaDB.
00:10:09It stores the company's process docs as vector embeddings,
00:10:12which is basically a way of turning text into numbers so the agent can search through it by meaning.
00:10:17And we needed a way to keep that base updated.
00:10:19We update it for all the departments by adding markdown files and PDFs to a specific folder.
00:10:24So you can create a loop that runs at the end of each day, runs the ingest command and updates the knowledge base.
00:10:30And you can run this either on the cloud or locally.
00:10:32The benefit of the cloud is that the session wouldn't need to stay active for the loop to keep running.
00:10:37But since we were running this on a Mac mini, we chose the local option.
00:10:41That way, if any new processes get added to the knowledge base, we don't need to manually sync them.
00:10:46Claude just syncs everything automatically on the next scheduled loop run.
00:10:49And here's the real benefit of using loop instead of a traditional cron job.
00:10:53If it hits any kind of error, it can actually cross-check it, fix the issue,
00:10:57and make sure the task finishes properly without needing any input from us.
00:11:01Now, a lot of people are already familiar with Claude's goal command and the loop command.
00:11:05But there's another command called monitor that a lot of people don't know about.
00:11:09And it's a really important part of the development workflow.
00:11:12This one's especially helpful if you're building agents like we were.
00:11:15How it works is, you give it something to monitor, like your logs or a running process,
00:11:19and it just keeps an eye on that for you.
00:11:21It only reports back when it finds an anomaly, basically something that's off.
00:11:25If everything's normal, it just keeps running quietly in the background.
00:11:28We use it a lot in our workflows.
00:11:30For example, while we were developing and testing our app,
00:11:33we had the agent leave logs and ask Claude to monitor them in the background.
00:11:37It would report any actions the agent was taking that it shouldn't have been.
00:11:40But before Claude set up the monitoring task, it first went through the app and the agent set up.
00:11:45It wanted to figure out what kinds of anomalies could even happen in the first place.
00:11:49In our setup, those included the agent straying from its intended workflow,
00:11:53tool calls failing, loading too much data at once from Notion or Gmail documents,
00:11:58and role-based permission issues.
00:12:00And once it had figured out those potential problems, it started monitoring.
00:12:03Then, as we interacted with the agents, the monitor reported issues like failed tool
00:12:07calls from the Gmail fetch tools.
00:12:09And that let us quickly spot what was causing the problems and fix them properly.
00:12:13Now, all the skills, workflows, and everything else we build and show you in these videos
00:12:17can be found in AI Labs Pro, which is our community.
00:12:20That's where you'll get the resources, the starter packs, and more,
00:12:23along with a place to interact with a bunch of like-minded people, including our team.
00:12:27So, if you've found value in what we do and want to support the channel, this is the best way to do it.
00:12:32The link's in the description.
00:12:34That brings us to the end of this video.
00:12:35If you'd like to support the channel and help us keep making videos like this,
00:12:39you can do so by using the super thanks button below.
00:12:42As always, thank you for watching, and I'll see you in the next one.