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
/plugin marketplace add rsmdt/the-startup
/plugin install team@the-startupWhat 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/billingusing 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-startupThis installs the whole team plugin with all its skills
2Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill pattern-detection -a claude-code3Manually: put the files in place
~/.claude/skills/pattern-detection/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/pattern-detection/
1Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill pattern-detection -a codex2Manually: put the files in place
.agents/skills/pattern-detection/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill pattern-detection -a cursor2Manually: put the files in place
.cursor/skills/pattern-detection/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install rsmdt/the-startup plugins/team/skills/cross-cutting/pattern-detection2Manually: put the files in place
.github/skills/pattern-detection/SKILL.md1Skills CLI (Vercel)
npx skills add rsmdt/the-startup --skill pattern-detection -a gemini-cli2Platform CLI
gemini skills install https://github.com/rsmdt/the-startup --path plugins/team/skills/cross-cutting/pattern-detectionManually: put the files in place
.devin/skills/pattern-detection/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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.