Decoding Agentic Engineering — Skills, agents.mmd & AI Workflow Architecture

Source: YouTube deep-dive on agentic engineering tooling

Full transcript of a deep-dive covering the three core skills used for agentic engineering: code structure skill, GP loop skill, and code simplifier skill, along with the difference between skills and agents.mmd files and how to architect efficient AI workflows.

Full Transcript

After the last video, a lot of people have been asking me what skills do I use when building applications when I’m doing agentic engineering. And I’m going to give you those skills. I’m going to give you my agents.mmd file, but I’m going to 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. So, I have three skills that I use. Nothing crazy. I have a code structure skill, which is my own that I developed. I have a GP loop skill, which is skill by Greal, my code review agent, and code simplifier, which is a skill by Claude. I’m going to share with you all the skills. It’ll be linked in the description and I’ll explain how each works.

But I also have an agents.mmd file. Now, one thing you’ll notice is there are a lot of videos where they’ll pit skills versus agents MD like one’s better than the other. I use both. And 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.mmd file is given to the agent every single time. Let 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. Forget about resources. I want you to focus on metadata and instructions.

The 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? And 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 dub.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. I 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.

Now this is very important. Let me just show you a real life example. So this is my code structure skill and if I go to code right here you’ll see the same structure. This is the metadata and then everything under the metadata is the instruction.

Why Skills Are Powerful (Token Efficiency)

The reason why skills are powerful because they are a need to know basis. Skills aren’t injected — the entire skill isn’t injected in the context. What’s injected in the context is the metadata. I’ll explain this clearly. If you’re confused don’t worry I got you.

Let’s go to OpenAI’s tokenizer. And this is all going to make sense. Now, whenever you create a markdown file and you tell the agent to read the markdown file, the entire markdown file is going to 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 AA agent, right? That’s about 944 tokens, right? It’s not a lot of tokens, but it can add up, right? Imagine in every chat conversation you have, you’re adding 944 tokens to the agent.

Now, what if the only thing in context was the name and the description? That’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. The reason why this is awesome is because I have more context window, right? I’m not wasting my context window. And 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.

Using Skills in Practice

So a perfect example I can give you is I have this skill right here, right? Code structure. And 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 very clean pattern for code to be written for the agent to continue to understand even for me to review. Right? So this restructures the code that the agent has generated because most of the time agents are just generating slop code.

This structures it. Let’s say I wanted to run the code structure skill. The basically the way I would do it is I can show you an example here is I would just run /code structure and I would just hit enter. And in doing that the agent basically calls the skill file, reads the instructions. Right all it has in its context is the name and description. So it calls the skill, reads the instruction and then executes.

Now the key difference with agents.mmd. The agents.mmd file is given to the agent every single time. And the benefit of this is the agent knows all your preferences upfront. So both are very powerful in their own ways. For example, with code structure skill, it’s doing a very very specific thing. It’s restructuring your code, right? You know, a GP loop skill might be creating a loop for you. A code simplifier is simplifying the code. So in that case, skills, they’re very specific.

Now the best way to think about this is if you want a very specific action that only gets invoked when the agent knows you need it, you use skills. If you want the agent to know something all the time, you use agents.mmd file. And there’s also Claw.md, which is similar but for Claude Code specifically. They each have their place in the stack.

Let me walk you through my agents.mmd file so you can understand how I set up my complete workflow. My agents.mmd file has everything the agent needs to know about my preferences — how I like code structured, what frameworks I prefer, my testing philosophy, my deployment pipeline preferences. This is loaded into context on every single turn, so the agent never forgets who it’s working with.

So what’s actually in my agents.mmd file? A lot. It tells the agent my preferred stack, the architecture patterns I use, the way I name things, how I handle errors. It prevents the agent from having to guess. If you’ve ever used an agent that starts writing things in a style you don’t like and you have to keep correcting it, that’s because you don’t have a good agents.mmd file.

The Three Core Skills

Let me break down each skill.

Code structure skill — This is my own developed skill. It restructures generated code into a service layer architecture. The output follows a clean pattern that both the agent and I can understand when reviewing. It’s like having an automatic code reviewer that reformats everything into a consistent structure.

GP loop skill — This is a skill by Greal. It’s my code review agent. It creates loops for processing. This is useful when you have repetitive code patterns that need to be generated consistently.

Code simplifier — This is a skill by Claude. It simplifies the code an agent generates. Agents have a tendency to over-engineer or write unnecessarily complex solutions. This skill reins that in.

Live Examples

So I want to show you a real example of how this works in practice. I’m going to go to my project where I have a new agentic workflow. I’ll load my agents.mmd file. Now notice that the agents.mmd file has all my preferences. Right now the agent knows exactly how I like things done.

Now I’m going to ask it to do a task. It’ll use the agents.mmd to understand my preferences and then if it needs to restructure code, it’ll do the code structure skill. If it needs a loop, it’ll use the GP loop skill. If it needs to simplify some generated code, it’ll use the code simplifier skill.

And this is the powerful thing — you don’t need to manually invoke each one. The agent knows based on its knowledge of me and the skill metadata which tool to use in which situation.

Claw.md for Claude Code

Now there’s also Claw.md. Claw.md is essentially the same concept as agents.mmd but specifically for Claude Code. Claude Code reads Claw.md at the start of every session to understand your preferences. The difference is that agents.mmd works across different agent platforms and tools, while Claw.md is specifically designed for Claude Code’s internal workflow.

So if you’re using Claude Code, you want both. You want a Claw.md that tells Claude Code how to behave, and then you want skills for the specific actions you need it to take. If you’re using other agent platforms like Cursor, Windsurf, or Continue, you use agents.mmd with your skills.

Token Budget Management

This is one of the most overlooked aspects of agentic engineering. Every token you put in context is a token that can’t be used for reasoning, for code generation, for understanding your actual problem. Skills solve this by keeping only 53 tokens (the metadata) in context at all times, compared to 944 tokens for the full file.

Let me show you the math. A single full skill file at 944 tokens. If you have five skills, that’s almost 5,000 tokens permanently in context. That’s 5,000 tokens you’re paying for in every single API call, 5,000 tokens that aren’t available for the actual thinking your agent needs to do. With skills, you’re paying 265 tokens total for the metadata of all five skills — a 95% reduction.

Conclusion and Best Practices

So to wrap it up, here’s my recommendation:

Use skills for:

• Specific, repeatable actions
• Token efficiency (53 tokens vs 944)
• Need-to-know basis invocation
• Code structure, GP loops, code simplification

Use agents.mmd for:

• Always-present preferences
• Your coding style and conventions
• Framework and stack choices
• Testing and deployment philosophy

Use both together:

• agents.mmd tells the agent who you are
• Skills tell the agent what to do
• Together they create an efficient, personalized workflow

Skills are on a need to know basis. Agents.mmd or Claw.md is what you want the agent to know all the time. Both are necessary. Both are important. This is how I use it. Let me know in the comments down below what you want to see next. Thank 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. Peace.