How To Use AI Skills Like A Senior Developer

Summary of the video (technology + how-to on AI “skills”)

The video presents AI skills as a way to package application-specific instructions for coding agents (e.g., in editor integrations). The creator positions skills as something real software engineers should use—rather than randomly downloading lots of skills hoping for “perfect” output.

---

What “skills” are

• A skill is essentially a Markdown file (skill.md) containing:
  • Required front matter: name and description
  • Optional front matter fields: licenses, compatibility strings, metadata key/value pairs
  • Optional security scoping: e.g., “allowed tools” to restrict what the skill can do
• The body text explains to the AI how to perform a task.
• Skills range from very small (few lines) to complex, with added folders/resources (scripts, references, assets, agents).

---

How to use skills in an editor/agent

• Skills are typically invoked via a slash command.
  • Example flow: type /skill:<name> and then provide the user request.
• The slash command loads the contents of the skill.md into the agent’s context, giving the model task-specific instructions.
• If the skill has good name/description, some agents may auto-select the skill based on user intent.

---

Finding and installing existing skills

• Main repository/site mentioned: skills.sh
  • Described like an “npm registry,” but for skills.
  • Skills can be searched (e.g., by “Tanstack”).
  • Skill listings show install counts to infer popularity.

Installing

• Skills expose an install command.
• You can install:
  • A single skill
  • All skills from an organization/section (bulk install)
  • Multiple skills at once (when prompted)

---

Security + safety guidance (major emphasis)

• Skills can inject malicious or harmful instructions (prompt injection).
  • Example: a skill could be “named innocently” but contain instructions like destructive actions.
• The recommendation:
  • Read the skill’s Markdown/scripts before trusting it.
  • Prefer skills with higher installs initially, until you learn how to judge safely.
• The video also describes security reports/audits shown during install:
  • Example: a skill with a critical risk.
  • Audits explain why risk was flagged and how it could impact the system.

---

Local vs global installation + version locking

• Project install:
  • Skills are stored locally in agent/skills inside the repo.
  • Includes a lockfile (similar to package-lock.json) to pin versions.
• Global install:
  • Installed to the user’s home directory for use across projects.
• Guidance: project installs are usually preferred for most skills.

---

A critique: many downloaded skills are inefficient/bad

The creator claims some popular skills (e.g., Tanstack examples shown) don’t follow best practices:

• They may be overly large
• They may include too much content in skill.md
• That can increase context usage/cost and degrade output quality

---

How to write your own skills (tutorial)

The video provides a structured approach to create skills that perform better and cost less.

Simple path

• Many editors support “create skill” commands (e.g., Copilot in VS Code).
• Workflow:
  1. Prompt the AI with detailed requirements
  2. AI generates a rough skill draft
  3. You must read and manually correct it

Advanced / from-scratch skill architecture

A standard skill structure is described with key folders:

1. skill.md
   • Keep front matter correct and intentional
   • Keep the body as concise as possible
2. scripts/
   • Put deterministic execution logic here (JS/batch/bash)
   • Useful for reproducibility and ordering tasks
3. references/
   • Split large documentation into smaller, topic-specific chunks
   • The agent loads only what’s needed (“progressive disclosure” concept)
4. assets/
   • Static data/templates: JSON, schemas, templates, images
   • Useful for consistent structured outputs

Key performance/cost principle

• Keep skill.md under ~500 lines (explicit recommendation).
• Move everything else into references/scripts/assets to avoid blowing up context.

---

Description best practices (so the AI picks the right skill)

The creator explains that the description is especially important because:

• It’s loaded frequently to help the AI decide whether to use the skill.
• It should focus on user intent, not implementation details.

Examples shown:

• Bad descriptions: definitions of what a library/skill is (won’t teach “when to use it”).
• Better descriptions: imperative guidance like “Use when the user wants to…” plus when not to use.

---

Body best practices (how the instruction content should be written)

Important guidance includes:

• Write as the domain expert from your experience (not generic AI knowledge).
• Include specific scenario details so results match your environment/workflow.
• Avoid dumping general explanations (AI already knows basic concepts like what a PDF is).
• Include a “what to do / what not to do” section (“gotcha” section).
• Use structured templates and checklists to reduce hallucinations and enforce formatting.
• Provide validation loops/checks when tasks have multiple steps.

---

Real example skill: rewriting blog articles from YouTube transcripts

A concrete case study is shown:

• Goal: transform YouTube/video-linked content into drafts matching the creator’s blog style.
• The skill is designed with:
  • A strong description that says when to use (draft new article, generate stub, UI/blog use cases)
  • Detailed instructions for:
    • Where to put the article
    • Front matter format and allowed values (e.g., tag lists)
    • Article structure (intro, headings, conclusion)
    • Common components and custom components (Astro + React, theme variables, light/dark support)
  • A large repository of past articles used as training material/reference for tone and formatting
  • A “what not to do” section with examples

---

Skill refinement process over time (continuous improvement)

The creator emphasizes that first drafts won’t be perfect and describes a refinement workflow:

• Keep the original AI-generated output version.
• Manually edit to match the desired tone/format.
• Use a second “refinement” skill that:
  • Compares original vs manually edited versions
  • Detects changes
  • Updates the main skill with those improvements
• The result: fewer manual edits in future generations and faster convergence to “your” style.

---

Additional learning resource mentioned

• The creator is building a free AI roadmap (with front-end/back-end roadmaps already done) and offers a link to download it; they plan to email when the AI roadmap version is released.

---

Main speakers/sources

• Kyle (host/creator), “WebDev Simplified”
• Source site referenced for skills discovery: skills.sh (described as run by “Burscell”)