Prompt file imported from karngyan/stacktrace (.cursor/commands/find-gems.md). Copyright stays with the author.

Find Hidden Gems

Name: find-gems
Author: karngyan

Find "I had no idea about this" moments in any codebase that would surprise experienced engineers.

What Makes a Great Discovery

✅ Look For	❌ Avoid
Magic numbers with meaning (constants that spell words, π-derived values)	Well-known patterns (singleton, factory)
Defensive code with personality (comments explaining "why", past bugs)	Generic optimizations
Intentional limitations (code that restricts to prevent misuse)	Complex code that's just complex
Lock-free / wait-free patterns (rotating buffers, atomic swaps)	Features in official docs
Memory layout tricks (struct packing, cache-line alignment)	Anything needing 20 min of context
Historical artifacts (code from bugs 10 years ago)

Quick Scan Commands

# Comments with stories
rg -n "NOTE:|HACK:|XXX:|SAFETY:|careful|subtle|tricky" --type c --type go --type rust | head -50

# Magic constants
rg -n "0x[0-9A-Fa-f]{6,}" --type c --type h | head -30

# Concurrency tricks
rg -n "atomic|barrier|volatile|lock.free" --type c --type go | head -30

# Oldest surviving code
git log --diff-filter=A --reverse --format="%h %s" -- "*.c" "*.go" | head -20

# Most-edited files
git log --pretty=format: --name-only | sort | uniq -c | sort -rn | head -20

Evaluate Each Candidate

Must answer YES to all:

Would a senior engineer with 10+ years experience be surprised?
Is there a "villain"? (A bug, attack, or constraint that drove this design)
Can you explain it in 5 minutes?
Does it teach something applicable to other projects?

Output Format

For each discovery (find 3-5):

## [Catchy Title] ⭐⭐⭐⭐☆

**File:** `path/to/file:line`
**Hook:** [One sentence that would make someone click]

### The Code
[Show 10-50 lines]

### Why It's Interesting
[2-3 paragraphs: what it does, why it's surprising, what problem it solves]

### The Lesson
[Broader takeaway any developer can use]

### Backstory
- Git blame: [commit hash]
- Related: [issues/discussions if found]

Repository: [paste repo path or URL]

Focus area (optional): [e.g., "networking", "memory management"]

# Find Hidden Gems Find "I had no idea about this" moments in any codebase that would surprise experienced engineers. --- ## What Makes a Great Discovery | ✅ Look For | ❌ Avoid | | ------------------------------------------------------------------------- | ---------------------------------------- | | Magic numbers with meaning (constants that spell words, π-derived values) | Well-known patterns (singleton, factory) | | Defensive code with personality (comments explaining "why", past bugs) | Generic optimizations | | Intentional limitations (code that restricts to prevent misuse) | Complex code that's just complex | | Lock-free / wait-free patterns (rotating buffers, atomic swaps) | Features in official docs | | Memory layout tricks (struct packing, cache-line alignment) | Anything needing 20 min of context | | Historical artifacts (code from bugs 10 years ago) | | ## Quick Scan Commands ```bash # Comments with stories rg -n "NOTE:|HACK:|XXX:|SAFETY:|careful|subtle|tricky" --type c --type go --type rust | head -50 # Magic constants rg -n "0x[0-9A-Fa-f]{6,}" --type c --type h | head -30 # Concurrency tricks rg -n "atomic|barrier|volatile|lock.free" --type c --type go | head -30 # Oldest surviving code git log --diff-filter=A --reverse --format="%h %s" -- "*.c" "*.go" | head -20 # Most-edited files git log --pretty=format: --name-only | sort | uniq -c | sort -rn | head -20 ``` ## Evaluate Each Candidate Must answer YES to all: 1. Would a senior engineer with 10+ years experience be surprised? 2. Is there a "villain"? (A bug, attack, or constraint that drove this design) 3. Can you explain it in 5 minutes? 4. Does it teach something applicable to other projects? ## Output Format For each discovery (find 3-5): ``` ## [Catchy Title] ⭐⭐⭐⭐☆ **File:** `path/to/file:line` **Hook:** [One sentence that would make someone click] ### The Code [Show 10-50 lines] ### Why It's Interesting [2-3 paragraphs: what it does, why it's surprising, what problem it solves] ### The Lesson [Broader takeaway any developer can use] ### Backstory - Git blame: [commit hash] - Related: [issues/discussions if found] ``` --- **Repository:** [paste repo path or URL] **Focus area (optional):** [e.g., "networking", "memory management"]

{ "prompt": "# Find Hidden Gems\n\nFind \"I had no idea about this\" moments in any codebase that would surprise experienced engineers.\n\n---\n\n## What Makes a Great Discovery\n\n| ✅ Look For | ❌ Avoid |\n| ------------------------------------------------------------------------- | ---------------------------------------- |\n| Magic numbers with meaning (constants that spell words, π-derived values) | Well-known patterns (singleton, factory) |\n| Defensive code with personality (comments explaining \"why\", past bugs) | Generic optimizations |\n| Intentional limitations (code that restricts to prevent misuse) | Complex code that's just complex |\n| Lock-free / wait-free patterns (rotating buffers, atomic swaps) | Features in official docs |\n| Memory layout tricks (struct packing, cache-line alignment) | Anything needing 20 min of context |\n| Historical artifacts (code from bugs 10 years ago) | |\n\n## Quick Scan Commands\n\n```bash\n# Comments with stories\nrg -n \"NOTE:|HACK:|XXX:|SAFETY:|careful|subtle|tricky\" --type c --type go --type rust | head -50\n\n# Magic constants\nrg -n \"0x[0-9A-Fa-f]{6,}\" --type c --type h | head -30\n\n# Concurrency tricks\nrg -n \"atomic|barrier|volatile|lock.free\" --type c --type go | head -30\n\n# Oldest surviving code\ngit log --diff-filter=A --reverse --format=\"%h %s\" -- \"*.c\" \"*.go\" | head -20\n\n# Most-edited files\ngit log --pretty=format: --name-only | sort | uniq -c | sort -rn | head -20\n```\n\n## Evaluate Each Candidate\n\nMust answer YES to all:\n\n1. Would a senior engineer with 10+ years experience be surprised?\n2. Is there a \"villain\"? (A bug, attack, or constraint that drove this design)\n3. Can you explain it in 5 minutes?\n4. Does it teach something applicable to other projects?\n\n## Output Format\n\nFor each discovery (find 3-5):\n\n```\n## [Catchy Title] ⭐⭐⭐⭐☆\n\n**File:** `path/to/file:line`\n**Hook:** [One sentence that would make someone click]\n\n### The Code\n[Show 10-50 lines]\n\n### Why It's Interesting\n[2-3 paragraphs: what it does, why it's surprising, what problem it solves]\n\n### The Lesson\n[Broader takeaway any developer can use]\n\n### Backstory\n- Git blame: [commit hash]\n- Related: [issues/discussions if found]\n```\n\n---\n\n**Repository:** [paste repo path or URL]\n\n**Focus area (optional):** [e.g., \"networking\", \"memory management\"]", "variables": [], "notes": "Find \"I had no idea about this\" moments in any codebase that would surprise experienced engineers.", "metadata": { "source": { "provider": "github-cursor-commands", "repository": "https://github.com/karngyan/stacktrace", "path": ".cursor/commands/find-gems.md", "ref": "24c99280f382d554337fafc9f43cdf25769d465c", "url": "https://github.com/karngyan/stacktrace/blob/24c99280f382d554337fafc9f43cdf25769d465c/.cursor/commands/find-gems.md", "key": "karngyan/stacktrace/.cursor/commands/find-gems.md" } } }

find-gems

About

Find Hidden Gems

What Makes a Great Discovery

Quick Scan Commands

Evaluate Each Candidate

Output Format

Use it

Manifest

Reviews