New: 97,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

Pattern Matching

by NoobyGains in NoobyGains/godmode

A skill your agent uses when contributing code to an existing project - guarantees that every new line mirrors the established conventions, naming schemes, architectural layering, directory layout…

MITAuto-check passed

Install Pattern Matching

skills CLI
$ npx skills add NoobyGains/godmode --skill pattern-matching -a claude-code

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

GitHub CLI
$ gh skill install NoobyGains/godmode pattern-matching --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/NoobyGains/godmode.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/pattern-matching .claude/skills/pattern-matching && 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
pattern-matching
GitHub stars
107
Token cost
~2.1k tokens
SKILL.md length
655 words
Files
1
Skills in repo
34
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when contributing code to an existing project - guarantees that every new line mirrors the established conventions, naming schemes, architectural layering, directory layout…

  • Contributing code to an existing project - guarantees that every new line mirrors the established conventions
  • SKILL.md covers Overview, The Prime Directive, When to Use and The Entry Protocol, plus 7 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Architectural layering

What it does

Pattern Matching is an agent skill from NoobyGains/godmode. Use when contributing code to an existing project - guarantees that every new line mirrors the established conventions, naming schemes, architectural layering, directory layout, and stylistic choices already present in the codebase rather than drifting toward generic AI defaults

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

The repository describes itself as: The AI development framework that thinks before it builds. 36 composable skills for Claude Code, Cursor, Codex, and OpenCode. The licence is MIT.

When your agent uses it

  • Contributing code to an existing project - guarantees that every new line mirrors the established conventions
  • Architectural layering
  • Directory layout
  • Stylistic choices already present in the codebase rather than drifting toward generic AI defaults

Example prompts

  • “/pattern-matching”

What it can do on your machine

Read from SKILL.md and the folder at commit 441103a. 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.

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

  • Network

    No URLs in SKILL.md.

    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

Pattern Matching loads about 2.1k tokens when it runs. Until then it costs about 74 tokens; SKILL.md has 655 words of instructions outside code blocks.

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

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 NoobyGains/godmode at commit 441103a, republished under its MIT licence (© NoobyGains). 655 words, ~2,071 tokens.

Download SKILL.mdSave it as .claude/skills/pattern-matching/SKILL.md (or your agent's skills folder).
name
pattern-matching
description
Use when contributing code to an existing project - guarantees that every new line mirrors the established conventions, naming schemes, architectural layering, directory layout, and stylistic choices already present in the codebase rather than drifting toward generic AI defaults

Pattern Matching

Overview

Every codebase has a fingerprint. Your job is to replicate that fingerprint so precisely that no reviewer can tell where the original ends and your contribution begins.

Core principle: Observe before you act. Every function, file, and folder you produce must have a living precedent somewhere in the repository. If you cannot point to the model you followed, you have already introduced drift.

No exceptions. No workarounds. No shortcuts.

The Prime Directive

EVERY ADDITION MUST MIRROR AN EXISTING PRECEDENT

When the repository favors snake_case, you write snake_case. When services live under src/domain/, your service lands there too. When errors propagate through a custom Result<T> type, you adopt it without question. There is no room for personal preference.

When to Use

Mandatory in these situations:

  • Touching any file in a pre-existing repository
  • Introducing new modules, routes, or components into an established architecture
  • Contributing features to a project you did not originate
  • Performing refactors that reshape existing logic

Unnecessary when:

  • Bootstrapping a greenfield project (see godmode:project-bootstrap)
  • Writing disposable scripts that will never enter version control

The Entry Protocol

BEFORE producing any code in an existing repository:

1. SURVEY: Locate 2-3 files or functions that solve a comparable problem
2. CATALOG: Record every convention they share
   - Identifier formatting (camelCase, snake_case, PascalCase)
   - Directory taxonomy (where do peers of this file reside?)
   - Import conventions (relative paths, aliases, barrel files)
   - Error propagation strategy (exceptions, Result types, error codes)
   - State access patterns (global store, context injection, parameter passing)
   - Test co-location and framework choices
3. REPLICATE: Produce your code using the identical conventions
4. AUDIT: Hold your output beside the originals — does it pass as native?

Omit any step = drift introduced

Dimensions of Conformity

File-Level Conventions
BEFORE placing a new file:

1. Where do its siblings reside? (directory hierarchy)
2. How are filenames formed? (kebab-case.ts, PascalCase.tsx, snake_case.py)
3. What internal structure does each file follow? (imports, types, constants, logic, exports)
4. How are exports surfaced? (default export, named exports, re-export indexes)
Function-Level Conventions
BEFORE writing a new function, class, or component:

1. Identify an existing function that addresses a similar concern
2. Mirror its shape:
   - Argument style (destructured object vs positional args)
   - Return envelope (Promise<T>, Result<T, E>, nullable)
   - Error strategy (try/catch, .catch(), explicit error returns)
   - Observability (logger.info(), structured JSON, console methods)
   - Validation technique (Zod, Joi, manual guards, type narrowing)
3. Rely on the SAME libraries and utilities the project already depends on
   - Do not introduce ramda if the project uses native array methods
   - Do not pull in got if the project wraps fetch
   - Do not add a competing ORM when one is already wired in
Architecture-Level Conventions
BEFORE inserting a new module or layer:

1. How is the codebase stratified?
   - Routes -> Controllers -> Services -> Repositories?
   - Pages -> Components -> Hooks -> Helpers?
   - Handlers -> Domain -> Infrastructure?
2. Which way do imports flow?
3. Where does business logic concentrate?
4. How do cross-cutting concerns surface? (auth middleware, logging wrappers, error boundaries)

The Shadowing Method

The fastest route to conformity: locate the nearest relative and shadow it stroke for stroke.

1. LOCATE: "Find the file most similar to what I need to create"
2. STUDY: Absorb its structure, imports, error handling, naming, export style
3. DUPLICATE: Use it as a skeleton
4. SPECIALIZE: Swap in only the logic unique to your feature
5. COMPARE: Place them side by side — can you spot the newcomer?

Effective prompting pattern:

"Here is our existing payment service (src/services/payment.ts).
Produce the new subscription service using identical structure, patterns, and naming."

Showing a concrete example always outperforms describing rules in prose.

Typical Divergence Patterns

AI TendencyProject ConventionCorrection
console.log()Structured logger via winstonAdopt the project's logging pipeline
Generic try/catchDomain-specific ServiceError classThrow and catch using the project's error hierarchy
Inline Tailwind classesCSS Modules / styled-componentsFollow the project's styling methodology
axios for HTTPCustom fetch wrapper in lib/httpUse the wrapper the team built
New helper functionsExisting utility belt in utils/Audit utils/ before creating anything new
Flat file layoutFeature-folder nestingRespect the existing directory blueprint
Default exportsNamed exports throughoutAlign with the repository's export convention
Loose any typesStrict TypeScript with genericsMatch the project's type discipline
let declarationsconst by defaultMirror the existing variable declaration habit
Raw SQL stringsORM query builderUse the project's data access layer

Pre-Commit Verification

Before finalizing, confirm:

  • File resides in the appropriate directory (same neighborhood as its peers)
  • Filename obeys the prevailing naming scheme
  • Import order and alias usage match the established style
  • All identifiers (variables, functions, types) follow existing naming rules
  • Error handling echoes the repository's standard pattern
  • No new dependency duplicates an existing one
  • Tests adhere to the same framework, structure, and naming as existing tests
  • Logging channels through the project's logger
  • The code reads as though the original author wrote it
Show full SKILL.md (235 more words)Show less

Cognitive Traps

RationalizationTruth
"My approach is objectively superior"Uniformity outweighs individual taste. Conform to the codebase.
"This is a more contemporary technique"Modern does not mean appropriate for THIS repository. Match the existing reality.
"It is only a single file"One divergent file sets a precedent for ten more. Entropy compounds.
"I will harmonize everything later"You will not. Partial migration is more damaging than consistent legacy.
"The current pattern is flawed"Raise it with the human first. Unilateral convention changes are forbidden.
"This dependency is demonstrably better"Better in isolation does not justify duplication. The project already solved this.

Guardrails

Prohibited actions:

  • Importing a library that overlaps with one already in use
  • Applying a naming convention alien to the codebase
  • Placing a file where it violates the existing directory structure
  • Altering an established convention without explicit human approval
  • Writing code that is visually distinguishable from its neighbors

Required actions:

  • Examine 2-3 analogous files before writing anything
  • Exhaust the project's existing utilities before inventing new ones
  • Reproduce error handling, logging, and validation patterns verbatim
  • Seek permission before deviating ("The codebase uses X. Shall I continue with X or migrate to Y?")

Integration

Complementary skills:

  • godmode:ux-patterns -- Conformity applied to UI component conventions
  • godmode:design-integration -- Conformity applied to design system usage
  • godmode:quality-enforcement -- Automated checks that catch drift

Adjacent skills:

  • godmode:codebase-research -- Discover external patterns; this skill enforces internal ones
  • godmode:system-design -- Guides greenfield structure; this skill governs established codebases

© NoobyGains, 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 skills/pattern-matching of NoobyGains/godmode.

Open the folder on GitHubat commit 441103a

Compare with similar skills

Pattern Matching 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.

Pattern Matching compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Pattern Matching this skillNoobyGains/godmode107—~2.1kAutomated safety check: PassMIT
Golang Patternsaffaan-m/ECC274k—~1.1kAutomated safety check: PassMIT
Kotlin Exposed Patternsaffaan-m/ECC274k4 repos~5.5kAutomated safety check: PassMIT
Dotnet Patternsaffaan-m/ECC274k1 repos~2.3kAutomated safety check: PassMIT
Fastapi Patternsaffaan-m/ECC274k—~2.3kAutomated safety check: PassMIT
Python Patternsaffaan-m/ECC274k—~2.3kAutomated safety check: PassMIT

Similar skills

  • Golang Patterns

    affaan-m/ECC

    Go-specific design patterns and best practices including functional options, small interfaces, dependency injection, concurrency patterns, error handling, and package organization.

    274k GitHub stars~1.1k tokensUpdated 2 days ago
    DevelopmentAuto-check passed

  • Kotlin Exposed Patterns

    affaan-m/ECC

    JetBrains Exposed ORM patterns including DSL queries, DAO pattern, transactions, HikariCP connection pooling, Flyway migrations, and repository pattern.

    274k GitHub starsUsed in 4 repos~5.5k tokens
    DatabasesAuto-check passed

  • Dotnet Patterns

    affaan-m/ECC

    Idiomatic C and .NET patterns, conventions, dependency injection, async/await, and best practices for building robust, maintainable .NET applications.

    274k GitHub starsUsed in 1 repo~2.3k tokens
    DevelopmentAuto-check passed

  • Fastapi Patterns

    affaan-m/ECC

    FastAPI patterns for async APIs, dependency injection, Pydantic request and response models, OpenAPI docs, tests, security, and production readiness.

    274k GitHub stars~2.3k tokensUpdated 2 days ago
    Backend & APIsAuto-check passed

  • Python Patterns

    affaan-m/ECC

    Python-specific design patterns and best practices including protocols, dataclasses, context managers, decorators, async/await, type hints, and package organization.

    274k GitHub stars~2.3k tokensUpdated 2 days ago
    DevelopmentAuto-check passed

  • Patterns

    sickn33/agentic-awesome-skills

    Reference document for monopoly patterns. An agent skill from sickn33/agentic-awesome-skills.

    47k GitHub starsUsed in 1 repo~2.6k tokens
    Backend & APIsAuto-check passed

More from NoobyGains/godmode

All 34 skills in this repo

  • Activation

    NoobyGains/godmode

    A skill your agent uses when starting any conversation - establishes how to locate and invoke skills, mandating Skill tool usage before ANY response including clarifying questions

    107 GitHub stars~2.4k tokensUpdated 7 mo ago
    Auto-check passed

  • Agent Messaging

    NoobyGains/godmode

    A skill your agent uses when dispatching subagents, composing prompts for teammates, structuring handoff reports, or managing context boundaries between agents.

    107 GitHub stars~3k tokensUpdated 7 mo ago
    Auto-check passed

  • Codebase Research

    NoobyGains/godmode

    A skill your agent uses when building ANY feature within an existing project - search the current codebase for existing patterns, conventions, similar implementations, and established approaches…

    107 GitHub stars~3.2k tokensUpdated 7 mo ago
    Auto-check: notes

  • Completion Gate

    NoobyGains/godmode

    A skill your agent uses when about to declare work done, fixed, or passing, before committing or opening PRs - demands executing verification commands and reading their output before making any…

    107 GitHub stars~1.6k tokensUpdated 7 mo ago
    Auto-check passed

  • Comprehension Check

    NoobyGains/godmode

    A skill your agent uses when implementing any substantial feature, multi-file modification, or architectural change - produces a plain-language walkthrough of every alteration so the developer can…

    107 GitHub stars~1.5k tokensUpdated 7 mo ago
    Auto-check passed

  • Delegated Execution

    NoobyGains/godmode

    A skill your agent uses when executing implementation plans with independent tasks in the current session

    107 GitHub stars~2.4k tokensUpdated 7 mo ago
    Auto-check passed

Questions about Pattern Matching

What does Pattern Matching do?

A skill your agent uses when contributing code to an existing project - guarantees that every new line mirrors the established conventions, naming schemes, architectural layering, directory layout…. Pattern Matching is an agent skill from NoobyGains/godmode.

When should I use Pattern Matching?

Pattern Matching fits situations like: contributing code to an existing project - guarantees that every new line mirrors the established conventions; architectural layering; directory layout; stylistic choices already present in the codebase rather than drifting toward generic AI defaults.

How do I install Pattern Matching in Claude Code?

Run `npx skills add NoobyGains/godmode --skill pattern-matching -a claude-code`. Or copy the skill folder (skills/pattern-matching in NoobyGains/godmode) into .claude/skills/pattern-matching in your project. Claude Code loads it when a task matches its description.

How do I install Pattern Matching in Codex?

Run `npx skills add NoobyGains/godmode --skill pattern-matching -a codex`. Or copy the skill folder (skills/pattern-matching in NoobyGains/godmode) into .agents/skills/pattern-matching in your project. Codex loads it when a task matches its description.

Can I use Pattern Matching 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 NoobyGains/godmode --skill pattern-matching -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/pattern-matching, .gemini/skills/pattern-matching, .github/skills/pattern-matching and .opencode/skills/pattern-matching in your project.

What does Pattern Matching need to run?

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

Does Pattern Matching access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Pattern Matching 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 Pattern Matching use?

Pattern Matching 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 Pattern Matching use?

About 2.1k tokens (SKILL.md is roughly 8.3k 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 Pattern Matching?

Skills that share tags, products or a category with Pattern Matching: Golang Patterns (affaan-m/ECC, 274k stars), Kotlin Exposed Patterns (affaan-m/ECC, 274k stars), Dotnet Patterns (affaan-m/ECC, 274k stars) and Fastapi Patterns (affaan-m/ECC, 274k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Pattern Matching?

NoobyGains (a GitHub user) maintains it in NoobyGains/godmode, which has 107 GitHub stars. The repository holds 34 skills in this directory. The repository was last updated on March 9, 2026.

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