New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Custom Matchers

by onsi in onsi/gomega

Writing your own Gomega matchers — the GomegaMatcher interface (Match/FailureMessage/NegatedFailureMessage), gcustom.MakeMatcher with message templates and template data, the format package helpers…

MITAuto-check passedDevelopment

Install Custom Matchers

skills CLI
$ npx skills add onsi/gomega --skill custom-matchers -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install onsi/gomega custom-matchers --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/onsi/gomega.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/gomega/skills/custom-matchers .claude/skills/custom-matchers && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
custom-matchers
GitHub stars
2.4k
Token cost
~2.4k tokens
SKILL.md length
714 words
Files
1
Skills in repo
12
Repo updated
First seen
Licence
MIT

At a glance

Writing your own Gomega matchers — the GomegaMatcher interface (Match/FailureMessage/NegatedFailureMessage), gcustom.MakeMatcher with message templates and template data, the format package helpers…

  • Composed matcher cant express your domain assertion and you need to build one
  • SKILL.md covers gcustom.MakeMatcher — the…, The raw GomegaMatcher interface, MatchMayChangeInTheFuture —… and Aborting from inside a matcher…, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Custom Matchers is an agent skill from onsi/gomega. Writing your own Gomega matchers — the GomegaMatcher interface (Match/FailureMessage/NegatedFailureMessage), gcustom.MakeMatcher with message templates and template data, the format package helpers (format.Message/format.Object), MatchMayChangeInTheFuture and StopTrying for Eventually/Consistently, and how to test and package custom matchers. Use when a built-in or composed matcher can't express your domain assertion and you need to build one.

Its SKILL.md is about 2.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development. The repository describes itself as: Ginkgo's Preferred Matcher Library. The licence is MIT.

When your agent uses it

  • Composed matcher cant express your domain assertion and you need to build one

Example prompts

  • “/custom-matchers”

What it can do on your machine

Read from SKILL.md and the folder at commit 820ad4d. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are go).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • onsi.github.io

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Custom Matchers loads about 2.4k tokens when it runs. Until then it costs about 116 tokens; SKILL.md has 714 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~116
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from onsi/gomega at commit 820ad4d, republished under its MIT licence (© onsi). 714 words, ~2,371 tokens.

Download SKILL.mdSave it as .claude/skills/custom-matchers/SKILL.md (or your agent's skills folder).
name
custom-matchers
description
Writing your own Gomega matchers — the GomegaMatcher interface (Match/FailureMessage/NegatedFailureMessage), gcustom.MakeMatcher with message templates and template data, the format package helpers (format.Message/format.Object), MatchMayChangeInTheFuture and StopTrying for Eventually/Consistently, and how to test and package custom matchers. Use when a built-in or composed matcher can't express your domain assertion and you need to build one.

Writing your own matchers

When no built-in matcher fits and composition (And/Or/WithTransform/SatisfyAll — see gomega:composing-matchers) can't express it cleanly, write a custom matcher. Reach for gcustom.MakeMatcher first — it's the modern, low-boilerplate path. Drop to a hand-written type only when you need full control. Docs: https://onsi.github.io/gomega/#adding-your-own-matchers.

gcustom.MakeMatcher(matchFunc, ...) builds a full types.GomegaMatcher from one function. The match function must be func(actual T) (bool, error):

go
import (
	"github.com/onsi/gomega/gcustom"
	"github.com/onsi/gomega/types"

	"encoding/json"
	"fmt"
	"net/http"
	"reflect"
)

func RepresentJSONifiedObject(expected any) types.GomegaMatcher {
	return gcustom.MakeMatcher(func(response *http.Response) (bool, error) {
		ptr := reflect.New(reflect.TypeOf(expected)).Interface()
		if err := json.NewDecoder(response.Body).Decode(ptr); err != nil {
			return false, fmt.Errorf("failed to decode JSON: %w", err)
		}
		decoded := reflect.ValueOf(ptr).Elem().Interface()
		return reflect.DeepEqual(decoded, expected), nil
	}).WithTemplate("Expected:\n{{.FormattedActual}}\n{{.To}} contain the JSON representation of\n{{format .Data 1}}").WithTemplateData(expected)
}

Then Expect(resp).To(RepresentJSONifiedObject(book)) just works.

Typed match funcs get free type-checking. Because the func takes *http.Response, gcustom rejects any other actual with a clear error before calling your code. Use func(actual any) (bool, error) only if you want to handle multiple types or do your own type checks.

Return (false, err) for bad input, not a panic. A non-nil error fails the assertion in both the To and NotTo directions — you can't accidentally pass a negated assertion by feeding garbage.

Messages: WithMessage vs WithTemplate
  • .WithMessage("contain the JSON representation") — simplest. Renders Expected:\n<actual>\nto contain the JSON representation (and not to when negated).
  • .WithTemplate(tmpl, optionalData) — full control. WithTemplate(tmpl, data) is shorthand for .WithTemplate(tmpl).WithTemplateData(data).
  • Omit both and you get a generic Custom matcher failed for:\n<actual> message.

Template variables and functions:

tokenmeaning
{{.Actual}}the raw actual value
{{.FormattedActual}}actual pretty-printed (indent 1)
{{.To}}"to" on positive failure, "not to" on negated failure
{{.Failure}} / {{.NegatedFailure}}bools for the two directions
{{.Data}}whatever you passed to WithTemplateData
{{format <obj> <indent>}}render any object with Gomega's formatter

Avoid recompiling templates in hot paths. WithTemplate parses on every constructor call. Precompile once with gcustom.ParseTemplate(str) (use that, not raw text/template, so the format func is registered) and pass it to MakeMatcher(matchFunc, tmpl) or .WithPrecompiledTemplate(tmpl).

The raw GomegaMatcher interface

MakeMatcher returns this; implement it directly only when you need behavior gcustom doesn't expose:

go
type GomegaMatcher interface {
	Match(actual any) (success bool, err error)
	FailureMessage(actual any) (message string)
	NegatedFailureMessage(actual any) (message string)
}

A hand-rolled version of the matcher above:

go
func RepresentJSONifiedObject(expected any) types.GomegaMatcher {
	return &representJSONMatcher{expected: expected}
}

type representJSONMatcher struct{ expected any }

func (m *representJSONMatcher) Match(actual any) (bool, error) {
	response, ok := actual.(*http.Response)
	if !ok {
		return false, fmt.Errorf("RepresentJSONifiedObject matcher expects an *http.Response")
	}
	ptr := reflect.New(reflect.TypeOf(m.expected)).Interface()
	if err := json.NewDecoder(response.Body).Decode(ptr); err != nil {
		return false, fmt.Errorf("failed to decode JSON: %w", err)
	}
	decoded := reflect.ValueOf(ptr).Elem().Interface()
	return reflect.DeepEqual(decoded, m.expected), nil
}

func (m *representJSONMatcher) FailureMessage(actual any) string {
	return format.Message(actual, "to contain the JSON representation of", m.expected)
}

func (m *representJSONMatcher) NegatedFailureMessage(actual any) string {
	return format.Message(actual, "not to contain the JSON representation of", m.expected)
}

Conventions:

  • A constructor function (here RepresentJSONifiedObject) returns the matcher; the struct itself stays unexported. Take concrete types in the constructor where you can; use any only when you genuinely must.
  • FailureMessage/NegatedFailureMessage are always called after Match — stash anything you computed in Match on the struct and reuse it in the messages.
  • Lean on reflect to interpret generic actual/expected inputs.
format package helpers

Use these for messages instead of hand-rolling fmt.Sprintf so output matches every other Gomega matcher:

  • format.Message(actual, "to <verb>", expected) → Expected\n<actual>\n<message>\n<expected>. Omit expected for a one-sided message.
  • format.Object(obj, indent) → the pretty-printed block Gomega uses everywhere (indent is a uint).
  • format.MessageWithDiff(actual, "to equal", expected) for string-diff highlighting.
Show full SKILL.md (313 more words)Show less

MatchMayChangeInTheFuture — stopping Eventually/Consistently early

Eventually/Consistently (see gomega:async) re-invoke your matcher each poll. If a match result can become permanently fixed (e.g. a closed channel, an exited process), implement the optional OracleMatcher method so polling can short-circuit:

go
func (m *exitMatcher) MatchMayChangeInTheFuture(actual any) bool {
	session := actual.(*gexec.Session)
	return session.ExitCode() == -1 // true while still running; false once exited
}

This is not part of GomegaMatcher — most matchers don't need it. When present, Gomega calls it after each Match; returning false stops polling and fails/passes as appropriate (so Eventually(session).Should(Exit(0)) fails the instant a wrong exit code lands instead of waiting out the timeout). gcustom matchers don't expose this; hand-write the type if you need it.

Only consulted for bare values. If Eventually is polling a function, Gomega can't assume the result is stable, so MatchMayChangeInTheFuture is skipped.

Aborting from inside a matcher with StopTrying

A more direct, modern alternative: have Match return a StopTrying(...) error (or call StopTrying(...).Now()) to abort Eventually/Consistently immediately and fail with your message.

go
func (m *thing) Match(actual any) (bool, error) {
	if irrecoverable {
		return false, StopTrying("the resource was deleted; it will never appear")
	}
	return check(actual), nil
}

You can .Wrap(err) and .Attach("desc", obj) onto the signal. Full polling-signal semantics (including TryAgainAfter) live in gomega:async.

Testing your custom matchers

Drive the matcher under test with ordinary assertions, and for the error paths call Match directly (an erroring matcher would otherwise just fail your assertion):

go
var _ = Describe("RepresentJSONifiedObject", func() {
	var book Book
	var response *http.Response

	BeforeEach(func() {
		book = Book{Title: "Les Miserables", Author: "Victor Hugo"}
		j, err := json.Marshal(book)
		Expect(err).NotTo(HaveOccurred())
		response = &http.Response{Body: io.NopCloser(bytes.NewBuffer(j))}
	})

	It("matches an http.Response carrying the object's JSON", func() {
		Expect(response).To(RepresentJSONifiedObject(book))
	})

	It("does not match a different payload", func() {
		response.Body = io.NopCloser(strings.NewReader(`{}`))
		Expect(response).NotTo(RepresentJSONifiedObject(book))
	})

	It("errors on the wrong actual type", func() {
		_, err := RepresentJSONifiedObject(book).Match("not a response")
		Expect(err).To(HaveOccurred())
	})
})

Assert on FailureMessage(actual) / NegatedFailureMessage(actual) when the wording matters.

Packaging & contributing

  • Keep matchers in their own package; export only the constructor.
  • To contribute a matcher upstream, mimic Gomega's house style: format output via the format package, put the matcher and its tests in the matchers package, and add the constructor to matchers.go in the top-level package. Issues and PRs welcome at https://github.com/onsi/gomega.

Wrapping the whole Gomega (advanced)

You can replace gomega.Default with a type implementing both gomega.Gomega and an Inner() Gomega method that returns the real default, delegating every call through. Useful for cross-suite logging, call counting, or injecting delays to surface timing dependencies — rarely needed, but the seam exists.

See also: gomega:matchers (catalog — check before building), gomega:composing-matchers (build matchers without code), gomega:async (polling signals).

© onsi, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in plugins/gomega/skills/custom-matchers of onsi/gomega.

Open the folder on GitHubat commit 820ad4d

Compare with similar skills

Custom Matchers next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Custom Matchers compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Custom Matchers this skillonsi/gomega2.4k—~2.4kAutomated safety check: PassMIT
Vercel Composition Patternssupabase/supabase111k58 repos~726Automated safety check: PassMIT
Finishing a Development Branchobra/superpowers297k5 repos~1.9kAutomated safety check: PassMIT
Typescript Advanced Typesrolling-scopes/rsschool-app10k25 repos~4.2kAutomated safety check: PassMPL-2.0
PR Babysitteropeninterpreter/openinterpreter69k3 repos~4.2kAutomated safety check: PassApache-2.0
Code Review ChecklistshareAI-lab/learn-claude-code78k4 repos~1.1kAutomated safety check: PassMIT

Similar skills

  • Vercel Composition Patterns

    supabase/supabase

    Official

    React composition patterns that scale. An agent skill from supabase/supabase.

    111k GitHub starsUsed in 58 repos~726 tokens
    DevelopmentAuto-check passed

  • Finishing a Development Branch

    obra/superpowers

    Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.

    297k GitHub starsUsed in 5 repos~1.9k tokens
    DevelopmentAuto-check passed

  • Typescript Advanced Types

    rolling-scopes/rsschool-app

    Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications.

    10k GitHub starsUsed in 25 repos~4.2k tokens
    DevelopmentAuto-check passed

  • PR Babysitter

    openinterpreter/openinterpreter

    Watches an open GitHub pull request until it merges, handling review comments, diagnosing CI failures and retrying flaky checks along the way.

    69k GitHub starsUsed in 3 repos~4.2k tokens
    DevelopmentAuto-check passed

  • Code Review Checklist

    shareAI-lab/learn-claude-code

    Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.

    78k GitHub starsUsed in 4 repos~1.1k tokens
    DevelopmentAuto-check passed

  • Greploop

    onyx-dot-app/onyx

    Iteratively improves a PR (GitHub), MR (GitLab), or shelved changelist (Perforce) until Greptile gives it a 5/5 confidence score with zero unresolved comments.

    32k GitHub starsUsed in 4 repos~3.3k tokens
    DevelopmentAuto-check passed

More from onsi/gomega

All 12 skills in this repo

  • Assertions

    onsi/gomega

    Write correct synchronous Gomega assertions — Expect/Ω notation, the To/NotTo/ToNot/Should/ShouldNot equivalences, the multi-return error idiom, Succeed vs HaveOccurred, the .Error() chaining form…

    2.4k GitHub stars~2.1k tokensUpdated yesterday
    Auto-check passed

  • Async

    onsi/gomega

    Polling assertions in Gomega — Eventually (poll until it passes) and Consistently (must keep passing), the func(g Gomega) callback idiom, WithTimeout/WithPolling/Within/ProbeEvery, WithContext and…

    2.4k GitHub stars~2.2k tokensUpdated yesterday
    Auto-check passed

  • Composing Matchers

    onsi/gomega

    Build compound Gomega assertions by combining matchers — And/SatisfyAll (all pass), Or/SatisfyAny (any pass), Not (negate), WithTransform to map the actual before matching, Satisfy for an ad-hoc…

    2.4k GitHub stars~1.5k tokensUpdated yesterday
    Auto-check passed

  • Gbytes

    onsi/gomega

    Testing streaming io buffers with gbytes — gbytes.NewBuffer() (an io.Writer also returned by gexec sessions), the Say(regexp) matcher that forward-scans from a moving read cursor, the canonical…

    2.4k GitHub stars~1.5k tokensUpdated yesterday
    Auto-check passed

  • Gexec

    onsi/gomega

    Testing external processes with gexec — compile binaries with Build/BuildWithEnvironment/BuildIn and CleanupBuildArtifacts, start them with Start returning a Session, await exit with the Exit…

    2.4k GitHub stars~1.3k tokensUpdated yesterday
    Auto-check passed

  • Ghttp

    onsi/gomega

    The ghttp test HTTP server for testing HTTP clients — NewServer/NewTLSServer, AppendHandlers, the Verify assertions (VerifyRequest/VerifyHeader/VerifyHeaderKV/VerifyJSON/VerifyForm/VerifyBasicAuth/Ve…

    2.4k GitHub stars~2.7k tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Custom Matchers

What does Custom Matchers do?

Writing your own Gomega matchers — the GomegaMatcher interface (Match/FailureMessage/NegatedFailureMessage), gcustom.MakeMatcher with message templates and template data, the format package helpers…. Custom Matchers is an agent skill from onsi/gomega.Object), MatchMayChangeInTheFuture and StopTrying for Eventually/Consistently, and how to test and package custom matchers.

When should I use Custom Matchers?

Custom Matchers fits situations like: composed matcher cant express your domain assertion and you need to build one.

How do I install Custom Matchers in Claude Code?

Run `npx skills add onsi/gomega --skill custom-matchers -a claude-code`. Or copy the skill folder (plugins/gomega/skills/custom-matchers in onsi/gomega) into .claude/skills/custom-matchers in your project. Claude Code loads it when a task matches its description.

How do I install Custom Matchers in Codex?

Run `npx skills add onsi/gomega --skill custom-matchers -a codex`. Or copy the skill folder (plugins/gomega/skills/custom-matchers in onsi/gomega) into .agents/skills/custom-matchers in your project. Codex loads it when a task matches its description.

Can I use Custom Matchers in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add onsi/gomega --skill custom-matchers -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/custom-matchers, .gemini/skills/custom-matchers, .github/skills/custom-matchers and .opencode/skills/custom-matchers in your project.

What does Custom Matchers need to run?

SKILL.md names no scripts, command-line tools or credentials: Custom Matchers is instructions for the agent only.

Does Custom Matchers access the network?

SKILL.md names 1 domain. As links in the text: onsi.github.io. This is read from the text; nothing was executed.

Is Custom Matchers safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Custom Matchers use?

Custom Matchers is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Custom Matchers use?

About 2.4k tokens (SKILL.md is roughly 9.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Custom Matchers?

Skills that share tags, products or a category with Custom Matchers: Vercel Composition Patterns (supabase/supabase, 111k stars), Finishing a Development Branch (obra/superpowers, 297k stars), Typescript Advanced Types (rolling-scopes/rsschool-app, 10k stars) and PR Babysitter (openinterpreter/openinterpreter, 69k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Custom Matchers?

onsi (a GitHub user) maintains it in onsi/gomega, which has 2,356 GitHub stars. The repository holds 12 skills in this directory. The repository was last updated on October 10, 2026.

Source: onsi/gomega on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.