# Are You Missing Out on Agent Skills? Here's How They Work > Source: > Published: 2026-07-17 20:32:30+00:00 *Hello, I'm Rijul. I'm building git-lrc, a micro AI code reviewer that runs on every commit. It's free and source-available on GitHub. Star git-lrc to help more developers discover the project. Do give it a try and share your feedback* Do you keep hearing terms like “agent skills” being thrown around without really understanding what they mean? And is the FOMO starting to get to you? Let’s understand what agent skills are in this article. A skill is a way to give an AI agent **procedural knowledge**. At its core, a skill is simply a `SKILL.md` file. But what exactly does this file contain? At the top of the file, we have the YAML frontmatter. At a minimum, it contains two things: This identifies the skill. This tells the agent: The description essentially acts as the trigger condition for the skill. Below the frontmatter, we have the body of the file. This contains the actual instructions. It explains what the agent needs to know to perform the task. For example: Skills can also contain optional directories. This can contain executable code that the agent can run when needed. This directory can contain additional documents that the agent can refer to. This can contain static resources that may be needed while performing the task. An agent can have a large number of skills. But this raises an obvious question: **If an agent has hundreds of skills, does loading all of them consume a huge amount of context?** This is where a concept called **progressive disclosure** comes in. The information is loaded in three stages. When the agent starts, it loads only the name and description of each skill. This allows the agent to understand what skills are available without loading all of their instructions into the context. When the description of a skill matches the task, the agent loads the full instructions from that skill into its context. Scripts, references, and assets are loaded or used only when they are needed. This prevents the agent from loading everything at once. There are a few concepts that may sound similar. MCP gives agents the ability to interact with external tools and APIs. It is mainly about **what the agent can reach**. RAG retrieves relevant information from a knowledge base. It is mainly about giving the agent **reference material and factual knowledge**. Fine-tuning changes the model's weights. The knowledge or behavior is effectively baked into the model itself. Skills are different. They provide the agent with **procedural knowledge**. They tell the agent: A skill can also use other technologies, such as MCP. For example, a skill could provide the instructions and judgment for **when to call a particular MCP tool**. This format is based on the open standard from Agent Skills. It has also been adopted by AI platforms such as Claude and Codex. This makes skills a useful way to package and share procedural knowledge across different AI tools. There is one important thing to keep in mind. Skills can execute scripts. That means installing a skill is not always as simple as downloading a text file. A malicious skill could potentially introduce risks such as: So you should treat skill installation similarly to installing any other software. Only install skills from sources you trust, and review what they contain before giving them access to your AI tools. So that's it about this article, see you on the next one! AI agents write code fast. They also silently remove logic, change behavior, and introduce bugs -- without telling you. You often find out in production. [git-lrc](https://github.com/HexmosTech/git-lrc) fixes this. It hooks into git commit and reviews every diff before it lands. 60-second setup. Completely free. Any feedback or contributors are welcome! It's online, source-available, and ready for anyone to use. Give it a ⭐ [star on Github](https://github.com/HexmosTech/git-lrc)