# Skills in AI and Agentic Systems ## Problems Across Individuals and Engineering Teams Today One common problem is the **lack of reusable skills and processes**. The context required to perform a task is often scattered across: * Prompts * Documents * Previous conversations * Individual knowledge and memory As a result, the AI may be capable of performing the task, but the **working context is not clear or consistently available**. For example, imagine having to review the PRDs (Product Requirement Documents) of 30 students. Every time, you may need to provide the AI with the same instructions: * Check whether the problem statement is clear. * Identify missing functional and non-functional requirements. * Check edge cases. * Review technical feasibility. * Evaluate whether the scope is realistic. * Suggest improvements. * Create an HLD, LLD, and Technical Requirement Document with a proper implementation plan. Instead of repeating these instructions every time, we can turn them into a **Skill**. * * * # What is a Skill? > **A skill is a reusable package of task-specific instructions.** Let's break this definition down. ## 1\. Task-Specific Instructions These are instructions that tell an AI **how to perform a particular type of task**. For example, if we frequently ask an AI to review PRDs, we might define instructions such as: * Check whether the problem statement is clear. * Identify missing functional and non-functional requirements. * Check edge cases. * Review technical feasibility. * Evaluate whether the scope is realistic. * Suggest improvements. * Create an HLD, LLD, and Technical Requirement Document with a proper implementation plan. These instructions define **how the task should be performed**. * * * ## 2\. Package Instead of typing these instructions every time, we put them together into one organised unit. For example: ### PRD Review Skill ```text PRD Review Skill │ ├── Review problem statement ├── Check requirements ├── Check edge cases ├── Check technical feasibility ├── Evaluate scope └── Provide recommendations ``` This entire collection of instructions becomes a **skill**. * * * ## 3\. Reusable Now imagine that you have 30 student projects. ### Without a Skill You might repeatedly write: > "Review this PRD. Check the requirements, architecture, feasibility, scope, and edge cases..." Then again: > "Review this PRD. Check the requirements, architecture, feasibility, scope, and edge cases..." And again for every student. This is repetitive and can also lead to **inconsistent reviews**. ### With a Skill You can simply say: > "Use my PRD Review Skill on this document." The same set of instructions is then applied consistently to every project. This makes the process: * Reusable * Consistent * Easier to maintain * Less repetitive * * * # A Simple Real-World Analogy Think of a **dosa recipe**. A recipe for making dosa contains a sequence of instructions: ```text Mix rice + dal ↓ Soak ↓ Grind ↓ Ferment ↓ Cook ``` You don't reinvent these instructions every time you make dosa. The **recipe is reusable**, but it is also **specific to making dosa**. Similarly: > **Skill = Recipe for an AI task** The skill tells the AI **how to perform a particular task**. * * * # Examples of Skills | Skill | What it teaches the AI | | --- | --- | | **PRD Review** | How to evaluate a PRD | | **Code Review** | How to review code | | **Resume Review** | How to evaluate a resume | | **Meeting Summary** | How to turn a meeting transcript into structured notes | | **Research** | How to conduct and present research | | **SQL Debugging** | How to diagnose SQL problems | Each skill contains the instructions and knowledge required to perform a specific type of task. * * * # Skills in the Context of AI Agents Skills become especially useful when building an **AI agent**. Instead of putting every possible instruction directly into the agent, we can give the agent access to different skills. ```text AI Agent │ ├── PRD Review Skill ├── Code Review Skill ├── Research Skill └── Documentation Skill ``` When the user asks: > "Review this PRD." The agent can use the **PRD Review Skill**. When the user asks: > "Review this code." The agent can use the **Code Review Skill**. This allows the agent to select the appropriate process depending on the task. * * * # The Key Idea The most important idea to remember is: > **A skill separates "how to perform a task" from the AI itself.** The AI provides the general intelligence. The skill provides the **specific process, instructions, and context required for a particular task**. * * * # What Can a Skill Contain? A skill can include: * **Workflow** — The steps that should be followed * **Examples** — Examples of good and bad outputs * **Templates** — Standard formats for producing output * **Company policies and terminology** — Organisation-specific rules and language * **Reference documents** — Documents that provide additional context * **Optional scripts** — Scripts that can help perform parts of the task * * * # Prompt vs Skill vs Tool vs Plugin It is important to understand the difference between these concepts. | Concept | Simple Meaning | Example | | --- | --- | --- | | **Prompt** | What you ask the AI **right now** | "Review this PRD." | | **Skill** | A reusable **how-to process** for a particular job | "Here is how to review PRDs." | | **Tool** | Something the AI can **actually do or access** | Search the web, query a database, create a Jira ticket | | **Plugin** | A **package** that distributes capabilities such as skills, tools, or connectors | A packaged capability that can be installed | A simple way to remember this is: ```text Prompt → What should I do? Skill → How should I do it? Tool → What can I use to do it? Plugin → What packaged capabilities can I add? ``` * * * # Another Simple Analogy: An AI Chef Imagine an AI as a **chef**. ## Prompt You tell the chef: > "Make me pasta." That's the **prompt**. It tells the chef what you want **right now**. * * * ## Skill The chef has a standard pasta-making procedure: ```text Boil pasta ↓ Prepare sauce ↓ Add vegetables ↓ Mix ↓ Season ↓ Serve ``` That's the **skill**. It defines **how the chef should make pasta**. The same skill can be reused to make pasta for 10 different customers. * * * ## Tool The chef needs equipment to actually perform the work: ```text Knife Pan Stove Oven Blender ``` These are the **tools**. The skill says: > "Chop the vegetables." The tool allows the chef to **actually chop them**. So: ```text Skill → "Chop the vegetables." Tool → Knife ``` * * * ## Plugin Now imagine a company sells a: > **Professional Italian Cooking Kit** It contains: ```text Italian cooking recipes + Special cooking techniques + Specialised kitchen integrations ``` You install the whole package. This is analogous to a **plugin** — a packaged capability that can provide multiple related capabilities to the AI. * * * # Putting Everything Together The concepts can be visualised like this: ```text USER │ │ Prompt ▼ "Review this PRD" │ ▼ AI Agent │ │ Selects ▼ PRD Review Skill │ ┌───────┼────────┐ ▼ ▼ ▼ Workflow Rules Examples │ ▼ Tools │ ┌──────┼─────────┐ ▼ ▼ ▼ Search Database Jira ``` The **prompt** tells the agent what the user wants. The **skill** tells the agent how to perform that type of task. The **tools** allow the agent to actually perform actions or access external information. The **plugin** can package and distribute these capabilities. ## In one line > **Prompt = What to do** **Skill = How to do it** **Tool = What you can use to do it** **Plugin = A packaged set of capabilities**