17:06Ras Mic · Tutorial
Trust Me, You're Sleeping on Cloud Agents
A walkthrough of the four ways cloud-hosted coding agents replace manual bug verification, QA, and code review — plus the setup behind all of it.
July 15thThe argument in one line.
Skills and agents.md solve opposite problems: skills conserve context by staying dormant until explicitly invoked, while agents.md burns context deliberately to enforce workflows the agent would otherwise forget.
Read if. Skip if.
READ IF YOU ARE…
- You build with Claude Code or Codex and your agent keeps producing unstructured, hard-to-review code.
- You want an automated quality gate that loops without you babysitting every PR.
- You are confused about when to use a slash-command skill vs. a CLAUDE.md or agents.md file.
- You already have some skills or a CLAUDE.md but have not thought systematically about what belongs where.
SKIP IF…
- You have never shipped code with an AI agent and are not actively trying to.
- You want a deep-dive on any single tool -- this is a workflow overview, not a product tutorial.
The full version, fast.
Every Claude Code skill injects only its name and description into context (53 tokens), not its full instructions -- those load on demand when invoked. An agents.md file does the opposite: its entire content loads on every turn. The practical split: put non-obvious workflow rules and source-code references in agents.md because the agent always needs them; put triggered procedures like code restructuring and quality-loop reviews in skills because you want to fire them deliberately. The greploop skill closes the feedback loop by reading Greptile PR scores automatically and pushing fixes until it reaches a five out of five.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 00:20
01 · Hook and promise
Addresses the recurring viewer question about which skills to use; promises to share the skills, the agents.md, and the reasoning behind both.
00:20 – 01:59
02 · Skills overview and anatomy
Lists the three skills. Explains skill architecture: metadata at top, instructions below. Demonstrates with a real code-structure skill file.
01:59 – 04:27
03 · Token-efficiency argument
Uses OpenAI tokenizer to show loading a full skill costs 944 tokens vs. 53 tokens for metadata-only. Demonstrates the agent fetches full instructions only when it needs the skill.
04:27 – 05:52
04 · Daytona sponsor
Sponsored demo: Daytona sandbox spins up in 30 seconds, forks the project, installs dependencies, and launches an OpenCode agent.
05:52 – 07:00
05 · agents.md contrast
Explains that agents.md injects its full content on every turn. Draws the contrast using an Excalidraw 272k context window diagram.
07:00 – 09:03
06 · What belongs in agents.md
Two entries: a detailed branching and PR workflow, and a reference to a local gitignored folder of open-source tool repos. Both are things the agent must know every turn.
09:03 – 09:52
07 · Why skills stay out of agents.md
Clarifies the split: restructure, greploop, and simplify are triggered manually. agents.md is for behavioral rules, not procedural skills.
09:52 – 12:08
08 · Greploop deep dive
Walks through a PR where greploop ran for 19 minutes, looping on Greptile feedback until hitting five out of five.
12:08 – 12:53
09 · Code simplifier and wrap-up
Introduces the Anthropic official /code-simplifier. Used by feel when code looks too complex. Closes with the rule restated.
Lines worth screenshotting.
- A Claude Code skill injects only 53 tokens per turn (name + description); the full instructions load only when the skill is explicitly invoked.
- agents.md injects its entire content on every single turn -- putting rarely-needed skills there wastes context window on every message.
- The practical split: skills for triggered procedures you want to fire yourself, agents.md for behavioral rules the agent needs to remember always.
- Do not put codebase technology information in agents.md -- the agent can search the code. Reserve that space for non-obvious workflows.
- A quality-gate loop that auto-repeats until it hits a five out of five score eliminates the need to manually chase down code review feedback.
- Storing open-source repos of your tools in a local gitignored folder gives the agent up-to-date API knowledge without flooding context.
- Most agents produce unstructured code by default; a code-structure skill enforces a consistent service-layer architecture without re-explaining it every session.
- Running a code simplifier by feel -- not on a schedule -- is a legitimate workflow when the goal is readability, not performance.
- The difference between 944 tokens and 53 tokens compounds across hundreds of turns; token discipline is a real competitive advantage in long sessions.
- Greptile AI code review almost always catches a security issue or bug even on features you tested yourself before pushing.
Two tools that look redundant but are not.
WHAT TO LEARN
Skills and agents.md belong together in the same workflow precisely because they do opposite things with context.
- A skill injects only its name and description on every turn (53 tokens) and loads full instructions only when explicitly invoked, so you can have dozens of skills without burning context.
- agents.md loads everything it contains on every single turn, making it the right place for rules the agent must follow habitually, not procedures you want to trigger yourself.
- The decision rule: if you want to fire it yourself at specific moments, make it a skill; if the agent would break your workflow by forgetting it for even one turn, put it in agents.md.
- A gitignored folder of open-source repo source code gives the agent accurate up-to-date API knowledge -- the agent searches it rather than loading it, so context stays clean.
- An automated code review loop that repeats until it hits a target score is more reliable than a single review pass -- there is almost always a security issue or bug that surfaces only after the first fix.
- Putting technology-stack facts in agents.md is wasted space -- the agent can read the code. Reserve agents.md for non-obvious decisions a new contributor would not guess from the repo alone.
Terms worth knowing.
- Skill (Claude Code)
- A markdown file with a name, description, and instructions that Claude Code registers as a slash command. Only the name and description are injected into context automatically; the full instructions are fetched on demand when invoked.
- agents.md
- A project-level instruction file injected in full into the agent context on every turn. Used for persistent behavioral rules and non-obvious workflows the agent must follow at all times.
- Greploop
- A Claude Code skill by Greptile that reads a PR AI code review score and comments, pushes a fix, waits for a new review, and repeats until the PR achieves a five out of five confidence score.
- Service layer architecture
- A code organization pattern that separates concerns into distinct layers, making agent-generated code easier to review and extend.
- Greptile
- An AI code review tool that analyzes pull requests, assigns a confidence score out of five, and leaves line-level comments with suggested fixes.
- Daytona
- A cloud sandbox provider that spins up isolated development environments for testing applications; sponsored this video.
Things they pointed at.
Lines you could clip.
00:45
“Skills are on a need to know basis where agents.md file is given to the agent every single time.”
10:25
“It just loops it. Just loops it. Just loops it until it gets a five out of five.”
09:31
“Do not put code base information in agents.md. The agent knows. It can search the code. This is specific workflows that are not natural to it.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
00:00After the last video, a lot of people have been asking me what skills do I use when building applications, when I'm agentic engineering. And I'm gonna give you those skills.
00:08I'm gonna give you my agents dot m d file, but I'm gonna share with you the thought process, how these tools work so you can use them effectively when you're doing your agentic engineering. Let's get straight into it.
00:18So I have three skills that I use. Nothing crazy. I have a code structure skill, is my own that I developed.
00:23I have a greploop skill, which is skill by Grebtop, my code review agent, and code simplify, which is skill by Claude. I'm gonna share with you all the skills. It'll be linked in the description, and I'll explain how each works.
00:33But I also have an agents dot m d file. Now one thing you'll notice is there are a lot of videos where they'll pit skills versus agents m d, like one's better than the other. I use both.
00:42And the reason why I use both is both do different things. For example, with skills, skills are on a need to know basis where agents dot m d file is given to the agent every single time.
00:55Let me explain this step by step. With skills, for example, you need to know how a skill is architected, how it's written. A skill has metadata, it has the instruction, and then it has resources.
01:07Forget about resources. I want you to focus on metadata and instructions.
01:12The metadata often looks like this, a name and then a description. The name is the name of the skill, and the description describes what the skill does. Right?
01:21And then after the metadata, the name and the description, then come the instructions. Basically, telling the agent how it's supposed to do whatever it's supposed to do. For example, I have a YouTube analytics skill, and it basically pulls clicks from dubb.sh and it pulls stuff from Notion and it pulls analytics from YouTube and it does some math and it presents to me a report.
01:42I created a skill for that. But what's interesting is all skills are structured the same. Name, description, metadata, and then everything below that is an instruction.
01:52Now this is very important. Let me just show you a real life example. This is my code structure skill and if I go to code right here, you'll see the same structure.
02:01This is the metadata and then everything under the metadata is the instruction. The reason why skills are powerful because they are a need to know basis.
02:11Skills aren't injected. The entire skill isn't injected in the context. What's injected in the context is the metadata.
02:19I'll explain this clearly. If you're confused, don't worry. I got you.
02:21Let's go to OpenAI's tokenizer and this is all going to make sense.
02:25Now whenever you create a markdown file and you tell the agent to read the markdown file, the entire markdown file is gonna be in the context. Right? So let's say this skill that I have, this entire file, let's say I put this in the context of the agent.
02:40Right? That's about 944 tokens.
02:42Right? It's not a lot of tokens but it can it can add up. Right?
02:45Imagine in every chat conversation you have, you're adding 944 tokens to the agent.
02:51Now what if the only thing in context was the name and the description?
02:58That's what makes skills awesome. The only thing you can see the token difference from 944 to 53 tokens. The only thing injected in the context of the AI agent, of the model when you're using skills is the name and the description.
03:13The reason why this is awesome is because I have more context window. Right? I'm not wasting my context window.
03:19And the reason why I say it's a need to know basis is because the model only invokes the instructions when it knows it needs the skill. So a perfect example I can give you is I have this skill right here, right, code structure.
03:31And if we look at this skill, basically, what it does is it rewrites the code in a service layer architecture. Right? This is in a way a a very clean pattern for code to be written for the agent to continue to understand even for me to review.
03:44Right? So this restructures the code that the agent has generated because most of the time agents are just generating slop code. This structures it.
03:52Let's say I wanted to run the code structure skill. The basically, the way I would do is I can show you an example here is I would just run slash code structure and I would just hit enter.
04:03And in doing that, the agent basically calls the skill file, reads the instructions. Right?
04:10All it has in its context is the name and description. It reads the instructions and then it knows what to do. That's what makes skills so powerful.
04:17It's on a need to know basis. Right? When you hear the word Daytona, you probably think of fast cars.
04:22When I hear it, I think of the most performance sandbox provider, and that is confirmed by this benchmark by Compute SDK. When you flip through all the different benchmarks, all the different tests, one thing that you see in commonality is Daytona is number one.
04:35And this isn't me just trusting a benchmark. I use Daytona in this app called Feedback. This is an internal tool for my product studio.
04:42It's basically our own internal vibe coding tool. And Daytona is the sandbox provider that powers this app. And what I'm going to do is I'm going to test this project in a Daytona sandbox.
04:51All I have to do is click test in sandbox. You're going to see how quickly it's going to spin up a sandbox instance. It's going to fork the project.
04:59It's going to install all the dependencies, and it's going to test if this application is working by running a build. That literally took thirty seconds.
05:06I'm now going to click create app, and then what I'm going to do is I'm going to open up an instance of the app. So it's gonna set up a new sandbox and preview environment. It's going to install a selected agent.
05:16I have OpenCode as the default agent, and you'll see in just a few seconds, I'll be able to give feedback. In just a few seconds, I have my application running in a sandbox with an open code agent. I can see the files here.
05:28I have access to a terminal. This is the terminal running in the Daytona sandbox. I also have live diagnostics.
05:34All of this is possible thanks to Daytona. Check them out in the link in the description down below. If you use my code, you get a $100 free credit.
05:41Make sure to go check them out. So I want my agent to be able to know how to structure code. I want my agent to be able to run a loop with Greptile so we can review the code and get a five out of five score.
05:50I want my code to be simplified. So I use these skills. And again, all of these will be linked in the description down below, and I'll explain them in a second.
05:58Here's what's interesting about agents m d. They're very different from skills because the agent m d file is injected in the context window every single turn.
06:07So if we were to think of this as a the context window, let's say this is a 272,000 context window, you know, you have the system prompt and all that, like, internal stuff the model has, and then the agent's MD, and then the conversations. Right?
06:21The back and forth that I'm having with the model. With skills, the only thing that gets loaded with skills is the name and the description.
06:31And, again, I showed you the difference. Right? If I loaded the entire skill, it'd be 944 tokens.
06:36But because we're just loading in the name and description, it's only 53 tokens. With agents dot m d files though, the entire thing is loaded in the context at every turn. So we gotta ask ourselves, what kind of files are we going to put in agent dot m d's?
06:53Right? What kind of information, sorry, are we gonna put in an agents dot m d? And for me, it's stuff that the agent needs to know all the time.
07:00So I have a specific branching and PR workflow. You can see here it says, use staging as the integration branch for feature work, create a feature branch from the latest staging, preferably in an isolated work tree under work trees. Open small focused PRs from each feature branch into staging.
07:15Do not merge unrelated feature work into another feature branch unless the PR is intentionally stacked and the dependency is real. Keep PRs reviewable for code review agents split by feature, ownership boundary, or behavioral surface rather than accumulating a large mixed diff. After a feature PR merges into staging, update any active feature branch from staging before continuing work.
07:36Promote staging to main only when the integrated set of changes is ready to for release. I need the agent to know this all the time. All the time.
07:43And then another thing I have, I use this tool called open source. I actually did a video about it. I'll share it with you right here.
07:49It'll be linked in the description down below. And, basically, what open source does is it downloads the source code of whatever tool I'm using in the code base.
07:57For example, you can see here it's grayed out, and the reason why it's grayed out is this is not getting pushed to GitHub into production. But I have a bunch of repos here. For example, browser use, composeo, uh, Daytona Cross Mint, OpenClaw.
08:11My my boy, uh, Chris Sorooki dropped an agent. I downloaded that here. Super Memory AI.
08:17So all the tools that I'm using that are open source, I will have their code bases downloaded in this folder. And the reason being is because the models might not be trained on the most up to date information, I will tell the agent to reference the source code so it knows exactly what to look for.
08:32Now a lot of you think that it's going to have the entire code base in context. No. The models have the ability to search.
08:39Right? So if I say, oh, how do remote functions work in SvelteKit? It knows to search for remote functions.
08:45They're not going to go through the entire code base. Right? So this makes it very good for me to get up to date information to my agent and I tell it that it has access to this tool.
08:55This is something I want the agent to know every single time.
09:00Now that you know the difference between skills and agents.md files, skills are a need to know basis. Right?
09:05Imagine I put my skill files in the agents dot m d. It it doesn't need to restructure the code all the time. It doesn't need to run a greploop all the time.
09:12It doesn't need to simplify the code all the time. Right? I want the features to be done, and I wanna be able to trigger these things myself.
09:18The agents dot m d file, this is information I want the agent to know all the time. Now for, you know, for the love of all things, do not put the code base information. They they don't say, oh, this is a React code base.
09:30The agent knows. It can search the code. Right?
09:33This is specific workflows that are not, let's say, the word natural to it. That's what you're gonna put in the a j s dot m d file.
09:40Now in terms of my skills, code structure I explained. This restructures a given piece of code in a service little architecture.
09:48I love this. I'll link it down below. Take a read at it.
09:51Greploop is one of my favorite skills in pair with greptile. Now, greptile does sponsor some videos, but this video is not sponsored.
09:58I generally love and use greptile. And basically, what this does is I can give you maybe a very concrete example here, a PR right now. Okay.
10:07Let me pull up this one right here. So actually, it's got a five out of five. So maybe let me pull up another one.
10:12Oh, this one has a five out of five as well. Let's see if this one doesn't have a five out of five. Oh, this one has a five out of five as well.
10:19All my PRs are golden. Let's say I push a feature and I get a confidence score of a three out of five. What I would do, and I have tons of examples here where you can see here, I ran slash greplu 128.
10:31That's the PR number. And basically, what this does is it will you you can see that it worked for nineteen minutes. Right?
10:39So what the a skill tells the agent to do is it reads the PR information, right, the review that Greptile left. And if you're wondering what information I could show you right here, you can see, like, the summary and all that stuff it leaves.
10:54It also, like, leaves, like, comments right here. Like, you you could see, like, oh, highlights code, gives you comments. It even gives you the prompt to fix it.
11:01So what the grep loop skill tells the agent to do is to pull all this information from the PR, analyze the information, push a fix, and once it pushes a fix, it waits for a new review. If that review is not a five out of five, guess what it does? It loops again.
11:16That's why it's called grep loop. And for me, this has been the best feedback loop ever. Right?
11:21Because I will go back and forth, plan with the agent, build with the agent, tell the agent to build it, and then I will test the feature obviously locally. But after I've tested the feature, I want the coding agent to review it. And when it reviews it, it almost always catches some security issue, some bug.
11:36There's always something that gets caught. Greptile gives the agent the feedback it needs. I then run greploop, and then it just loops it.
11:43Just loops it. Just loops it until it gets a five out of five. I did a full video on my workflow.
11:48I'll share it with you right here. It is fantastic. Right?
11:51I love this skill. And finally, the final skill, this is by Claude themselves by the Anthropic team, this and is a code simplifier. Now I run this every now and then when I'm just, like, looking at code and it just feels too complex and I'm not understanding what's going on.
12:05I just run code simplifier, and it basically preserves functionality, simplifies thing. It's actually a great skill to use.
12:11I use it based off vibes. I don't really have, like, a structure as to when and where I use it. But when I just feel like something's a little too complex, I use a code simplifier skill and it simplifies the code base for me.
12:23So there you have it. You have my skills. You have my agents dot m d.
12:26You understand what skills I use and how I use them, why I use them. You understand what's the purpose of an agents dot m d file and what information I have of it. Skills are on a need to know basis.
12:37Agents dot m d or claw.md is you want the agent to know this all the time. Both are necessary.
12:42Both are important. This is how I use it. Let me know in the comments down below what you wanna see next.
12:46Thank you so much for watching this video. Make sure to like, comment, subscribe, hit the notification bell. I'll see you in the next one.
12:51Peace.
The Hook
The bait, then the rug-pull.
The question that keeps landing in the comments after every workflow video is always the same: which skills, exactly? Here, the answer is three -- and the more interesting half of the explanation is why those skills live in a completely different place than the agents.md file sitting beside them.
Named ideas worth stealing.
00:45model
Skills vs agents.md split
Skills = need-to-know (metadata only in context). agents.md = always-on (full content every turn). Skills for triggered procedures; agents.md for persistent behavioral rules.
Steal forany project where you want a lean context window while keeping deep procedural skills available
09:52model
Greploop quality gate
- Push feature branch
- Greptile reviews PR and scores it
- If < 5/5: agent reads comments, pushes fix, waits for re-review
- Loop until 5/5
Automated code review loop that eliminates manual PR iteration.
Steal forany team shipping features through pull requests with an AI code review agent
07:54concept
Source code reference folder
Gitignored local folder of cloned open-source repos. agents.md tells the agent it has access; agent searches rather than loads into context.
Steal forany project using third-party tools that may have updated APIs since the model training cutoff
How they asked for the click.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
