Skip to main content
skill CX Codex

pattern-detection · rsmdt — Claude Code skill: what it does, how to install

pattern-detection finds naming conventions, architectural layers, and test styles across files. Keeps generated code aligned with repository habits.

MIT ★ 587 updated 2026-10-26

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startup
Open on GitHub

What pattern-detection does

The skill scans existing files before code generation or review tasks. It inspects naming rules, folder layering, error handling, imports, and test setup. To verify a convention, the agent reviews 3 to 5 sample files of each category and cites exact file and line references as evidence.

When codebases show mixed conventions, the workflow flags explicit conflicts. It contrasts both examples, checks commit recency, and gives preference to practices guarded by linter configs or used in the specific target folder. A single file occurrence never counts as an established pattern.

Findings populate a structured report ranked by confidence levels. If an approach appears in over 80% of samples or in CONTRIBUTING.md, it receives top priority, preventing contradictory conventions from slipping into pull requests.

What it helps with

  • detect project naming conventions for files, methods, and variables
  • inspect directory layering and import flows before scaffolding new features
  • resolve conflicting code conventions between legacy and recent files
  • document testing and mocking styles with concrete file references

Example prompts for the agent

  • Analyze naming conventions and test placement in src/modules/billing using pattern-detection
  • Check architecture and import patterns in the repository before writing a new service
  • Find error handling conventions across existing endpoints and report line numbers

How to install pattern-detection

1Plugin marketplace

/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startup

This installs the whole team plugin with all its skills

2Skills CLI (Vercel)

npx skills add rsmdt/the-startup --skill pattern-detection -a claude-code

3Manually: put the files in place

~/.claude/skills/pattern-detection/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/pattern-detection/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about pattern-detection

How to install pattern-detection in Claude Code?

Run /plugin marketplace add rsmdt/the-startup followed by /plugin install team@the-startup. You can also add it directly using npx skills add rsmdt/the-startup --skill pattern-detection -a claude-code.

What does pattern-detection do?

It inspects codebase files across naming, architecture, tests, and formatting, building a report of verified conventions with concrete file and line citations.

How does it handle conflicting conventions?

It surfaces both code examples, compares their recency, and favors the convention enforced by tooling or already adopted in the folder being edited.

Source text

SKILL.md · MIT
---
name: pattern-detection
description: Identify existing codebase patterns (naming conventions, architectural patterns, testing patterns) to maintain consistency. Use when generating code, reviewing changes, or understanding established practices.
---

## Persona

Act as a codebase pattern analyst that discovers, verifies, and documents recurring conventions across naming, architecture, testing, and code organization to ensure new code maintains consistency with established practices.

**Analysis Target**: $ARGUMENTS

## Interface

PatternCategory: NAMING | ARCHITECTURE | TESTING | ORGANIZATION | ERROR_HANDLING | CONFIGURATION

Confidence: HIGH | MEDIUM | LOW

Pattern {
  category: PatternCategory
  name: string                   // e.g., "PascalCase component files"
  description: string            // what the pattern is
  evidence: string[]             // file:line examples that demonstrate it
  confidence: Confidence
  isDocumented: boolean          // found in style guide or CONTRIBUTING.md
}

PatternReport {
  patterns: Pattern[]
  conflicts: PatternConflict[]   // where patterns are inconsistent
  recommendations: string[]      // for new code
}

PatternConflict {
  category: PatternCategory
  description: string
  exampleA: string               // file:line of pattern A
  exampleB: string               // file:line of pattern B
  recommendation: string         // which to follow and why
}

State {
  target = $ARGUMENTS
  samples = []
  patterns = []
  conflicts = []
}

## Constraints

**Always:**
- Survey at least 3-5 representative files of each type before declaring a pattern.
- Provide concrete file:line evidence for every detected pattern.
- Distinguish between intentional conventions and accidental consistency.
- Follow existing patterns even if imperfect — consistency trumps preference.
- Check tests for patterns too — test code reveals expected conventions.
- Recommend the pattern used in the specific area being modified when conflicts arise.
- When tied on conflicts, prefer the pattern with tooling enforcement.

**Never:**
- Declare a pattern from a single file occurrence.
- Assume patterns from other projects apply to this codebase.
- Introduce new patterns without acknowledging deviation from existing ones.
- Ignore conflicting patterns — always surface and recommend resolution.

## Reference Materials

- [Pattern Catalogs](reference/pattern-catalogs.md) — Naming, architecture, testing, and organization pattern catalogs with detection guidance
- [Common Patterns](examples/common-patterns.md) — Concrete examples of pattern recognition and application in real codebases

## Workflow

### 1. Survey Files

Determine scope:

match (target) {
  specific file     => survey sibling files in same directory
  directory/module  => survey representative files across subdirectories
  entire codebase   => sample from each major directory/module
}

For each scope, collect representative samples:
1. Read 3-5 files of each relevant type (source, test, config).
2. Prioritize files in the same module/feature as the target.
3. Include style guides, CONTRIBUTING.md, linter configs if present.
4. Note file ages — newer files may represent intended direction.

Read reference/pattern-catalogs.md for detection guidance.

### 2. Identify Patterns

Scan samples across each PatternCategory:

match (category) {
  NAMING => {
    File naming convention (kebab, PascalCase, snake_case)
    Function/method verb prefixes (get/fetch/retrieve)
    Variable naming (pluralization, private indicators)
    Boolean prefixes (is/has/can/should)
  }
  ARCHITECTURE => {
    Directory structure layering (MVC, Clean, Hexagonal, feature-based)
    Import direction and dependency flow
    State management approach
    Module boundary conventions
  }
  TESTING => {
    Test file placement (co-located, mirror tree, feature-based)
    Test naming style (BDD, descriptive, function-focused)
    Setup/teardown conventions
    Assertion and mock patterns
  }
  ORGANIZATION => {
    Import ordering and grouping
    Export style (default vs named)
    Comment and documentation patterns
    Code formatting conventions
  }
}

For each detected pattern, record: name, description, 2+ evidence locations, confidence level.

### 3. Verify Intentionality

For each detected pattern:
1. Check if documented in style guide or CONTRIBUTING.md.
2. Check linter/formatter configs that enforce it.
3. Count occurrences — high consistency = likely intentional.
4. Check commit history — was it introduced deliberately?

Assign confidence:

match (evidence) {
  documented + enforced by tooling  => HIGH
  consistent across 80%+ of files  => HIGH
  consistent across 50-80% of files => MEDIUM
  found in < 50% of files           => LOW — may be accidental
}

### 4. Detect Conflicts

Compare patterns within each category for inconsistencies (e.g., some files use camelCase, others use snake_case).

For each conflict:
1. Identify both variations with evidence.
2. Check date/author patterns — newer code may represent intended direction.
3. Check if one variation is in the target area being modified.
4. Recommend which pattern to follow with rationale.

### 5. Document Patterns

Produce PatternReport:
1. Confirmed patterns (HIGH confidence first).
2. Probable patterns (MEDIUM confidence).
3. Conflicts detected with resolution recommendations.
4. Recommendations for new code in the target area.

© Rudolf S. · MIT · rsmdt/the-startup

Similar skills

All skills for Code review and refactoring →

pattern-detection by other authors comes first.

pattern-detection akillness pattern-detection is a Claude Code skill that groups recurring bugs, log anomalies, and suspicious code into a review packet before debugging or patching. CX Codex +1 362installs brooks-lint hyhmrright brooks-lint evaluates production code and test suites against classic engineering literature. Delivers a health score with cited remedies. ★ 1,584repo stars llm-artifacts-detection existential-birds llm-artifacts-detection detects leftover cruft from AI coding assistants: dead code, duplicate test helpers, redundant wrapper classes, and obvious comments. CX Codex +1 151installs component-common-domain-detection tech-leads-club component-common-domain-detection finds business logic repeated across components and proposes what to pull into a shared service, a library, or a single component. CX Codex +1 ★ 7,191repo stars test-smell-detection dotnet test-smell-detection audits existing tests against the formal testsmells.org taxonomy, ranking issues by severity. Helpful when you need an academic assessment of test code quality. CX Codex +1 4,400installs coding davidkiss coding is a Claude Code skill that sets general practices for writing and reviewing software. It activates for implementation, refactoring, and code review tasks. CX Codex +1 394installs dart-use-pattern-matching dart-lang dart-use-pattern-matching is a Claude Code skill that applies Dart 3 pattern matching, switch expressions, and destructuring. It runs when refactoring nested if-else chains or parsing JSON schemas. CX Codex +1 20,800installs

From the same set50

The whole set →
security-assessment security-assessment — a Claude skill that runs a security audit: STRIDE threat modelling, OWASP-based code review, and findings ranked by severity with fixes. CX Codex +1 ★ 587repo stars technical-writing technical-writing drafts architecture decision records, system architecture overviews, API references, and operations runbooks directly in your codebase. CX Codex +1 ★ 587repo stars refactor The refactor skill analyzes a chosen part of a codebase and guides step-by-step cleanup while preserving behavior. Use it to improve readability without changing business logic. CX Codex +1 ★ 587repo stars requirements-elicitation requirements-elicitation is a Claude Code skill that turns vague ideas into testable requirements with priorities and acceptance criteria. CX Codex +1 ★ 587repo stars monitor-production The monitor-production subagent plans production metrics, logs, traces, alerts, and dashboards. Use it when defining SLOs or investigating recurring service failures. CX Codex ★ 587repo stars review-compatibility review-compatibility — a subagent for Claude Code that examines code for breaking changes to APIs, databases, and configs. CX Codex ★ 587repo stars specify-requirements specify-requirements is a Claude Code skill that drafts and validates PRDs in spec.md, structuring user stories and acceptance criteria. CX Codex +1 ★ 587repo stars build-feature build-feature is a Claude Code subagent that implements features across UI, APIs, services, and other project layers. It joins coding requests to build or change something. CX Codex ★ 587repo stars

Project sponsors

Companies that keep this analytics open