Skip to content
Skills Library
Programming · Research

code-search

/code-search

Search for patterns inside file contents using ripgrep (rg). Use when searching for code patterns, finding function definitions, locating usages, or when the user asks to search/grep content inside files.

Licence
MIT
Last repository change
17.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 17.08.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Search for patterns inside file contents using ripgrep (rg). Use when searching for code patterns, finding function definitions, locating usages, or when the user asks to search/grep content inside files.

Original author description

Search for patterns inside file contents using ripgrep (rg). Use when searching for code patterns, finding function definitions, locating usages, or when the user asks to search/grep content inside files.

How it works

  1. Prerequisites
  2. Quick Reference
  3. Core rg Options
  4. Common Search Patterns
  5. Search Strategies
  6. Regex Tips
  7. Performance Tips
  8. Advanced Options
Original SKILL.md headings · 234 lines, 748 words
SKILL.md preview
---
name: code-search
description: Search for patterns inside file contents using ripgrep (rg). Use when searching for code patterns, finding function definitions, locating usages, or when the user asks to search/grep content inside files.
allowed-tools: Bash, Read, Task
---

# Code Search Skill

Use **ripgrep (`rg`)** for searching patterns inside file contents. For finding files by name, use the `file-nav` skill instead.

## Prerequisites

If `rg` is not installed, recommend the user install it:

```bash
# Arch Linux
sudo pacman -S ripgrep

# Ubuntu/Debian
sudo apt install ripgrep

# macOS
brew install ripgrep

# Cargo
cargo install ripgrep
```

## Quick Reference

| Task | Command |
|------|---------|
| Search content | `rg "pattern"` |
| List matching files | `rg -l "pattern"` |
| Search with context | `rg -C 3 "pattern"` |

## Core rg Options

### Output Control

```bash
rg "pattern"              # Show matching lines (default)
rg -l "pattern"           # List files only (--files-with-matches)
rg -c "pattern"           # Count matches per file
rg -o "pattern"           # Only show matched text
```

### Context Lines

```bash
rg -A 5 "pattern"         # 5 lines after
rg -B 5 "pattern"         # 5 lines before
rg -C 5 "pattern"         # 5 lines before and after
```

### Filtering by File Type

```bash
rg -t clojure "pattern"   # Only Clojure files
rg -t js "pattern"        # Only JavaScript files
rg -t py "pattern"        # Only Python files
rg -t rust "pattern"      # Only Rust files
rg -T test "pattern"      # Exclude test files

rg -g "*.clj" "pattern"   # Glob filter
rg -g "!*.test.*" "pat"   # Exclude glob pattern
```

### Scope

```bash
rg "pattern" src/         # Search specific directory
rg "pattern" file.clj     # Search specific file
```

### Case Sensitivity

```bash
rg -i "pattern"           # Case insensitive
rg -s "pattern"           # Case sensitive (default)
rg -S "pattern"           # Smart case (insensitive if all lowercase)
```

### Line Numbers

```bash
rg -n "pattern"           # Show line numbers (default)
rg -N "pattern"           # Hide line numbers
```

### Multiline

```bash
rg -U "pattern"           # Multiline mode (pattern can span lines)
rg -U "start.*?end"       # Non-greedy multiline match
```

### Limiting Output

```bash
rg -m 5 "pattern"         # Max 5 matches per file
rg "pattern" | head -20   # First 20 lines of output
```

## Common Search Patterns

### Find Function Definitions

```bash
# Clojure
rg -t clojure "\(defn\s+my-function"
rg -t clojure "\(defn-?\s+my-function"  # defn or defn-

# JavaScript/TypeScript
rg -t js "function\s+myFunction|const\s+myFunction\s*="
rg -t ts "function\s+myFunction"

# Python
rg -t py "def\s+my_function"

# Go
rg -t go "func\s+MyFunction"

# Rust
rg -t rust "fn\s+my_function"
```

### Find Class/Type Definitions

```bash
# Clojure defrecord/deftype
rg -t clojure "\(def(record|type)\s+MyType"

# TypeScript interface/type
rg -t ts "(interface|type)\s+MyType"

# Python class
rg -t py "class\s+MyClass"

# Java/Kotlin class
rg -t java "class\s+MyClass"
```

### Find Usages/References

```bash
# Find all uses of a symbol
rg -C 2 "my-function"

# Word boundary match (avoid partial matches)
rg -w "user"

# Find require/import statements
rg "\[my\.namespace" -t clojure
rg "import.*MyModule" -t js
rg "from.*import.*my_func" -t py
```

### Find TODO/FIXME Comments

```bash
rg -i "(TODO|FIXME|HACK|XXX)"
rg -i "TODO" -C 1
```

### Find Configuration Values

```bash
rg "database|connection" -g "*.{yml,yaml,json,edn}"
rg "password|secret|key" -g "*.env*"
```

## Search Strategies

### 1. Broad to Narrow

Start with file listing, then search with context:

```bash
# Step 1: Find files containing pattern
rg -l "authentication"

# Step 2: Search specific file with context
rg -C 5 "authentication" src/auth.clj
```

### 2. Definition + Usages (run in parallel)

```bash
# Find definition
rg -t clojure "\(defn\s+create-user" -A 10

# Find usages
rg "create-user" -C 2
```

### 3. Exclude Tests/Vendor

```bash
rg "pattern" -g "!*test*" -g "!vendor/*" -g "!node_modules/*"
```

### 4. Multiple File Types

```bash
rg "pattern" -t clojure -t edn
rg "pattern" -g "*.{ts,tsx,js,jsx}"
```

## Regex Tips

- `\s+` for whitespace
- `\(` for literal parentheses
- `.*?` for non-greedy matching
- `[^)]+` for anything except closing paren
- `\{` and `\}` for literal braces
- `(?:...)` for non-capturing groups
- `\b` for word boundaries
- `^` and `$` for line start/end

## Performance Tips

1. **Use `-t type` filters** - Much faster than searching all files
2. **Use `-l` first** - Cheaper than showing content
3. **Specify directory** - `rg "pattern" src/` narrows scope
4. **Use `-m N`** - Stop after N matches per file
5. **Parallel searches** - Run independent rg commands in parallel
6. **Exclude directories** - `-g "!node_modules/*"` etc.

## Advanced Options

```bash
rg --hidden "pattern"     # Include hidden files
rg --no-ignore "pattern"  # Don't respect .gitignore
rg -uuu "pattern"         # Unrestricted (all files)
rg --json "pattern"       # JSON output for parsing
rg -p "pattern" | less -R # Pager with color
```

Versions

RepositoryScoreLicence
This page · brettatoms/agent-skills100MIT
langwatch/langwatch100Apache-2.0
edmundmiller/dotfiles100MIT
atretyak1985/swarmery100Apache-2.0
athola/claude-night-market100MIT
elastic/sourcerer100Apache-2.0
agentscope-ai/agentscope-java90Apache-2.0

Database snapshot: 13.11.2026 · package version 3b645e3b154d (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100file-search
    This skill should be used when agents need to search codebases for text patterns or structural code patterns. Provides fast search using ripgrep for text and ast-grep for syntax-aware code search.
  • 100rg-code-search
    ripgrep (rg) fast code search: smart defaults, regex, file filtering. Use when searching for text patterns, code snippets, or doing multi-file analysis.
  • 95file-search
    Modern file and content search using fd, ripgrep (rg), and fzf. Triggers on: fd, ripgrep, rg, find files, search code, fzf, fuzzy find, search codebase.
  • 100ripgrep
    Fast, recursive search tool for pattern matching in files with regex support, ignore handling, and glob filtering. Use when searching codebases for patterns, finding function definitions, filtering by file type, or performing find/replace operations. Triggers: "search for X in…
  • 95mgrep-code-search
    Semantic code search using mgrep for efficient codebase exploration. This skill should be used when searching or exploring codebases with more than 30 non-gitignored files and/or nested directory structures. It provides natural language semantic search that complements…
  • 100file-search
    Perform fast file name and content searches with ripgrep (rg); use it when you need to locate files by glob/regex, find keywords across directories, or replace common find/grep workflows.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.