Ep 1167 Blog 2:55 w/ Jessica & Cathy

Build once, run on any agent: A practical guide to agent skills

Jessica and Cathy unpack GitHub’s “agent skills” idea: define tools once so different AI agents can reuse them, and what that means for avoiding framework lock‑in.

Embed this episode

Paste this on any site — the player is a self-contained iframe with no cookies or trackers.

<iframe src="https://sandrise.io/exploring-next/embed/1167"
  width="100%" height="180" style="max-width:640px;border:0;border-radius:12px;overflow:hidden"
  title="Exploring Next — Episode 1167 audio player"
  loading="lazy" allow="autoplay" referrerpolicy="strict-origin-when-cross-origin"></iframe>
Embed & API docs →
Script GPT-5.1 Voice Cartesia TTS

Transcript

Jessica So GitHub just dropped this post on “agent skills” for Copilot, and it’s basically about not rebuilding the same tool twenty times.

Cathy Yeah, this is Andrea Griffiths’ piece, right? The core idea is pretty simple: instead of each agent having its own hard‑coded behaviors, you define skills once as capabilities the agent can invoke. Things like “run tests”, “kick off a deployment”, “file an issue” become shared skills that multiple agents can reuse.

Jessica Right, and she frames it in that really practical, GitHub‑y way: a skill is just a well‑described action with inputs, outputs, and maybe some guardrails, not some magical new primitive.

Cathy Exactly. It’s basically formalizing what people are already hand‑rolling as tools. The interesting bit is the portability angle: build the skill once, then different Copilot agents can call it, instead of every new agent integration re‑implementing “create a pull request” slightly differently and breaking in its own way.

Jessica Which matters now that we have, what, dozens of agent frameworks floating around. If your repo automation is encoded as skills, at least the logic lives in one place while you experiment on the agent side.

Cathy Yeah. The article stays scoped to GitHub’s ecosystem, but you can feel the subtext: the skills layer is where you want stability. Agent brains can change, orchestration can change, but the contract for “here’s how you talk to my CI” should not be rewritten every quarter.

Jessica Mm‑hm.

Cathy Where I’m still cautious is portability beyond GitHub. The post doesn’t claim these skills are some cross‑framework standard. They’re practical guidance inside Copilot land: name things clearly, define parameters, handle errors, so multiple agents can safely share them. Whether that becomes a broader convention is still an open question.

Jessica Yeah, it’s more like, if you’re already betting on Copilot agents, you should stop treating every automation as a bespoke prompt and start treating it as a skill with a contract.

Cathy And then you can do the interesting stuff Andrea hints at, like composing skills. An agent planning a workflow doesn’t need to know how your deployment works, it just chains “build”, “test”, “deploy” skills and monitors results. That’s much easier to reason about and to audit later.

Jessica The practical move I took from it is pretty small but real: if you’re experimenting with agents on GitHub, pick one boring thing you already do in your pipeline, describe it as a reusable skill, and wire more than one agent to it instead of forking the logic.

Cathy Yeah. It’s not a flashy new model, it’s a nudge toward treating your agent tools like shared infrastructure instead of disposable prompts. In a field this chaotic, that’s not nothing.

Jessica Alright, that’s the nugget for today—skills as the stable layer under whatever agents you’re playing with. Catch you next time.