Divya van Mahajan

Agent Skills Masterclass

ai-daily-brief-podcast

Agent Skills Masterclass – Study Document

Overview

This talk is a practical deep-dive masterclass on building, deploying, and managing AI agent skills. It is presented by Nufar Gaspar, in conversation with the host of the AI Daily Brief podcast. The session builds on a prior introductory “skills primer” episode and is intended as a hands-on operator playbook. The central thesis is that agent skills — portable, human-readable instruction folders — are the foundational primitive of the emerging AI agent era, and that individuals and organizations who invest in building high-quality skill libraries will see compounding productivity and capability gains.

Source video: URL not available (originally aired approximately April 2, 2026 on the AI Daily Brief)

Prerequisites

  • Basic familiarity with AI chat tools (Claude, ChatGPT, Gemini, Cursor, etc.)
  • General understanding of what AI agents and agentic workflows are
  • Awareness of prompt engineering concepts (system prompts, custom GPTs, Gems)
  • Familiarity with markdown file format and basic folder/file structures
  • Some exposure to the concept of agent skills (the prior AI Daily Brief “skills primer” episode is recommended as a foundation)

Main Points

What Agent Skills Are

  • Skills are folders (not just single files) containing instructions, scripts, and resources that give AI agents and tools an actionable playbook for executing specific tasks.
  • Skills operate in two modes:
    • Agent-discovered: the agent autonomously detects and invokes the relevant skill from the enabled environment.
    • Human-triggered: the user invokes a skill via slash commands or verbal cues (e.g., saying “research this topic” fires a custom research skill).
  • Skills are highly portable — stored as human-readable files with no proprietary format, moveable between tools, and editable by anyone without an engineering background.

Why Skills Are the Future Standard

  • Approximately 44 tools already support skills and the number grows daily; includes Claude (Anthropic), OpenAI’s ecosystem, Cursor, Windsurf, GitHub, Notion, and others.
  • Skills solve the key limitation of custom GPTs and Gems: those were locked to a single platform; skills travel with you.
  • Skills that come from third-party marketplaces (e.g., Anthropic’s skills repo, OpenClaude marketplace) should be treated like installing third-party software — read carefully, verify the source, and be cautious about permissions they may invoke.

When to Build a Skill

  • Strong signals to build a skill:
    • You do something more than three times.
    • You keep pasting the same instructions repeatedly.
    • You need consistent output across uses or users.
  • Additional motivations:
    • Standardizing how work is done across a team.
    • Unlocking tasks you previously lacked the bandwidth or know-how to accomplish.
  • One skill per task — if a skill is trying to do multiple separate jobs, split it into separate skills.
  • Building your own skills is recommended over copying from marketplaces, especially early on, because it develops the foundational capability; downloaded skills can still serve as templates rather than wholesale copies.

Anatomy of an Effective Skill

A well-constructed skill should include:

  1. Trigger — the most critical element; precise wording for when the skill should fire. Be explicit and loud rather than subdued; models may skip past weak triggers.
  2. Body (steps) — written as numbered steps or bullet lists, not prose. Structured instructions become the agent’s literal action plan.
  3. Level of freedom calibration — be prescriptive for fragile/precise tasks (e.g., database migrations); allow creative latitude for open-ended tasks (e.g., strategy docs).
  4. Output format — include an example output, not just a description. Show a table with headers, a document section structure, etc.
  5. Gotcha section — highest-signal content; explicitly instructs the model where it typically goes wrong, what assumptions it should not make, and what failure modes have been observed during testing.

What to avoid (skill killers):

  • Weak or vague triggers
  • Over-defining/railroading the model (especially on creative tasks)
  • Stating what the model already knows (wastes tokens)
  • Skipping the gotcha section
  • Monolithic single-file blobs instead of structured folders

Skill Folder Structure Best Practices

  • Keep the main skill file under 500 lines — it is a playbook, not an encyclopedia.
  • Move reference materials and context into separate files within the skill folder.
  • Put long input/output examples in a separate examples.md file inside the folder.
  • Deciding what goes inside the folder vs. external pointers:
    • Context specific to this skill that should travel with it → put it in the skill folder.
    • General context about you or your organization → point to an external source.

Concrete Skill Example: Meeting Prep

A more advanced skill was walked through:

  • Trigger phrases: “prep for the meeting,” “meeting prep,” and several variants.
  • Bundled context: stakeholder profiles (fixed or transient), email history, calendar data, open action items.
  • Steps: identify attendees → collect context → analyze agenda → run scenario analysis → generate brief.
  • Output: defined in a separate attached file due to length; includes executive summary and scenario planning sections.
  • Gotcha examples: do not infer attendee importance from title alone; do not fabricate company details; do not skip the “what could go wrong” analysis.
  • Nested sub-skill: a simulation skill that generates 6–7 scenarios (e.g., attendee with a hidden agenda, difficult questions, sales objections) for meeting rehearsal.
  1. Research with Confidence — includes defined sources, time horizons, built-in fact-checking by comparing sources, and confidence scoring on findings.
  2. Devil’s Advocate — systematically stress-tests any proposal; explicitly accounts for both user blind spots and known model biases; always concludes with actionable improvements, not just critique.
  3. Morning Briefing — pulls together priorities, calendar, pending items, and relevant news; binds personal context files (goals, projects, stakeholders) to the skill.
  4. Board of Advisors — simulates multiple expert archetypes (e.g., VC perspective, entrepreneur perspective, domain expert) to provide diverse advisory perspectives on any decision.

Advanced Skill Patterns

  • Dispatcher (meta-skill): a skill that reads all incoming requests and routes them to the appropriate skill. Recommended once you have more than 10–15 active skills, especially when skills have nuanced overlaps.
  • Skill chaining: connect skills sequentially — manually (take output of one as input to next) or automatically (a skill that calls the next skill). Requires clean, well-defined inputs and outputs at each stage.
    • Example chain: Research with Confidence → Devil’s Advocate → Executive Summary/Deck Preparation.
  • Agentic loops: skills that iterate in a check-act-check cycle. Example: a marketing campaign optimization loop that monitors ad performance, adjusts bids, checks metrics, and runs competitive analysis continuously.
  • Multi-agent orchestration: skills that explicitly spin up multiple sub-agents to execute tasks in parallel.

Testing and Maintenance of Skills

  • Primary test: if you find yourself iterating on the output after a skill runs, the skill is not yet good enough. A well-built skill should produce a ready-to-use output.
  • Evaluation rigor should match stakes: skills that touch CRMs, customer-facing outputs, or critical workflows require formal evaluation processes.
  • Re-evaluate when: a new model is released, a new tool adopts the skill, approximately one month has passed, or when output quality declines.
  • Note: sometimes the skill logic is sound but the context files within the skill have gone stale — that is also a common cause of degrading results.
  • Skills that are no longer relevant should be deprecated to prevent accumulation of a stale library.

Organizational Skill Libraries

  • Forward-thinking organizations are treating skills the way they treat code: maintained in shared libraries, with clear ownership, versioning, and deprecation policies.
  • Recommended organizational workflow:
    1. Discovery — run work audits; identify repetitive tasks, AI underperformance areas, and wish lists.
    2. Build — use best practices or tools like Anthropic’s skill creator.
    3. Validate — cross-validate: have one person stress-test another person’s skill; treat shared skills like AI products with proper evaluation.
    4. Package — bundle skills and relevant context into plugins or reusable components deployable per department or team.
    5. Maintain — assign clear owners (AI champions or subject matter experts); schedule reviews; deprecate stale skills.
  • Anthropic’s Claude for Work already supports plugins composed of skills and context, deployable org-wide to give all users a consistent shared capability baseline.
  • Skill hackathons are one mechanism organizations are using to bootstrap team-level skill libraries.

Key Concepts

  • Agent Skill: A portable folder containing instructions, scripts, and resources that give an AI agent or tool an actionable playbook for a specific task.
  • Trigger: The section of a skill file that specifies exactly when and how the skill should be activated, either by an agent automatically or by a human verbal/command cue.
  • Gotcha Section: A dedicated section in a skill that explicitly lists the failure modes, wrong assumptions, and error patterns the model should avoid — considered the highest-signal content in any skill.
  • Dispatcher Skill: A meta-skill that reads incoming requests and routes them to the appropriate skill in a library; analogous to a traffic controller.
  • Skill Chaining: The practice of connecting skills sequentially so the output of one skill becomes the input to the next, enabling multi-step automated workflows.
  • Agentic Loop: A skill pattern where the agent iterates in a recurring check-act-recheck cycle, suitable for tasks like continuous campaign optimization.
  • Organizational Skill Library: A shared, version-controlled repository of skills maintained at the team or company level, analogous to a code library.
  • Plugin (Claude for Work context): A bundled artifact combining skills and context that can be deployed across an organization so all users share the same AI capabilities.
  • Skill Deprecation: The deliberate retirement of skills that are no longer relevant or performant, necessary to prevent a stale and unreliable skill library.

Summary

Nufar Gaspar presents a five-level practical framework for building and managing agent skills — from understanding what they are through to designing organizational skill libraries. The core argument is that skills, as portable human-readable instruction folders, represent the foundational infrastructure primitive of the AI agent era, solving the portability and lock-in problems of earlier tools like custom GPTs. The talk emphasizes that effective skills require precise triggers, structured step-by-step bodies, calibrated creative freedom, explicit output examples, and critically a “gotcha” section documenting known failure modes. Beyond individual productivity, the larger opportunity is organizational: companies that treat skills like maintained, owned, version-controlled code assets — built through discovery, validated rigorously, packaged as plugins, and actively deprecated when stale — will achieve durable, compounding value from AI. Gaspar closes by stressing that skills are not a one-time initiative but a recurring operational practice, with roughly monthly review cycles needed to keep pace with rapidly evolving models and tools.