Three of GitHub's hottest repos this week are just SKILL.md files

What happened

Three of this week's fastest-climbing GitHub repos are not libraries, models, or apps. They're skills — specifically, they're conformant to Anthropic's Skills format, which landed as a first-class primitive earlier this year. The lineup: anthropics/fermats-last-theorem (960 trending score), a formalization scaffold for the Wiles proof; kajisho5/ffmpeg-skill (487), a video-manipulation skill that wraps ffmpeg's CLI surface in something a model can actually reason about; and Mantitup-Org/vista (423), a UI-inspection skill for visually grounded automation.

All three follow the same on-disk layout: a top-level `SKILL.md` file with YAML frontmatter declaring `name`, `description`, `version`, and an `allowed-tools` list, followed by a markdown body that reads more like a runbook than documentation. Below that sits a `scripts/` directory of small executables — Python, Bash, sometimes a Node one-liner — and a `resources/` folder with prompts, examples, or reference material the skill's instructions can point at.

There is no framework import. No agent class. No graph. The runtime is Claude (or any agent that speaks the format), and the "framework" is whatever the markdown file tells the model to do next.

Why it matters

For two years, the agent tooling story has been a race to build the best orchestration primitive. LangGraph, LlamaIndex Workflows, CrewAI, AutoGen, Semantic Kernel — each shipped its own take on nodes, edges, state, memory, and tool routing. The bet was that agents need scaffolding the way web apps need a framework.

Skills quietly propose the opposite: the model is the runtime, the markdown is the program, and the "framework" is a filesystem convention. A SKILL.md file for ffmpeg doesn't describe a graph of ffmpeg-related nodes. It says, in plain English, "here's what ffmpeg can do, here are the flags that bite you, here are three scripts I've pre-written for common jobs, call them like this." The model reads it on demand, decides which script to invoke, and executes. That's the whole architecture.

The ffmpeg-skill repo is the sharpest example of why this works. ffmpeg's CLI is famously unforgiving — flag order matters, filter graphs are their own syntax, and half the Stack Overflow answers are subtly wrong for your codec. The skill's SKILL.md doesn't try to wrap ffmpeg in a Python DSL. It hands the model a page of "here's the trap, here's the incantation that avoids it," plus three battle-tested scripts for the 80% cases (concat, transcode, extract audio). The result is closer to what a senior video engineer would leave in a `README.md` for a junior than to what a framework would generate.

Compare the code footprint: a typical LangChain agent that wraps ffmpeg is 300+ lines of Python, three abstractions deep, with tool schemas defined in Pydantic. The equivalent Skill is a 200-line markdown file and a shell script. Both work. Only one is auditable in a single browser tab. The Fermat's Last Theorem repo is even more telling — formal proof work is exactly the kind of domain where you'd expect elaborate scaffolding, and instead it's a skill that tells the model how to interact with a Lean environment plus a handful of tactic helpers.

The community reaction on HN and Reddit has been split along predictable lines. Framework maintainers point out — correctly — that skills don't solve multi-agent coordination, don't give you deterministic replay, and don't help when you need to pin a specific model to a specific step. Practitioners counter — also correctly — that 90% of what people call "agents" in production is one model with three tools and a system prompt, and for that shape of problem, a Skill is strictly less code to maintain.

What this means for your stack

If you're building agent workflows today, the immediate move is to try porting one before you commit to another framework refactor. Pick the smallest LangChain/CrewAI/AutoGen agent in your codebase — the one that wraps a CLI or an API — and rewrite it as a single SKILL.md with a scripts directory. You'll know within an afternoon whether the model can follow the markdown as reliably as it followed your Python. In most cases involving a single tool surface, it can.

The economic pressure on framework maintainers is now real: if a markdown file plus a shell script does the job, the value proposition of a 40-dependency Python package shrinks to "multi-step orchestration and observability." That's a smaller market than "how to build an agent," and it's the market Temporal, Inngest, and Prefect already own from the non-AI side. LangChain, LlamaIndex, and their peers will need to decide whether they're competing in orchestration (against workflow engines) or retreating to just being the tool-schema layer (against the model providers themselves).

For teams shipping to production, the checklist changes. You still need eval harnesses, still need cost monitoring, still need a way to pin model versions. But the artifact you're versioning is now a markdown file, which means diffing agent behavior finally works with `git diff` instead of requiring you to trace through a call graph. That alone is worth the migration for anyone who's ever tried to code-review a LangGraph change.

Looking ahead

Three trending repos is an anecdote. But the pattern — that the top of GitHub trending is now populated by markdown files posing as software — is the leading indicator. Expect a Skills registry (community or Anthropic-run) within the quarter, expect the other model providers to ship compatible formats within two, and expect the framework tier to spend 2026 either consolidating hard or repositioning as observability. The winning bet in agent tooling has quietly shifted from "build the best abstraction" to "write the clearest instructions," and that's a very different competition.