Video summary

I Stopped Installing Claude Skills. Here's What I Do Instead.

Main summary

Key takeaways

Technology

Core Concept: What a “Skill” Is (and Isn’t)

The video argues that “skills” (for ChatGPT/Codex/Claude/Claude Code) are powerful capabilities that are often misunderstood—treated like plug-and-play apps or installed incorrectly—leading to unreliable or even harmful behavior.

What a skill is

  • Skill = a set of instructions an AI agent (e.g., ChatGPT/Codex/Claude) can use at a specific moment to accomplish a task.

Example skills mentioned include:

  • building spreadsheets
  • styling PowerPoint
  • writing Python code in a particular way

What a skill is not

  • Skills are not like mobile apps.
    • You don’t get the same guarantees, standardized trust level, or predictable behavior just by installing them.

Why Skills Can Fail

Skills can fail due to several factors:

  • Untrusted sources
    • Grabbing skills from places like GitHub without knowing the author/intent can introduce:
      • malicious instructions
      • unpredictable behavior
  • Mismatch with your actual task
    • The agent may not know when the skill should be used.
  • Bad metadata / description (e.g., skill.markdown front matter)
    • Vague descriptions → the skill never triggers
    • Overly broad descriptions → the skill triggers too often and wastes context
    • Overly large main file → the agent spends time navigating documentation instead of doing work

Key point: Successfully installing a skill doesn’t mean it will be useful.

How Skills Are Invoked (Loading Order Matters)

When an agent calls a skill, it typically:

  1. Uses the skill’s name and description first (not the full instruction set).
  2. Loads the full instructions only when the task matches.

The video frames this as both:

  • why skills can outperform “paste one giant prompt every time,” and
  • why writing quality directly affects performance.

Reframing for Better Skill Design

Skills should be designed for a two-audience reality:

  1. Agents (so they can reliably choose and use the skill)
  2. Humans (so they can inspect/audit what the agent is doing)

The creator emphasizes auditable judgment: if you’re encoding business logic or decision-making logic, it should be readable and verifiable by humans.

Product/Guide Focus: The “Skill Builder” Concept

The video promotes a “skill builder” skill/tool to help people write better skills by following agentic best practices.

It produces a skill structure that is:

  • readable by humans (e.g., skill.markdown can be opened and understood)
  • usable by agents (clear front matter, good examples/counterexamples, not bloated)

It also mentions a “teaser trailer” idea:

  • the short early text the agent uses to decide whether to invoke the skill
  • the builder helps write this so the agent calls the skill appropriately, without context-window bloat or confusion

Examples and Lineage (Evolving Skills)

The video references Matt Pocock’s “Grill Me” skill (and a Nate Hurk short version/fork):

  • The original idea includes an interview loop that questions the user until a solid plan exists.
  • The fork changes the goal so the resulting context is more persistent and inspectable, reducing repeated questioning.

“Skill lineage” is used to illustrate that skills are:

  • evolving capability envelopes, not static one-time installations.

The video suggests most real usage involves:

  • modifying skills, or
  • building from inspiration, rather than collecting many ready-made skills.

Advanced Use: Auditing and Conflicts Across Many Skills

For builders with many skills (e.g., 25+), the video warns about:

  • skill conflicts
  • “averaging out” behavior (adding more skills can make results worse without obvious explanation)

The creator says they’re launching an advanced audit/analysis skill to:

  • identify conflicts across installed skills
  • help resolve them in ways that remain comfortable for humans

Motivation: prevent a cycle where someone adds a new skill because performance seems bad, but the new skill actually worsens the overall system.

Practical Starting Guidance

  • Don’t install skills “just to feel cool” or treat them like Pokémon cards.
  • Start with:
    • trusted skills only
    • clear reasons/goals for installing skills
    • a mindset like you’re authoring intelligence on your computer (encoding judgment and trusted sources)

Mentioned Supporting Tech: Voice as Input

The video claims voice interaction will be transformative (noted for 2026). It encourages:

  • using voice tools/features (e.g., “GPT live”)
  • using tools like Whisper / other open-source voice pipelines
  • capturing unique goals/judgment and converting that into repeatable skills

Main Speakers / Sources

  • Primary speaker: Matt Pocock (referenced as the author of skills like “Grill Me”) Plus the unnamed video creator who promotes the “skill builder” concept and an “audit” skill.

  • Referenced source:

    • Nate Hurk (referenced via modification/fork examples connected to “Grill Me”)

Original video