🚀 Advanced use

Typical ways to chain skills — sequential, parallel, conditional — each with its own trigger.

Without a standard, you reinvent the pipeline with every feature. Named patterns speed up decisions.

Pipeline, fan-out/fan-in, gate, orchestration.

Matt's default workflow — alignment becomes a PRD, then issues, then TDD cycles until merge.

It’s the living example of composition. Reproducing the flow delivers immediate results.

Handoff, output contract, canonical flow.

A skill that orchestrates other skills — used when the same sequence repeats across multiple projects.

A macro too early is premature abstraction. Too late, and you get pipeline copy-paste.

Rule of three, timely abstraction, composer skill.

Skills don’t store state — CONTEXT.md is the memory channel between them within the project.

Without shared state, each skill relearns the domain. With CONTEXT.md, you get continuity.

Persistence, documentary contract, single source of truth.

Overly long chains, skills with overlapping scope, cyclic dependencies.

Detecting early prevents a fragile pipeline no one understands.

Overcoupling, fuzzy scope, cycles, prompt explosion.

Refactoring case: /zoom-out → /improve-codebase-architecture → /to-issues → /tdd → review.

Seeing the full composition in a real-world problem makes the pattern stick.

Safe refactoring, real chaining, intermediate gates.

File anatomy: YAML front matter (name, description, triggers) and Markdown body with instructions.

Without understanding the structure, customization breaks skill loading.

Frontmatter, body, required sections, parser.

Fields that determine when the agent loads the skill—phrases, contexts, and explicit triggers.

Bad trigger = the skill never fires or always fires. Weak description = the agent ignores it.

Trigger phrase, description, scope, false positive.

Skills have templates (PRD, ADR, issue). Editing templates adjusts output without changing the logic.

Cheaper and safer customization — you change the form, keep the behavior.

Template, output contract, sections, placeholders.

Fork = independent copy; override = a local skill with the same name overrides the global one in that project.

A fork loses upstream. An override keeps updates. The wrong decision becomes costly later.

Local/global scope, precedence, upstream, drift.

Treating the skills directory as a repo—with branches, PRs, reviews, and a changelog for changes.

Without version control, customization becomes ".skill.bak.final.v2". The team loses traceability.

Skills as code, semver, changelog, skill review.

Walkthrough adapting /grill-with-docs to a specific domain—its own terms, questions, and references.

Seeing a real customization eases the fear of changing an "official" skill.

Domain fit, local prompt, specific refs, minimal fork.

Each agent loads skills differently. Map what’s portable versus what’s specific.

Maintaining N versions of the same skill is unsustainable. Knowing what’s common reduces duplication.

Runtime, portability, capability matrix, surface area.

A skill that packages a SKILL.md in a portable format and outputs it for Claude Code, Codex, and others.

Build once, run anywhere — without polyskill, you maintain N divergent copies.

Source of truth, transpile, adapter, runtime target.

Slash commands, hooks, MCP, permissions — each runtime exposes a subset. Know which ones break portability.

A skill that assumes a Claude Code hook won’t work in Codex. Mapping gaps beforehand avoids confusing debugging.

Hook, MCP, slash command, permission, sandbox.

Expose skills through an MCP server — any compatible agent can use them without installing them locally.

The whole team uses the same skill version, updated centrally.

MCP server, tool, manifest, dynamic discovery.

Run skills in pipelines (GitHub Actions, GitLab CI) — automated review, linting, and doc updates.

A skill in CI becomes a reliable gate. It goes from “if you remember to run it” to “it always runs.”

Pipeline, gate, headless agent, artifact, idempotency.

Workflow that runs /tdd on new PRs—the agent generates a failing test, implements the fix, and opens a commit.

A hands-on project wraps up the learning path: everything you learned runs without you opening the IDE.

Workflow YAML, secret, agent runner, PR automation.