Why Fastify’s Creator Is Fed Up with AI‑Generated Code and Open‑Sources His Node.js Skills

Who Is Matteo?

If you have spent any time in the Node.js ecosystem, you probably know Matteo Collina. He is a member of the Node.js Technical Steering Committee and the core author of Fastify, one of the fastest web frameworks for Node.js with over 30,000 GitHub stars. Unlike a typical KOL, Matteo works deep in the Node.js runtime: he knows libuv internals, has tackled V8 JIT pitfalls, and has fixed numerous stream edge‑case bugs.

Recently, he described AI‑generated code as “slop” in a blog post because, although the code compiles and runs, it does not match his personal style, error‑handling conventions, or performance expectations.

“I’m not complaining that AI can’t write code; I’m complaining that the code it writes does not meet my standards. I have to repeat the same review comments every time.”

Matteo argues that the real issue is not AI’s inability to understand Node.js, but its ignorance of an individual developer’s preferred patterns. AI may produce code that uses outdated callbacks, ignores Fastify’s plugin architecture, or adopts error‑handling logic that conflicts with a project’s conventions. For developers with a mature methodology, this “good enough” output becomes a burden because they must spend time reshaping the code to fit their style.

Matteo’s Solution: mcollina/skills

To eliminate repetitive code‑review comments, Matteo created a set of “Skills” that encode his experience and best practices. He published the repository mcollina/skills on GitHub, which has earned 847 stars.

The repository contains nine distinct Skills, each focusing on a specific domain:

fastify : Best‑practice usage of the Fastify framework, covering hook lifecycles, plugin architecture, and performance tuning.

node : General Node.js development guidelines, including event‑loop semantics, async error handling, stream usage, and the native test runner.

nodejs-core : Deep dive into V8 internals, libuv operation, C++ addon development, and build‑system configuration.

typescript-magician : Advanced TypeScript type system tricks and complex generic patterns, inspired by TotalTypeScript.

octocat : Git workflow and GitHub operations, emphasizing the gh CLI for PRs, issues, and releases.

oauth : RFC‑compliant OAuth 2.0/2.1 implementation with Fastify integration.

linting-neostandard-eslint9 : Modern ESLint v9 flat‑config setup using the neostandard style.

documentation : Technical writing guidelines based on the Diátaxis framework (Tutorial, How‑to, Reference, Explanation).

snipgrapher : Configuration and usage of the snipgrapher code‑screenshot tool.

What Exactly Is a “Skill”?

A Skill is essentially an instruction manual for AI, telling it which conventions and preferences to follow in a particular domain. Skills adhere to the Agent Skills open standard, originally proposed by Anthropic and now supported by Claude Code, GitHub Copilot, and OpenAI Codex.

The standard employs progressive disclosure: the AI first loads a Skill’s metadata (a table of contents) and only fetches the full content when that knowledge is needed, preventing context overload.

Typical Skill contents include: SKILL.md: Metadata and description.

Optional executable scripts.

Reference documentation.

Template resources.

How Skills Differ From a Monolithic AGENTS.md

Many projects place a single AGENTS.md file at the repository root to provide AI with all context at once. While straightforward, this approach has three drawbacks:

Non‑reusable : The content applies only to that specific project.

Context pressure : All information occupies the AI’s prompt space regardless of relevance.

High maintenance cost : Every new project requires a fresh copy.

Skills, by contrast, are cross‑project reusable knowledge units, distributed like npm packages. Developers can load only the Skill they need—for example, the fastify Skill when writing Fastify routes, or the documentation Skill when authoring docs—without flooding the AI with unrelated material.

“It’s like pairing with an experienced developer who never forgets the obscure V8 flag you mentioned in 2022.”

How to Use the Skills

First install the community‑maintained skills CLI, then add the desired Skill with a single command:

# Install the Fastify skill
pnpx skills add mcollina/skills --skill='fastify'

# Install all skills (beware of context pressure)
pnpx skills add mcollina/skills --skill='*'

A visual tool called Skills Hub is also available for managing Skills more intuitively.

Matteo notes that the current ecosystem suffers from “unstable activation”: sometimes the AI loads a Skill automatically, other times an explicit “use fastify skill” prompt is required. This instability is a known limitation of the broader Skills ecosystem, not a defect of Matteo’s repository.

Why This Matters

By packaging his deep Node.js expertise into a format consumable by AI, Matteo provides a concrete example of how leading engineers can make their knowledge reusable for code generation tools. For developers who use Fastify, loading the fastify Skill steers AI toward the framework’s intended design patterns rather than a generic “just works” approach. Similarly, the nodejs-core Skill offers more reliable guidance for native module development than most online tutorials.

However, the value of a Skill is tightly coupled to the author’s expertise. Matteo’s Skills are trustworthy because he is a recognized authority in these areas.

Reference Materials GitHub – mcollina/skills My Personal Skills for AI‑assisted Node.js Development – Adventures in Nodeland