slashnote-appslashnote-app/claude-code-plugin/skills/note-find/SKILL.md

note-find

Skill1 starsChanged 9 months agoMITView on GitHub

Search and surface relevant SlashNote notes by topic, content, or type

In this repository10 other files it gives its agents.
- note-bugSkill
- note-contextSkill
- note-decideSkill
- note-loopSkill
- note-meetingSkill
- noteSkill
- note-snippetSkill
- note-standupSkill
- note-todoSkill
- note-wrapupSkill

The file

Show its rules and text

We split this skill into the rules it gives an agent

16 rules. About 0 are common, 9 are distinctive, and 7 are very specific to this project.

≈0
Common · estimate
Many files like this have a rule of this kind.
≈9
Distinctive · estimate
This author's own choices. Worth a look.
7
Very specific
Tied to their project's names, files or tools. Probably skip.

Common
Distinctive
Very specific

Distinctive:
Search existing SlashNote notes and surface relevant ones.
line 14
Very specific:
Call mcp__slashnote__search_notes with the query
line 37
Distinctive:
If results found → display summary table
line 38
Distinctive:
If no results → try broader search (see "No Results" section)
line 39
Very specific:
Call mcp__slashnote__list_notes with brief: true for lighter token usage
line 65
Very specific:
Call mcp__slashnote__list_notes with limit: N, brief: true
line 89
Very specific:
Call mcp__slashnote__get_open_notes to get all visible notes with window positions and screen info
line 98
Distinctive:
When multiple results match, rank by:
line 141
Distinctive:
When search returns no results:
line 149
Distinctive:
Broaden the search: Remove least important words and retry
line 151
Distinctive:
Always show results as numbered list with color tag
line 158
Very specific:
If no notes at all → "No notes found.
line 162
Distinctive:
Keep output compact — one line per note
line 163
Very specific:
Do NOT read all notes' full content — use brief: true with list_notes for minimal token usage
line 164
Distinctive:
Only read full content when showing a specific note
line 165
Very specific:
Use list_notes filtering params: pinned, is_open, tag to narrow results server-side
line 166

≈ “Common” is an estimate: at least 1 in 5 of the 350,495 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.

Files

SKILL.md

/note-find — Search & Surface

Search existing SlashNote notes and surface relevant ones.

Usage

/note-find <query>                    # Search by content/topic
/note-find <query> --type note-bug    # Combined: content + type filter
/note-find --type note-bug            # Filter by note type (color)
/note-find --recent                   # Show recently modified notes
/note-find --recent 5                 # Show N most recent
/note-find --open                     # Show all currently open notes
/note-find --pinned                   # Show pinned notes only

Search Modes

Content Search (default)

/note-find auth
/note-find WebSocket bug
/note-find meeting with Alex

Call mcp__slashnote__search_notes with the query
If results found → display summary table
If no results → try broader search (see "No Results" section)
Show the most relevant note via mcp__slashnote__show_note

Combined Search (query + flag)

/note-find auth --type note-bug         # Bugs mentioning "auth"
/note-find API --type note-decide       # Decisions about "API"
/note-find login --type note-snippet    # Code snippets about "login"

Call mcp__slashnote__search_notes with the query
Filter results by type (color/pattern)
Display matching subset

Type Filter (`--type`)

/note-find --type note-bug        # Pink notes (bugs)
/note-find --type note-todo       # Peach notes (checklists)
/note-find --type idea            # Blue notes with "Idea" heading
/note-find --type note-snippet    # Purple notes (code)
/note-find --type note-meeting    # Blue notes with meeting patterns
/note-find --type note-decide     # Green notes with decision patterns
/note-find --type note-loop       # Green notes with "/note-loop" heading
/note-find --type note-context    # Blue notes with "Context" heading

Call mcp__slashnote__list_notes with brief: true for lighter token usage
Filter by color + content pattern:

Type	Color	Pattern
`note-bug`	pink	—
`note-todo`	peach	has checkboxes
`idea`	blue	has "Idea" heading
`note-snippet`	purple	has code blocks
`note-meeting`	blue	has "Key Points" or "Action Items"
`note-decide`	green	has "Decision:" or "Over:"
`note-loop`	green	has "/note-loop" heading
`note-context`	blue	has "Context" heading

Display matching notes as summary table

Optimization: For type-only filters that map to a single color, use tag parameter in list_notes if a matching tag exists, or filter by color client-side from the brief response.

Recent (`--recent`)

/note-find --recent
/note-find --recent 5

Call mcp__slashnote__list_notes with limit: N, brief: true
Notes are returned sorted by updatedAt (most recent first)
Show top N notes (default: 5, max: 10)

Open (`--open`)

/note-find --open

Call mcp__slashnote__get_open_notes to get all visible notes with window positions and screen info
Show all currently visible notes with their screen positions

Pinned (`--pinned`)

/note-find --pinned

Call mcp__slashnote__list_notes with pinned: true, brief: true
Show all pinned notes

Output Format

Display results as a compact summary:

Found N notes:

1. 📌 [green] /note-loop — 3/5 tasks done
2. [pink] Bug: Login crash — Feb 18
3. [blue] Sprint Planning — 2 action items
4. [purple] JWT validation — 15 lines Swift
5. [peach] Shopping list — 4 items, 1 done

Showing #1. Say "show 2" to open another.

Summary Line Rules

Note Type	Summary Format
Checklist (peach)	`<title> — N items, M done`
Bug (pink)	`<title> — <severity if present>, <date>`
Idea (blue)	`<title> — <first 8 words>...`
Code (purple)	`<title> — N lines <language>`
Meeting (blue)	`<title> — N action items`
Decision (green)	`<title> — <decision one-liner>`
/note-loop (green)	`<title> — N/M tasks done`
Context (blue)	`<title> — <date>`
Other	`<title> — <first 8 words>...`

Result Ranking

When multiple results match, rank by:

Pinned notes first — they represent active/important items
Recency — more recently updated notes rank higher
Content match — exact title match > content match
Pinned notes get a 📌 prefix in the output

No Results Handling

When search returns no results:

Broaden the search: Remove least important words and retry
- "WebSocket connection bug" → try "WebSocket bug" → try "WebSocket"
Suggest alternatives: "No notes found for 'auth'. Try /note-find --type note-bug or /note-find --recent"
Offer creation: "Create one with /note <text> or /note-bug <description>"

Rules

Always show results as numbered list with color tag
Auto-show the most relevant result (highest-ranked match)
User can say "show 2", "show 3" to open other results
Max 10 results per search
If no notes at all → "No notes found. Create one with /note <text>"
Keep output compact — one line per note
Do NOT read all notes' full content — use brief: true with list_notes for minimal token usage
Only read full content when showing a specific note
Use list_notes filtering params: pinned, is_open, tag to narrow results server-side
Flags can be combined: /note-find auth --type note-bug --pinned works

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

It worked
Partly
It didn't

What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

Check your setup, free