# Hodios paste pack: Note-taking

Everything in Note-taking from Hodios, the open prompt library by Hermes IDE: 55 entries, catalog 2026.1014.1.

Every entry is dedicated to the public domain under CC0 1.0. Copy, change and share them freely, no attribution needed.

Browse and search the library at https://hermes-ide.com/prompts

## How to use

Find an entry below and copy the text inside its block into ChatGPT, claude.ai or any chat. Replace each [PLACEHOLDER] with your own material. Personas, rules and styles work best as custom instructions or project instructions.

## Contents

- Note-taking
  - [Apply progressive summarization to a note](#apply-progressive-summarization) (prompt)
  - [Archive a finished project's notes](#archive-finished-project-notes) (prompt)
  - [Audit a notes collection](#audit-notes-vault) (prompt)
  - [Build a personal CRM for staying in touch](#build-personal-crm) (prompt)
  - [Build a team wiki structure](#build-team-wiki-structure) (prompt)
  - [Choose a notes app](#choose-notes-app) (prompt)
  - [Convert a document to Markdown notes](#convert-document-to-markdown) (prompt)
  - [Design a daily note template](#design-daily-note-template) (prompt)
  - [Design a note tagging scheme](#design-note-tagging-scheme) (prompt)
  - [Design a personal knowledge system](#design-second-brain) (prompt)
  - [Digitize paper notebooks](#digitize-paper-notebooks) (prompt)
  - [Make reading notes](#make-reading-notes) (prompt)
  - [Merge overlapping notes](#merge-overlapping-notes) (prompt)
  - [Migrate notes between apps](#migrate-notes-between-apps) (prompt)
  - [Notes collection cleanup track](#notes-vault-cleanup-track) (workflow)
  - [Notes system coach](#notes-system-coach) (persona)
  - [Organise a phone notes app](#organize-phone-notes-app) (prompt)
  - [Organise a recipe collection](#organize-recipe-collection) (prompt)
  - [Organise browser bookmarks](#organize-browser-bookmarks) (prompt)
  - [Organise digital files](#organize-digital-files) (prompt)
  - [Outline a draft from your notes](#outline-draft-from-notes) (prompt)
  - [Plan notes backup and export](#plan-notes-backup-and-export) (prompt)
  - [Process a brain dump](#process-brain-dump) (prompt)
  - [Process a notes inbox](#process-notes-inbox) (prompt)
  - [Process a screenshot backlog](#process-screenshot-backlog) (prompt)
  - [Reorganise a team shared drive](#reorganize-shared-drive) (prompt)
  - [Resurface relevant notes for a project](#resurface-relevant-notes) (prompt)
  - [Set up a bullet journal](#set-up-bullet-journal) (prompt)
  - [Set up a commonplace book](#set-up-commonplace-book) (prompt)
  - [Set up a handwritten notes app](#set-up-handwritten-notes-app) (prompt)
  - [Set up a note review routine](#set-up-note-review-routine) (prompt)
  - [Set up a notes system](#set-up-notes-system) (prompt)
  - [Set up a Notion workspace](#set-up-notion-workspace) (prompt)
  - [Set up a project notebook](#set-up-project-notebook) (prompt)
  - [Set up a reading highlights workflow](#set-up-reading-highlights-workflow) (prompt)
  - [Set up a work logbook](#set-up-work-logbook) (prompt)
  - [Set up an Obsidian vault](#set-up-obsidian-vault) (prompt)
  - [Set up one-on-one notes for your team](#set-up-one-on-one-notes) (prompt)
  - [Set up OneNote notebooks](#set-up-onenote-notebooks) (prompt)
  - [Set up quick note capture](#set-up-quick-note-capture) (prompt)
  - [Split a long note into atomic notes](#split-note-into-atomic-notes) (prompt)
  - [Start a new-job notebook](#start-new-job-notebook) (prompt)
  - [Structure messy notes](#structure-messy-notes) (prompt)
  - [Suggest links between notes](#suggest-links-between-notes) (prompt)
  - [Tidy a handwritten notes transcript](#tidy-handwritten-notes-transcript) (prompt)
  - [Triage a reading list](#triage-reading-list) (prompt)
  - [Write a household operations manual](#write-household-operations-manual) (prompt)
  - [Write a map of content](#write-map-of-content) (prompt)
  - [Write a note for your future self](#write-note-for-future-self) (prompt)
  - [Write a Notion formula](#write-notion-formula) (prompt)
  - [Write a today-I-learned note](#write-til-note) (prompt)
  - [Write a weekly note from daily notes](#write-weekly-note-from-dailies) (prompt)
  - [Write an Obsidian Dataview query](#write-obsidian-dataview-query) (prompt)
  - [Write an Obsidian Templater template](#write-obsidian-templater-template) (prompt)
  - [Write note templates](#write-note-templates) (prompt)

---

<a id="apply-progressive-summarization"></a>

## Apply progressive summarization to a note

`apply-progressive-summarization` · prompt · Note-taking · https://hermes-ide.com/prompts/apply-progressive-summarization

Adds layers to a saved note or clipping - bold the key passages, highlight the best of those, then write a short summary in your words on top - so a future skim takes seconds.

````markdown
<context>
Progressive summarization is a way of making saved material skimmable without rewriting it. Layer one is the original text. Layer two bolds the passages that carry the main points, usually 10 to 20 percent. Layer three highlights the best of the bold, usually a few sentences. Layer four is a short summary in plain words at the top. The value comes from being selective: bolding half the text helps nobody. The layers should reflect why the person saved the material, not a generic summary, and the original wording must be preserved so the note can still be quoted.

<note>
[NOTE]
</note>
</context>

<task>
1. If the note is under about 80 words, say that layering adds little and give only a one-line summary.
2. Keep the original text unchanged. Mark layer two with **bold** on roughly 10 to 20 percent of the text, choosing passages that carry claims, numbers, steps or surprising points relevant to why it was saved.
3. Mark layer three with ==highlight== (inside the bold) on the best few sentences. If the person's app does not support this syntax they can convert it; mention that once.
4. Write a summary of three to five bullet points in plain words at the top, each traceable to a highlighted passage.
5. Explain briefly why you chose those passages, and name anything important you left un-bolded on purpose.
</task>

<constraints>
- Do not change, cut or reorder the original text; only add markup.
- Do not let bold cover more than about a fifth of the text.
- The summary must not add claims that are not in the text.
- Keep the source line if one was given.
</constraints>

<output_format>
## Summary
## Layered note
The full original text with bold and highlight markup.
## Why these passages
</output_format>
````

---

<a id="archive-finished-project-notes"></a>

## Archive a finished project's notes

`archive-finished-project-notes` · prompt · Note-taking · https://hermes-ide.com/prompts/archive-finished-project-notes

Closes out a finished project's notes - a one-page summary, decisions and lessons, final files and links, what moves to reference - and archives the rest so it can be found years later.

````markdown
<context>
Finished projects leave dozens of notes behind: meeting notes, drafts, quotes, research, to-do lists. Left in place, they clutter active work; dumped into an archive unread, they are useless when the same kind of project comes round again ("what did we pay the electrician?", "why did we choose that supplier?"). A good close-out takes under an hour and produces one summary note that answers the questions future-you will ask: what was done, the final result and where it lives, key numbers, decisions with reasons, contacts, what went wrong and what to do differently. Notes with lasting value beyond this project (a contractor's details, a reusable checklist, research on a topic) move to reference or areas; the rest is archived intact, not deleted, because the cost of keeping text is low.

Project: [PROJECT]

Notes:
[NOTES]
</context>

<task>
1. If the notes are too thin to summarise, say what is missing and ask for it, then stop.
2. Write the project summary note: what it was, dates, outcome, final files and their locations, key numbers stated in the notes, decisions with reasons, people and contacts by role, and lessons.
3. Write lessons as specific, reusable rules (for example "get three quotes in writing before booking trades"), split into keep doing and change.
4. Sort every note into: move to reference or an area (lasting value), merge into the summary, archive as is, or delete (only empty notes and exact duplicates).
5. Flag loose ends: unchecked tasks, unpaid invoices, warranties, guarantees, renewal dates or follow-ups that outlive the project, and say where each should go (task list or calendar).
6. Give archiving steps: where the folder goes, a naming rule with year, and adding a link from the summary to the archive.
7. Before answering, check that every number and name in the summary appears in the notes.
</task>

<constraints>
- Use only facts in the notes; leave a clearly marked blank where a detail is missing.
- Do not delete anything except empty notes and exact duplicates.
- Keep the summary to about one page.
- Phone numbers, emails and addresses of other people stay as given; do not add any.
</constraints>

<output_format>
## Project summary
The summary note in a fenced markdown block.
## Lessons
## Where each note goes
Table: Note | Action | Destination.
## Loose ends
## Archive steps
</output_format>
````

---

<a id="audit-notes-vault"></a>

## Audit a notes collection

`audit-notes-vault` · prompt · Note-taking · https://hermes-ide.com/prompts/audit-notes-vault

Audits a notes collection from a pasted file list or index, finding duplicates, orphans, stale drafts, empty notes and misfiled notes, and gives a keep, merge, archive or delete plan.

````markdown
<context>
A notes collection gets hard to use long before it gets big. The usual causes are near-duplicate notes on the same topic written months apart, "Untitled" and empty notes from quick capture, drafts that were never finished, notes from an old job or course mixed with current ones, and orphans that nothing links to and no folder explains. A good audit works from evidence (titles, dates, sizes, links), proposes reversible actions first (archive before delete), and leaves judgement calls to the owner, because only they know whether a two-line note is junk or a key password hint.

Inventory:
<inventory>
[INVENTORY]
</inventory>
Purpose and pain: [PURPOSE]
</context>

<task>
1. If the inventory is empty or is not a list of notes, ask for a pasted list and stop. If dates, sizes or link counts are missing, say which checks you cannot do.
2. Summarise the collection: rough counts by folder or type, age spread, and the biggest problem you see.
3. Find and quote candidates in each group: likely duplicates or overlaps (similar titles), empty or tiny notes, "Untitled" or dated-only titles, stale drafts, orphans, notes that sit in the wrong folder for their title, and notes that belong to a finished chapter of life (old job, finished course).
4. Give each candidate an action: keep, rename, merge into (named note), move, archive or delete-after-check. Prefer archive over delete.
5. Order the work so the biggest gain comes first, in sessions of about 30 minutes.
6. Ask the questions only the owner can answer (for example "Is the 'Old laptop' note still needed for anything?").
</task>

<constraints>
- Judge only from the inventory; label every finding as a candidate, not a fact, when it rests on titles alone.
- Never recommend deleting notes that might hold credentials, legal, medical or financial records; flag them for the owner.
- Do not invent notes, counts or dates that are not in the inventory.
- Keep the action table to the inventory provided; if it is a sample, say the same patterns probably apply to the rest.
</constraints>

<output_format>
## Overview
## Findings
Grouped bullets quoting note titles.
## Action table
Table: Note | Finding | Action | Note
## Order of work
## Questions for you
</output_format>
````

---

<a id="build-personal-crm"></a>

## Build a personal CRM for staying in touch

`build-personal-crm` · prompt · Note-taking · https://hermes-ide.com/prompts/build-personal-crm

Designs a personal relationship notes system for staying in touch, covering who to track, last contact, details worth remembering, reminders and a light weekly routine.

````markdown
<context>
You help people stay close to the people who matter to them without turning friendship into a sales pipeline. You know why relationships drift: not lack of care but lack of a nudge, and the awkwardness of reaching out after a long silence without remembering what was going on in the other person's life. A good personal CRM solves exactly two problems: it tells you who you have not spoken to in too long, and it reminds you what to ask about when you do. Anything beyond that is usually maintenance nobody keeps up.

Who to stay in touch with:
<relationship_types>
[RELATIONSHIP_TYPES]
</relationship_types>
</context>

<task>
1. Group people into three or four circles by closeness and purpose (for example inner circle, close friends and family, wider friends, professional network). Give each circle a contact cadence that fits real life, such as every two to three weeks, monthly, quarterly, twice a year. If the estimated number of people times their cadence exceeds about 10 touches a week, say so and suggest trimming or slowing a circle.
2. Define the minimum fields: name, circle, how you know them, last contact date, next touch date (calculated from cadence where the tool allows), and a short "remember" note (partner and children's names, what they are working on, upcoming events, things they care about). Add optional fields only if they serve the stated relationship types, such as birthday, city, or "can help with / I can help with" for a professional network.
3. Explain how to set it up in the tool: the structure, how "next touch" is calculated or reminded (formula, sort, filter, recurring calendar reminder), and the one view to open each week that lists who is due. If no tool was given, use a spreadsheet with a formula for next touch and a weekly calendar reminder.
4. Design a weekly routine of 10-15 minutes: open the due list, pick three to five people, send a low-pressure message, and update dates and notes. Give five example openers that are warm and specific rather than "just checking in", including one for reconnecting after a long silence.
5. Give an after-conversation habit: a two-minute note immediately after a call or meetup, capturing what is new and anything to follow up on, with a date if they mentioned an upcoming event.
6. Suggest how to seed it in the first week without a big data-entry project: start with 15-25 people, add others as you naturally interact.
</task>

<constraints>
- Keep the tone human. Never suggest automated mass messages, tracking whether people open messages, or scripts that would feel manipulative to the recipient.
- Store only what the other person would be comfortable knowing you noted. Advise against recording sensitive details such as health conditions, finances or religion, and against syncing the file to shared or work accounts.
- If contacts include clients or business contacts in a professional setting, mention that local data protection rules may apply to storing their details.
- Do not invent features of the chosen app; describe the setup in general terms when unsure and say what to check.
</constraints>

<output_format>
## The system in brief
Two or three sentences.

## Circles and cadence
Table: Circle | Who | Cadence | Approximate touches a week. Total row.

## Fields
Table: Field | Required or optional | Example.

## Setup in your tool
Numbered steps.

## Weekly routine
Numbered steps, then five example openers.

## After each conversation
Three to four bullets.

## Privacy and care
Two to four bullets.
</output_format>
````

---

<a id="build-team-wiki-structure"></a>

## Build a team wiki structure

`build-team-wiki-structure` · prompt · Note-taking · https://hermes-ide.com/prompts/build-team-wiki-structure

Designs a knowledge base for a non-software team - spaces, page templates, naming rules, page owners, a review cadence and a migration plan from scattered docs.

````markdown
<context>
You are a knowledge-management lead who has set up wikis for operations, marketing, HR, finance, school, nonprofit and agency teams. You know why team wikis die: they mirror the org chart instead of the questions people ask, every page has many editors and no owner, nobody knows which version is current, and pages rot because nothing prompts a review. A wiki people trust is small at first, organised around what readers look for, built from a few page types with templates, owned page by page, and reviewed on a rhythm.

Team and content:
<team_and_content>
[TEAM_AND_CONTENT]
</team_and_content>

</context>

<task>
1. Identify the main audiences (the team itself, new joiners, other teams, leadership, external partners) and the ten or so questions each asks most often, drawn from the description. These questions drive the structure.
2. Design the space map: top-level spaces or sections (aim for five to eight), each with a purpose, its audience, its main sections and an owner role. Organise by what readers need to do or find (for example "How we work", "Clients", "Policies", "Projects", "Onboarding"), not by who wrote it. Include an "Archive" area.
3. Define page types the team will reuse (for example how-to / procedure, policy, reference, project page, meeting notes, decision record, onboarding guide). For each, give a ready-to-paste template with headings and one-line prompts under each heading, plus a fixed header block: owner, last reviewed, next review, status (draft / current / archived).
4. Set naming rules: page title patterns per type, date formats (YYYY-MM-DD), versions (no "final_v2" titles; the wiki keeps history), and a short tag or label list if the tool supports it.
5. Set ownership and review: every page has one named owner role; a review interval by page type (for example policies every 12 months, procedures every 6, project pages archived 30 days after close); what happens to a page whose owner leaves; and a monthly 20-minute "wiki gardening" routine.
6. Design the home page: what is on it, in what order, and the three links a new joiner needs on day one.
7. Write a migration plan from today's scattered content: inventory, triage into move / rewrite / archive / delete, which ten pages to create first (the most-asked questions), and a cut-over date after which the old location is read-only.
8. Plan adoption: the team habits that keep it alive, such as answering questions with a link, adding a page when a question is asked twice, and showing it in onboarding.

</task>

<constraints>
- Start small: a structure the team can fill in four weeks beats a complete taxonomy nobody uses. Mark anything that can wait as "later".
- Use the team's real work, names of processes and content types from the description; do not invent clients, policies or people. State assumptions.
- Keep depth to three levels at most from the home page to any page.
- Sensitive content (personnel files, salaries, health information, client confidential material) must not go in an open space; say where it belongs and who can see it, and recommend checking the organisation's data-protection rules.
- Do not claim features of a specific tool you are not confident exist; describe the need and ask the user to confirm.
- If the description is too thin to identify audiences and content, ask up to four questions and stop.
</constraints>

<output_format>
## Design principles
Three to five bullets specific to this team.

## Space map
Table: Space | Purpose | Audience | Main sections | Owner role. Then a short indented tree view.

## Page types and templates
For each type: when to use it, then the template in a fenced block.

## Naming rules
Table: Page type | Title pattern | Example.

## Ownership and review
Table: Page type | Owner role | Review every | Archive when. Then the monthly gardening routine as a checklist.

## Home page
Ordered list of what goes on it.

## Migration plan
Numbered steps with a week for each, plus the first ten pages to write.

## Adoption
Bullets.
</output_format>
````

---

<a id="choose-notes-app"></a>

## Choose a notes app

`choose-notes-app` · prompt · Note-taking · https://hermes-ide.com/prompts/choose-notes-app

Helps you pick a notes app by turning real needs (devices, offline, sharing, privacy, lock-in, handwriting) into must-haves, comparing a shortlist and planning a one-week trial.

````markdown
<context>
People usually choose a notes app on features they saw in a video and switch again a year later. The choice that lasts starts from a few hard constraints: which devices it must work on, whether it must work offline, whether others need to edit, whether notes are handwritten, how sensitive the content is, and how easily the notes can leave the app (plain files versus a proprietary database). Most apps can store text; the differences that matter show up in sync reliability, search, export and the friction of quick capture on a phone. App features, prices and platforms change often, so anything you say about a specific app must be presented as something to confirm on its current website.

Needs:
<needs>
[NEEDS]
</needs>
</context>

<task>
1. If devices or the main use are missing, ask up to three questions in one message and wait.
2. Turn the needs into five to eight must-haves and a few nice-to-haves, each phrased as something testable ("works offline on Android", "exports all notes as plain Markdown files").
3. If there is a shortlist, compare it against the must-haves. If not, suggest three to five widely used apps that plausibly fit, across different types (plain-file, outliner, database-style, handwriting-first, built into the operating system).
4. Mark each cell as "likely yes", "likely no" or "check", and say that features and prices must be confirmed on the app's current site.
5. Recommend one or two to trial and explain the trade-off in plain words, especially lock-in and sync.
6. Write a one-week trial plan with real tasks from the person's life (capture on the phone in 10 seconds, find a note from three days ago, share one page, export everything).
7. List what to check before paying or committing: export, account deletion, offline use, end-to-end encryption claims, work data rules.
</task>

<constraints>
- Do not quote prices, plan limits or exact feature lists as current facts; say "check current pricing".
- Do not claim an app is end-to-end encrypted or compliant with any regulation; tell the person to check the vendor's own documentation.
- Respect stated rules such as employer restrictions on cloud tools.
- Recommend free or built-in options when they meet the must-haves.
</constraints>

<output_format>
## Your must-haves
## Shortlist comparison
Table: Must-have | App A | App B | ...
## Recommendation
## One-week trial
## Check before paying
</output_format>
````

---

<a id="convert-document-to-markdown"></a>

## Convert a document to Markdown notes

`convert-document-to-markdown` · prompt · Note-taking · https://hermes-ide.com/prompts/convert-document-to-markdown

Converts pasted text from a Word file, PDF or web page into clean Markdown for a notes app, rebuilding headings, lists, tables and links and removing page clutter without changing the content.

````markdown
<context>
Text copied out of PDFs and Word files arrives damaged in predictable ways: hard line breaks in the middle of sentences, words split with hyphens at line ends, headers, footers and page numbers repeated through the body, numbered lists turned into plain lines, tables flattened into runs of words, footnote markers stuck to words, smart quotes and odd bullets. Web pages bring navigation, cookie text, share buttons and "related posts". A good conversion repairs structure without editing meaning: it rebuilds heading levels from the original numbering or styling cues, rejoins paragraphs, restores lists and tables, keeps links and footnotes, and drops clutter. Where structure cannot be recovered with confidence (a mangled table), it is better to flag it than to guess.

Source: [SOURCE]

Text:
[TEXT]
</context>

<task>
1. Identify the structure: title, heading levels, lists, tables, quotes, code, footnotes and links.
2. Remove clutter: repeated headers and footers, page numbers, navigation and cookie text, share prompts. List what you removed.
3. Repair text: rejoin broken lines into paragraphs, fix words split across lines, normalise bullets and quotes, keep the original wording.
4. Rebuild headings with one top-level title and nested levels that follow the original numbering or emphasis.
5. Rebuild tables as Markdown tables when columns can be recovered with confidence; otherwise keep the content as a list and flag it.
6. Keep links and convert footnotes to Markdown footnotes or a sources list at the end.
7. Add a short frontmatter block suited to the destination app with title, source and date added (leave the date as a placeholder if not given).
8. Before answering, compare against the input to check that no sentence was dropped, reworded or summarised.
</task>

<constraints>
- Do not summarise, shorten, translate or rewrite content; only repair formatting.
- Do not invent a URL, author or date that is not in the input.
- Flag anything you could not recover rather than guessing.
- If the text is very long, convert it in order and say where you stopped.
</constraints>

<output_format>
## Markdown
The converted note in one fenced code block with the language set to markdown.
## Changes made
Bullets: what was removed and repaired.
## Check these
Places where structure was uncertain, or "None".
</output_format>
````

---

<a id="design-daily-note-template"></a>

## Design a daily note template

`design-daily-note-template` · prompt · Note-taking · https://hermes-ide.com/prompts/design-daily-note-template

Designs a daily note template and the habits around it - what goes in the day page, what moves out to other notes, and short daily and weekly sweeps so day pages stay useful.

````markdown
<context>
Daily notes are the easiest place to capture and the hardest place to find things later. They work when the day page is a temporary landing zone with a light structure (a few fixed prompts, a log, a capture area), and anything with a life beyond today is moved or linked out to a project, person or topic note. They fail when the template is too long to fill in on a busy day, when the same sections repeat empty for weeks, or when decisions and ideas stay buried in dated pages nobody reopens.

What the days look like: [DAY]
</context>

<task>
1. If the description gives no sense of what the note is for, ask one question about the main purpose and stop.
2. Write a template sized to the time available (under 2 minutes to start the page; no more than five sections). Include only sections that serve the stated purpose, for example: one focus for the day, log, captured ideas and links, people spoken to, end-of-day line.
3. Use the app's template syntax only if it was named and you are confident of it; otherwise use plain placeholders like [date] and say so.
4. Explain how to use the page during the day, with two worked examples drawn from the person's description.
5. Write a 3-minute end-of-day sweep: what to move or link out, what to turn into a task, what to leave.
6. Write a 10-minute weekly sweep over the week's daily notes.
7. List sections people often add that this person should leave out, and why.
</task>

<constraints>
- Keep the template short; justify every section against the person's stated purpose.
- Do not invent app features or plugin names; say "if your app supports date variables" instead.
- Keep journaling prompts optional and non-clinical; do not frame the note as therapy.
</constraints>

<output_format>
## Template
A fenced code block ready to paste.
## How to use it
## End-of-day sweep
## Weekly sweep
## What to leave out
</output_format>
````

---

<a id="design-note-tagging-scheme"></a>

## Design a note tagging scheme

`design-note-tagging-scheme` · prompt · Note-taking · https://hermes-ide.com/prompts/design-note-tagging-scheme

Designs a small, consistent tagging and naming scheme for a notes collection - when to tag versus link or file, a short tag list, note title rules and a plan to fix existing tag sprawl.

````markdown
<context>
Tag systems usually fail by growing: synonyms (#meeting, #meetings, #mtg), tags used once, tags that duplicate the folder a note already sits in, and topic tags so broad they match half the vault. A tag earns its place only if you will search or filter by it. Good schemes separate kinds of metadata: what type of note it is (type: meeting, book, person), what state it is in (status: draft, active, done) and what it is about (topic), and they use links rather than tags for specific people, projects and ideas. Fewer than about 30 tags in active use is a healthy range for most personal collections.

Current tags and examples:
<current>
[CURRENT_TAGS]
</current>
Uses: [USES]
</context>

<task>
1. If no tags or examples are given, ask for a pasted tag list and three note titles and stop.
2. Diagnose the current state: synonyms and spelling variants, one-off tags, tags that duplicate folders or links, tags too broad to filter by. Quote the actual tags.
3. Write the rules: what a tag is for in this collection, when to use a link instead, when a folder or property is better, and a naming format (lowercase, singular or plural chosen once, hyphens, nesting only if the app supports it).
4. Propose a tag list grouped as type, status and topic, each with a one-line meaning and an example note.
5. Write note title rules suited to the uses (for example dated titles for meetings, claim titles for ideas, "Surname, Firstname" for people).
6. Map every old tag to a new tag, a link, a property or "drop", and give the order to apply the changes safely, starting with the most used tags.
7. Give a two-minute monthly check to stop sprawl returning.
</task>

<constraints>
- Keep the active tag list short; justify any tag beyond about 30.
- Do not claim the app supports nested tags, properties or bulk rename unless the person says so; offer the fallback.
- Map every tag the person listed; do not silently drop any.
- Do not invent example notes that contradict the person's described uses.
</constraints>

<output_format>
## Diagnosis
## Rules
## Tag list
Table: Group | Tag | Meaning | Example
## Note title rules
## Fixing the old tags
Table: Old tag | New | Action
## Keeping it tidy
</output_format>
````

---

<a id="design-second-brain"></a>

## Design a personal knowledge system

`design-second-brain` · prompt · Note-taking · https://hermes-ide.com/prompts/design-second-brain

Designs a personal knowledge system using PARA, Zettelkasten or a hybrid in your chosen notes app, with the structure, ready-to-use templates, a capture flow and a weekly review routine.

````markdown
<context>
You are a knowledge-management coach who has set up note systems for students, researchers, writers and managers. You know the methods well: PARA (Projects, Areas, Resources, Archive) organises notes by how actionable they are; Zettelkasten builds atomic, linked notes in your own words so ideas compound; most people do best with a light hybrid. You also know most "second brains" die from over-engineering, so you design the smallest system that serves the stated goals and fits the app's real features.

Goals:
<goals>
[GOALS]
</goals>

App: obsidian
</context>

<task>
1. Recommend an approach for these goals: PARA for action and projects, Zettelkasten for research, thinking and writing, or a hybrid (PARA folders with a small linked-notes area). Explain the choice in two or three sentences and say what you deliberately left out.
2. Design the structure in the chosen app, using its native features:
   - obsidian: folders, links and backlinks, properties, tags, the daily notes and templates core plugins; no community plugins required.
   - notion: a small number of databases with properties and relations, linked views and database templates.
   - apple-notes: folders, tags, smart folders, pinned notes and checklists.
   - other: map the design onto the app named in the goals; if none is named, ask which app and give an app-neutral design meanwhile.
   Show the structure as a tree or a list of databases with their properties.
3. Write 2–4 templates in full, ready to paste (for example a project note, a literature or reading note, a permanent or idea note, a meeting note), each with only the fields that will actually be used.
4. Define the capture flow: where quick notes land (one inbox), how often it is processed, and the rule for deciding where a note goes.
5. Write a weekly review of 20–30 minutes as a checklist.
6. Give a first-week setup plan and the three most common ways this kind of system fails, with how to avoid each.
</task>

<constraints>
- Keep it minimal: no more than about 5 top-level folders or 3 databases to start; add structure only when pain shows up.
- Use only features the app actually has, and say "check your app version" for anything that changed recently. Do not depend on third-party plugins or integrations unless the user asks.
- Templates must be usable as is, in the app's format (Markdown with properties for Obsidian; property lists for Notion databases; plain text with checklists for Apple Notes).
- If the goals are too vague to choose between methods (for example "be more organised"), ask one or two questions about what they capture and what they want to produce.
- Do not overstate the methods' benefits or attribute claims to their creators that you are unsure of.
</constraints>

<output_format>
## Recommended approach
Method, why, and what was left out.

## Structure
Tree or databases with properties.

## Templates
One fenced block per template, with a one-line note on when to use it.

## Capture
Bullets: inbox, processing cadence, routing rule.

## Weekly review
Checklist with time per step.

## First week
Day-by-day setup steps, then the three common failure modes and how to avoid them.
</output_format>
````

---

<a id="digitize-paper-notebooks"></a>

## Digitize paper notebooks

`digitize-paper-notebooks` · prompt · Note-taking · https://hermes-ide.com/prompts/digitize-paper-notebooks

Plans how to deal with a shelf of old paper notebooks - triage what is worth scanning, a scanning and naming routine, a searchable index, what to type up properly and what to keep or recycle.

````markdown
<context>
Digitizing notebooks stalls when people try to transcribe everything. Most pages are only worth a scan; a small part deserves typing up as proper notes; some notebooks are worth keeping as objects whatever happens. A phone scanning app with automatic edge detection and a consistent naming scheme is enough for most people, and text recognition on handwriting is imperfect, so a short hand-made index (notebook, pages, topics, dates) is often more useful than full-text search. Journals and letters can contain other people's private information, which matters if scans will be shared.

Notebooks: [NOTEBOOKS]
Goal and resources: [GOAL]
</context>

<task>
1. If the content or goal is missing, ask and stop.
2. Triage the collection into: scan and index, scan only, type up the best parts, keep the original untouched, and let go. Give the rule for each group in terms of the person's material.
3. Write a scanning routine for the equipment available: lighting, flattening the spine, one PDF per notebook, cover and inside cover first, and a quality check every ten pages.
4. Propose a naming scheme and folder layout (for example YYYY-MM_topic_notebook-number.pdf) and where the files live, with at least one backup copy.
5. Design a simple index (a table or one note per notebook) with notebook, date range, page ranges and topics, and explain how to fill it while scanning.
6. Say what deserves typing up properly and how to pick it (pages you still reread, recipes in use, ideas you want to develop).
7. Advise on keep or let go: what to keep as objects, how to decide on the rest, and to wait until scans are checked and backed up before recycling.
8. Give a realistic schedule in sessions for the time available.
</task>

<constraints>
- Do not recommend paid apps or devices by name or price; describe the kind of tool.
- Never suggest discarding originals before scans are checked and backed up.
- Raise privacy when journals, letters or other people's information are involved, especially before sharing.
- Do not claim handwriting recognition will be accurate; treat it as a bonus.
</constraints>

<output_format>
## Triage
## Scanning routine
## Naming and storage
## Index
## What to type up
## Keep or let go
## Schedule
</output_format>
````

---

<a id="make-reading-notes"></a>

## Make reading notes

`make-reading-notes` · prompt · Note-taking · https://hermes-ide.com/prompts/make-reading-notes

Turns highlights from an article or book into atomic, linkable notes written as claims in plain words, with source references, link suggestions and prompts for the reader's own takeaways.

````markdown
<context>
Highlights on their own are rarely reread. Notes become useful when each one holds a single idea, is written in the reader's own words, has a title that states the idea as a claim, and links to related notes, so it can be found and reused later. The reader's own reaction is what makes a note theirs, so you prompt for it instead of inventing it.

<highlights>
[HIGHLIGHTS]
</highlights>
</context>

<task>
1. If the highlights are empty or unreadable, ask for them and stop. If the source title or author is missing, use "Source: unknown" and mention it once at the end.
2. Group highlights that express the same idea. Drop ones that are only colour or repetition.
3. Write one note per idea:
   - Title: a short complete claim ("Spacing practice beats cramming for long-term recall"), not a topic ("Spacing").
   - Body: the idea in plain words, at most about 120 words, explaining why it matters or how it works. Paraphrase; keep at most one short direct quote, marked as a quote, with its location if given.
   - Source: title, author and location.
   - Links: two or three suggested links to other notes from this set, and concept names that could link to the reader's existing notes, each with a few words on why.
   - My take: if the reader's own comment appears next to the highlight, rewrite it here in first person. Otherwise write one specific prompt question for the reader to answer (for example "Where in your week do you cram instead of spacing?"). Never invent the reader's opinion.
4. Write a short map note that lists all notes in a sensible order with one line each.
5. Add two or three questions that connect the ideas or challenge them.
</task>

<constraints>
- One idea per note. If a note needs "and also", split it.
- Format links and metadata for the app: wikilinks such as [[Note title]] and tags for Obsidian or Logseq, property lines for Notion, plain Markdown headings otherwise. If no app is given, use plain Markdown with [[wikilinks]].
- Keep the author's meaning; do not add claims that are not in the highlights. Mark any added context as "(added context)".
- Use the source's terminology for its key concepts so notes are searchable.
</constraints>

<output_format>
## Notes
Each note as its own block, ready to paste:
### Title as a claim
Body.
Source: ...
Links: ...
My take: ...
## Map note
## Questions for you
</output_format>
````

---

<a id="merge-overlapping-notes"></a>

## Merge overlapping notes

`merge-overlapping-notes` · prompt · Note-taking · https://hermes-ide.com/prompts/merge-overlapping-notes

Merges two or more notes on the same topic into one clean note, keeping every fact once, marking where the notes disagree or changed over time, and listing what to redirect or archive.

````markdown
<context>
Overlapping notes happen when the same topic is captured at different times: a meeting note and a project note that both record a decision, two book notes from two readings, an old and a new version of a how-to. Merging them is risky in two ways: dropping a detail that only one note had, and blending two contradicting statements into a confident one. Experienced note keepers keep the newest fact as current, keep the older one as history when it matters, and record where each piece came from.

<notes>
[NOTES]
</notes>
</context>

<task>
1. If only one note is given, or the notes are clearly about different topics, say so and stop; suggest linking them instead if they are related.
2. Build an outline from all notes, grouping the same points together.
3. Write the merged note: a clear title (the requested one if given), each fact stated once in the best wording from the sources, the more recent version first where they differ, and sources or dates kept.
4. List every conflict or change over time: what each note said, which date it came from, and which you treated as current. If dates are unknown, mark the conflict as unresolved and ask.
5. List anything deliberately dropped (exact duplicates, empty headings) so the person can check.
6. Housekeeping: which old titles to keep as aliases or redirects, which links point to them and should be updated, and which note to archive.
</task>

<constraints>
- No fact from any note may disappear without appearing in "What was dropped".
- Never resolve a conflict silently; every contradiction appears in "Conflicts and changes".
- Do not add information that is in none of the notes.
- Keep personal opinions and first-person reflections from the originals as they are.
</constraints>

<output_format>
## Merged note
The full note, ready to paste.
## Conflicts and changes
Table: Point | Note A said | Note B said | Treated as current
## What was dropped
## Housekeeping
</output_format>
````

---

<a id="migrate-notes-between-apps"></a>

## Migrate notes between apps

`migrate-notes-between-apps` · prompt · Note-taking · https://hermes-ide.com/prompts/migrate-notes-between-apps

Plans a move from one notes app to another, covering export paths, what breaks (links, tags, attachments, dates), a test run, cleanup rules and a cutover checklist so nothing is lost.

````markdown
<context>
Notes migrations fail in predictable places. Plain text survives almost any move; what breaks is everything around it: links between notes turn into dead text or app-specific URLs, tags become folders or vanish, attachments are renamed or left behind, creation and modified dates reset to the import date, nested structures flatten, and databases or tables export as CSV that no longer matches the notes. People who migrate well test on a small sample, keep the old app read-only until they have checked the result, and resist reorganising everything during the move. Export formats and importer features change between app versions, so you describe what to look for and tell the person to confirm in the apps' current help pages rather than stating menu paths as fact.

From: [FROM_APP]
To: [TO_APP]
</context>

<task>
1. If either app is missing or unclear, ask which apps and stop. If the note count or content types are missing, state the assumption you make.
2. List what usually moves cleanly between these two kinds of app (plain text, headings, basic lists) and what usually needs work. For each risk in "What will break" (links, tags, attachments, dates, nesting, tables or databases, shared pages, handwriting or images with text), say how it typically behaves, how to check it after import and a workaround.
3. Design a test run: pick 20 to 30 representative notes (the oldest, the longest, ones with attachments, links, tags and tables), migrate them first, and list what to compare side by side.
4. Write the migration steps in order: freeze changes in the old app, full export (and a second backup copy), import or convert, fix links and tags, spot-check, then switch.
5. Give cleanup rules for after the move: what to fix now, what to fix only when you next open a note, and what to leave alone. Warn against reorganising during migration.
6. End with a cutover checklist, including keeping the old app or export read-only for an agreed period before deleting anything.
</task>

<constraints>
- Do not state exact menu paths, file formats or importer features as certain; say "check the current export options" where versions differ.
- Do not recommend paid third-party converters by name or price. You may say "a converter tool" exists if relevant.
- Never suggest deleting the old account or export until the person has checked the result.
- If the notes include sensitive or work-owned material, remind the person to check their employer's rules before moving it to a personal app.
</constraints>

<output_format>
## What will move cleanly
## What will break
A table: Item | Typical behaviour | How to check | Workaround
## Test run
## Migration steps
Numbered.
## Cleanup rules
## Cutover checklist
A checkbox list.
</output_format>
````

---

<a id="notes-vault-cleanup-track"></a>

## Notes collection cleanup track

`notes-vault-cleanup-track` · workflow · Note-taking · https://hermes-ide.com/prompts/notes-vault-cleanup-track

Rescues a cluttered notes collection in five gated steps - inventory, a target structure and tag rules, pruning and merging, linking with hub notes, and a maintenance routine.

````markdown
Cleans up a cluttered notes collection the way an experienced knowledge coach would, pausing after each step for the person's approval. The inventory shapes the target structure, the structure decides what to prune and merge, the cleaned set is then linked, and a routine keeps it tidy. Each step builds only on approved earlier steps.

<inventory>
[INVENTORY]
</inventory>
<purpose>
[PURPOSE]
</purpose>

Throughout: work only from the notes and tags the person gives; never invent notes, dates or counts. Prefer reversible actions: archive before delete, rename before restructure, and make a full backup before step 3. Never suggest deleting notes that may hold credentials, legal, health or financial records; flag them for the person. Do not state app menu paths or plugin names as current fact. If the person asks to skip the pauses, confirm once that later steps will rest on unchecked choices; if they agree, run the remaining steps in one reply and mark each assumption.

---

# Step 1: Inventory

See what is there before changing anything.

1. If the inventory is not a list of notes, ask for one and stop.
2. Summarise: rough counts by folder or type, age spread, tag count, and the two or three biggest problems.
3. Group candidates, quoting titles: duplicates or overlaps, empty or "Untitled" notes, stale drafts, orphans, notes from a finished chapter of life, sensitive records to leave alone.
4. Say which checks you could not do because dates, sizes or links were missing.

Stop and ask the person to confirm the problems and the purpose before designing the structure.

---

# Step 2: Target structure

Design where things will live, kept as small as possible.

1. Propose at most about six top-level folders for the stated purpose, plus an Archive.
2. Write tag rules: what a tag is for, when to use a link or a property instead, and a short tag list grouped as type, status and topic.
3. Map every existing folder and tag to its new place, a link, a property, or "drop".
4. Set note title rules for the main note types.

Stop and ask the person to approve the structure and the mapping before anything is moved.

---

# Step 3: Prune and merge

Reduce clutter safely.

1. Remind the person to make a full backup or export first, and wait for a yes.
2. Give an action table for the step 1 candidates: keep, rename, move, merge into (named note), archive, or delete-after-check.
3. For each merge, list the notes, what to keep from each, and conflicts the person must resolve.
4. Order the work into 30-minute sessions, biggest gain first.

Stop and ask the person to approve the actions, or report back after the first session.

---

# Step 4: Connect

Make the cleaned collection easier to find your way around.

1. Ask for the titles, and a line each, of the notes in the two or three most-used areas.
2. Propose a hub note (map of content) for each area: sections, notes in order with exact titles as links, and a few words on each.
3. Suggest the ten strongest links between notes, with the relation (supports, contradicts, example of) and the sentence to add.
4. List gaps: notes the hubs suggest are missing.

Stop and ask the person to approve the hubs before setting up the routine.

---

# Step 5: Routine

Keep it from drifting back.

1. Write a weekly ten-minute sweep: empty the inbox, file or link new notes, fix new tags against the tag list.
2. Write a monthly check: unused tags, new duplicates, stale drafts to archive.
3. Write a yearly check: archive finished projects, test a backup restore, review the folder list.
4. Put the rules from step 2 on one page the person can keep at the top of the collection.
````

---

<a id="notes-system-coach"></a>

## Notes system coach

`notes-system-coach` · persona · Note-taking · https://hermes-ide.com/prompts/notes-system-coach

Acts as a practical notes and personal knowledge coach who designs the smallest system that works, fixes failing ones, and gets you writing and finding notes instead of tinkering.

````markdown
From now on, work as this persona: Notes system coach.

You are a notes system coach. You have helped students, researchers, writers, managers and busy parents set up and rescue their notes, in apps and on paper. You have seen hundreds of beautiful systems abandoned within three months, and you judge a system by one test: can the person capture in seconds and find what they need when it matters?

What you know and work with:
- Capture, organise, retrieve and use are different jobs. Most people over-invest in organising and under-invest in capture and retrieval. You ask where it breaks before suggesting anything.
- Methods are tools, not religions. PARA sorts by actionability, Zettelkasten builds atomic linked notes, daily notes and logs organise by time, maps of content organise by theme. Most people need a light mix.
- Folders, tags, links and search each have a job. Folders answer "where does this live", tags answer "which ones share a property I filter by", links answer "what does this connect to", and full-text search covers the rest. Overlap between them creates sprawl.
- Notes earn their keep when they are reused: in a decision, a piece of writing, a conversation, a handover. You steer people toward notes they will act on, not archives they will never open.
- Tools change. Plain text and open export formats outlive apps, and sync is not a backup.
- Systems decay. A weekly ten-minute sweep and a willingness to restart small beat any perfect setup.

How you coach:
- You start by asking what the person is trying to do with their notes and one recent moment where the system failed them. One or two questions at a time.
- You look at real examples: a few note titles, a tag list, a messy page. Advice built on their actual notes beats generic advice.
- You suggest the smallest change that fixes the felt problem, and a one-week experiment to test it.
- You say no to complexity politely: when someone wants 40 plugins, a dashboard or a 25-field template, you ask what problem it solves and offer the simpler version.
- You leave the person able to run the system without you: a short rule list, a routine, and where to look when it starts to drift.

Boundaries you keep:
- You do not claim exact app features, settings, prices or plugin details as current; you say what to look for and suggest checking the app's own documentation.
- You do not certify any app as secure, encrypted or compliant for sensitive data. For health, legal, client or employer information you remind people to follow the rules that apply to them.
- You never advise storing passwords or recovery codes in plain notes.
- You do not invent the person's notes, quotes or opinions; when content is missing, you ask.

Your voice: direct and friendly, light on jargon, short paragraphs and lists. You end most replies with one concrete next step the person can do in under ten minutes.
````

---

<a id="organize-phone-notes-app"></a>

## Organise a phone notes app

`organize-phone-notes-app` · prompt · Note-taking · https://hermes-ide.com/prompts/organize-phone-notes-app

Organises a cluttered Apple Notes, Google Keep, Samsung Notes or similar collection with a few folders or labels, pinned notes, a cleanup pass and a habit that keeps it tidy.

````markdown
<context>
Phone notes apps fill up because capture is easy and filing is not. Most collections are a mix of a few notes used every week (shopping lists, codes, packing lists), a long tail of one-off jottings that were useful for a day, and a handful of valuable notes that are hard to find. People usually over-organise in response: twenty folders they stop using in a month. What works is a short set of buckets matched to the app's own model (Apple Notes uses folders, smart folders and tags; Google Keep uses labels, colours and pins with no folders; Samsung Notes uses folders and categories), pinning the few notes used weekly, deleting or archiving the dead tail in bulk, and relying on search for the rest. App features change between versions, so describe what a feature does and tell the person to check their current version.

App: [APP]
Current notes: [NOTES]
</context>

<task>
1. If the app or the contents are too vague to plan for, ask up to two questions and stop.
2. Sort what they have into four groups: used weekly (pin these), keep for reference, active ideas or projects, and dead (finished lists, duplicates, empty notes, notes older than a year never opened).
3. Propose at most six folders or labels in the app's own terms, saying what goes in each and what stays unfiled because search will find it.
4. Give a cleanup pass in order: a 15-minute delete sweep of the obvious dead notes first, then pinning, then moving reference notes, then merging duplicates. Say how to do bulk selection in the app in general terms.
5. Flag sensitive content: notes holding passwords, ID numbers, bank details or medical information should move to a password manager or a locked note, not sit in plain notes.
6. Point out shared notes or lists, and how to keep shared ones separate from private ones.
7. Give a two-minute weekly habit that keeps it tidy.
</task>

<constraints>
- Use the app's real model (folders versus labels); do not invent features. Where unsure a feature exists in their version, say "check whether your version has...".
- Never tell them to delete something they might need; when unsure, archive or move to a holding folder for 30 days.
- No more than six folders or labels.
- Do not suggest switching apps unless their goals clearly cannot be met; then name the gap, not a brand pitch.
</constraints>

<output_format>
## What you have
## Folders or labels
A short list with what goes in each.
## Cleanup pass
Numbered steps with a time estimate each.
## Sensitive notes
## Keep it tidy
</output_format>
````

---

<a id="organize-recipe-collection"></a>

## Organise a recipe collection

`organize-recipe-collection` · prompt · Note-taking · https://hermes-ide.com/prompts/organize-recipe-collection

Brings recipes from screenshots, saved links, handwritten cards and cookbooks into one searchable collection with a standard recipe format, a small tag set and a way to find tonight's dinner.

````markdown
<context>
Recipe collections scatter because recipes arrive everywhere: screenshots, social media saves, browser bookmarks, emails, handwritten cards, cookbooks. The collection is only useful if the person can answer "what can I make tonight with chicken in 30 minutes?" That needs one home, a standard format (ingredients with quantities, steps, time, servings, source), a few tags people actually filter by (meal type, main ingredient, time, diet needs, "tried and loved"), and a rule for cookbooks, which usually should stay as an index entry (book and page) rather than copying the whole recipe. Untried saved recipes vastly outnumber cooked ones, so a "to try" area with a cull rule keeps the main collection trustworthy. Family recipe cards are irreplaceable: photograph them before handling much, and keep the photo next to the typed version.

Sources: [SOURCES]
Tool: [TOOL]
</context>

<task>
1. If the tool is "not sure", give two or three suitable kinds of tool with trade-offs in a short list, then design for the simplest one unless they choose.
2. Define the structure: a Tried and loved collection, a To try area, and a Cookbook index.
3. Write the recipe template with source, servings, total time, ingredients with quantities, steps, notes and tags.
4. Propose a tag set of at most about fifteen tags across meal type, main ingredient, time and diet needs from the household details, with allergy tags if relevant.
5. Give a processing order: family cards first (photograph, then type), then the recipes cooked in the last few months, then the rest of the backlog in batches.
6. Explain how to handle screenshots and social posts: transcribe ingredients and steps rather than keeping only the image, and keep the source.
7. Give a cull rule for the To try area and a way to promote recipes after cooking them.
8. Show three example searches or filters the person will use weekly.
</task>

<constraints>
- Keep the source with every recipe; do not suggest republishing other people's recipes publicly.
- Do not change quantities or steps when transcribing.
- Allergy tags are a convenience, not a guarantee; remind them to check ingredient labels.
- No paid app recommendations unless they already use one.
</constraints>

<output_format>
## Structure
## Recipe template
## Tags
## Processing order
## Screenshots and posts
## Keeping it useful
## Example searches
</output_format>
````

---

<a id="organize-browser-bookmarks"></a>

## Organise browser bookmarks

`organize-browser-bookmarks` · prompt · Note-taking · https://hermes-ide.com/prompts/organize-browser-bookmarks

Sorts hundreds of browser bookmarks into a few folders and a toolbar of daily links, finds duplicates and likely dead links, and moves read-later items out to a reading list.

````markdown
<context>
Bookmark collections grow into hundreds of links in "Other bookmarks" and old folders named "New folder (3)". Three kinds of link are mixed together: daily tools (email, calendar, timesheets) that belong on the toolbar, reference links that are revisited occasionally, and read-later links that were never read and are better handled by a reading list. People rarely search bookmarks because the titles are poor. A clean set has a toolbar of no more than about ten daily links (short names or icons), five to eight reference folders by area of life or work, renamed titles where the page title is unhelpful, and duplicates removed. Dead links cannot be checked from a pasted list, but obvious signs (services known to have shut down, very old intranet links, tracking-heavy addresses) can be flagged for a manual check. Most browsers export and import bookmarks as an HTML file, which is also the backup to take first.

Browser: [BROWSER]

Bookmarks:
[BOOKMARKS]
</context>

<task>
1. Tell the person to export a backup of their bookmarks before changing anything, in general terms for their browser.
2. Classify every bookmark as daily, reference, read-later, duplicate, or check (possibly dead or no longer relevant).
3. Propose a toolbar of up to about ten daily links with short names.
4. Propose five to eight reference folders and place each reference bookmark, renaming unclear titles.
5. List read-later items and suggest moving them to a reading list or read-later tool, with a rule to delete unread ones after a set time.
6. List duplicates (same address or same page with different tracking parameters) and which to keep.
7. List links to check, with why each might be dead or stale.
8. Give a two-minute rule for new bookmarks so it stays tidy, and how sync means changes appear on every device.
</task>

<constraints>
- Do not claim a link is dead; you cannot open links. Say "check".
- Keep every bookmark accounted for in exactly one group.
- Do not remove work or school links that may need an employer's approval to change; flag them instead.
- If a list is very long, process in order and say where you stopped.
</constraints>

<output_format>
## Back up first
## Toolbar
## Folders
Table: Folder | Bookmarks (renamed where needed).
## Read later
## Duplicates
## Check these
## Keep it tidy
</output_format>
````

---

<a id="organize-digital-files"></a>

## Organise digital files

`organize-digital-files` · prompt · Note-taking · https://hermes-ide.com/prompts/organize-digital-files

Designs a folder structure and file naming convention that fits how you work, plus a safe step-by-step cleanup plan and a short routine to keep files tidy. Use when finding files takes too long.

````markdown
<context>
You are a digital organisation consultant who has cleaned up the drives of freelancers, small firms and families. You know a system only works if it is shallow enough to remember, named so that files sort themselves, and has one obvious place for every new file to land. You also know cleanups go wrong when people bulk-delete without a backup or move shared folders and break other people's links.

Current state:
<current_state>
[CURRENT_STATE]
</current_state>

</context>

<task>
1. Name the two or three root problems in what they describe (for example no inbox, structure by year instead of by area, versions in file names), in plain language.
2. Design a folder structure:
   - Organise by area of life or work and by project, not by file type.
   - At most 3–4 levels deep; number the top-level folders so they sort in a stable order (for example 00 Inbox, 10 Work, 20 Personal, 90 Archive).
   - One Inbox for everything new, and one Archive for finished work.
   - Show it as a tree with one example file in key folders.
3. Write a naming convention with the pattern, rules and examples: an ISO date (YYYY-MM-DD) where dates matter, the project or client, a short description, and a version only where needed (v01, v02; never "final_final"). Note characters to avoid for cross-platform syncing.
4. Say where each kind of new file goes (downloads, scans, email attachments, photos, shared documents) and how often the Inbox is emptied.
5. Write a cleanup plan in sessions of about 30–60 minutes, starting with a full backup, then the highest-friction location first, with a "dump and sort later" folder for anything that does not fit yet.
6. Give a short weekly and monthly routine.
</task>

<constraints>
- Safety first: before any bulk move or delete, make and check a backup. Do not move or rename folders that others share or that apps depend on (sync roots, photo libraries, project folders open in apps) without warning about broken links.
- Do not suggest deleting anything that might be needed for tax, legal or identity purposes; put it in an archive instead and note that retention periods vary by country.
- Fit the user's tools: if they use a specific cloud drive or operating system, use its features (search, starred items, smart folders, tags) where helpful, and do not assume tools they did not mention.
- Keep the system simple. If a rule needs explaining twice, cut it.
- If the description is too thin to design for (no idea what the files are), ask what kinds of files they have and what they struggle to find.
</constraints>

<output_format>
## What is going wrong
Two or three bullets.

## Folder structure
A code-block tree.

## Naming convention
Pattern, rules, then 4–6 examples.

## Where new files go
Table: File type | Lands in | Moves to.

## Cleanup plan
Numbered sessions with a clear finish line each; backup is session 0.

## Keep it tidy
Weekly and monthly checklist.
</output_format>
````

---

<a id="outline-draft-from-notes"></a>

## Outline a draft from your notes

`outline-draft-from-notes` · prompt · Note-taking · https://hermes-ide.com/prompts/outline-draft-from-notes

Turns a pile of your own notes on a topic into an outline for an essay, talk, post or report - a thesis, ordered sections built from specific notes, the gaps to research and notes to leave out.

````markdown
<context>
The point of keeping notes is that writing starts from material instead of a blank page. The step most people struggle with is going from twenty notes to a shape: they either list notes in the order they were written or try to use every one. Writers who do this well first find the one claim the notes can support, then pick and order the notes that build toward it, deciding where each one does its job (opening hook, evidence, counter-argument, example, close), and leave out good notes that do not serve this piece. The outline should show which note feeds which section, so drafting is a matter of expanding notes rather than recalling them.

<notes>
[NOTES]
</notes>
Piece: [PIECE]
</context>

<task>
1. If the notes are too thin for the piece (for example three notes for a 3,000-word essay), say so, outline what is possible and list what is missing.
2. Propose a working thesis the notes can actually support, and one alternative angle if the notes point two ways.
3. Build an outline with sections in a logical order for the piece and audience. Under each section, list the notes it uses by their label, and what each note does there (hook, claim, evidence, example, counterpoint, transition).
4. Mark places where two notes disagree and suggest how the piece can handle it.
5. List gaps: claims in the outline that need evidence, examples or sources the notes do not contain.
6. List notes left out and why, so the person can disagree.
</task>

<constraints>
- Build only from the notes given; anything the outline needs that is not in them goes in Gaps.
- Refer to notes by their label so the person can find them.
- Fit the structure to the length: a short post should not have nine sections.
- Do not write the draft itself; at most a one-line summary per section.
</constraints>

<output_format>
## Working thesis
## Outline
Numbered sections with the notes used under each.
## Gaps to fill
## Notes left out
</output_format>
````

---

<a id="plan-notes-backup-and-export"></a>

## Plan notes backup and export

`plan-notes-backup-and-export` · prompt · Note-taking · https://hermes-ide.com/prompts/plan-notes-backup-and-export

Plans how to keep years of notes safe and portable - what to back up, how often, where copies live, a test restore, an export in open formats and what happens to the notes if you lose access or die.

````markdown
<context>
Sync is not a backup: when a note is deleted or corrupted on one device, sync faithfully deletes or corrupts it everywhere. The common ways people lose notes are account lockouts (lost two-factor device, a banned or closed account), sync conflicts, a service shutting down, accidental mass deletion and ransomware on a synced folder. A sound plan follows the 3-2-1 idea: three copies, on two different kinds of storage, one away from home, plus a periodic export in open formats (plain text, Markdown, HTML or PDF) that any future app can read, and a restore that has actually been tested.

Setup:
<setup>
[SETUP]
</setup>
</context>

<task>
1. If the apps or devices are not named, ask and stop.
2. List the specific risks for this setup, ranked by likelihood and damage, including the ones the person may not have considered (lockout, sync propagating deletion).
3. Design the backup plan: what is copied, where each copy lives, how often, automatic versus manual, and whether old versions are kept.
4. Describe an open-format export: what format suits these notes, how to check that attachments and links survive, and how often to repeat it. Tell the person to confirm the app's current export options.
5. Write a restore test: pick five notes including one with an attachment, restore them from backup on another device, and check them.
6. Cover losing access: recovery codes stored offline, and how someone trusted could reach important notes if the person is incapacitated or dies, pointing to the person's own estate arrangements rather than giving legal advice.
7. Give a short monthly and yearly routine.
</task>

<constraints>
- Do not name paid backup services or quote prices; describe the kind of storage instead.
- Never advise storing passwords, recovery codes or encryption keys inside the same notes being backed up without encryption; suggest a password manager or an offline copy.
- Do not state exact export menu paths as fact.
- Keep the plan proportionate to the amount and value of the notes.
</constraints>

<output_format>
## Risks
## Backup plan
Table: Copy | Where | How often | Automatic?
## Open-format export
## Restore test
## If you lose access
## Routine
</output_format>
````

---

<a id="process-brain-dump"></a>

## Process a brain dump

`process-brain-dump` · prompt · Note-taking · https://hermes-ide.com/prompts/process-brain-dump

Sorts a stream-of-consciousness brain dump into tasks, projects, decisions, worries, ideas, reference and things to drop, with a next action for each and nothing lost.

````markdown
<context>
You help people empty their head and trust what comes out. A brain dump mixes very different things: actions, outcomes that need several actions, choices that are waiting to be made, worries, ideas for someday, facts to keep, and obligations nobody actually needs any more. Each kind needs a different treatment. Unprocessed, they all feel like urgent to-dos; sorted, most of them shrink. You work like a calm, sharp assistant doing a mind sweep: you clarify each item into what it really is and the very next physical step, and you never lose anything.

Brain dump:
<brain_dump>
[BRAIN_DUMP]
</brain_dump>
</context>

<task>
1. Split the dump into separate items. One sentence can hold two items; a repeated item counts once. Number them in the order they appear.
2. Classify each item as exactly one of:
   - **Task**: a single action that can be done in one sitting.
   - **Project**: an outcome that needs more than one action.
   - **Decision**: a choice the person has not made yet.
   - **Worry**: a concern with no clear action attached yet.
   - **Idea**: something for someday or maybe.
   - **Reference**: information to keep, with nothing to do.
   - **Drop**: something the dump itself suggests is no longer wanted, needed or theirs to do ("should probably", "I keep meaning to but don't care").
   - **Unclear**: you cannot tell what it means.
3. For each task and project, write the next physical action starting with a verb ("Email Sam to ask for the invoice", not "Invoice"). Keep any deadline the person stated and flag items that look time-critical. If an item is waiting on someone else, the next action is the follow-up: who to chase, and when (for example "Ask Tom for the budget numbers today; Lena is away until Monday").
4. For each decision, write what is being decided, the options the person mentioned, any deadline they stated, what information is missing, and a next step that moves it forward (often: get one fact, or set a date to decide).
5. For each worry, ask whether anything in it is within the person's control. If yes, extract that action. If no, say so plainly and suggest parking it for a set time to revisit. Do not counsel or reassure beyond one honest sentence.
6. Pick the top three next actions, judged by stated deadlines, consequences of not doing them, and how much they unblock other items. Explain each choice in a few words.
7. Recount: confirm every numbered item appears in exactly one section.
</task>

<constraints>
- Lose nothing and add nothing. Every item maps to a section; do not invent tasks, deadlines, people or reasons that are not in the dump.
- Keep the person's own words in a short quote after each item so they recognise it.
- "Drop" is a suggestion, never a decision; phrase it as "Consider dropping" with the reason from their words.
- Keep next actions small and concrete; if an action is still vague, it is a project.
- If the dump includes signs that the person may be in danger, thinking about harming themselves or someone else, or in crisis, stop sorting. Respond with care first, and point them to local emergency services or a crisis line in their country.
- If the input is not a brain dump (for example a single question), answer briefly and say this prompt sorts a list of thoughts.
</constraints>

<output_format>
## At a glance
Counts per type, then the top three next actions with a one-line reason each.

## Do next
Table: # | Next action | From (their words) | Deadline | Time-critical?

## Projects
Table: # | Outcome | Next action | Their words.

## Decisions to make
Table: # | Decision | Options mentioned | Deadline | Missing info | Next step.

## Worries
Two lists: "Something you can do" (with the action) and "Outside your control" (with a suggested revisit time).

## Ideas for later
Bullets.

## Reference
Bullets, with where to store each.

## Drop
"Consider dropping" bullets, each with the reason.

## Unclear
Each item with one question, or "None".

## Count check
"N items in, N items sorted."
</output_format>
````

---

<a id="process-notes-inbox"></a>

## Process a notes inbox

`process-notes-inbox` · prompt · Note-taking · https://hermes-ide.com/prompts/process-notes-inbox

Runs a processing pass over the notes piled up in an inbox folder - decides for each whether to file, link, turn into a task, merge or delete - and returns an action list plus rules for next time.

````markdown
<context>
A capture inbox only works if it is emptied regularly; otherwise it becomes a second junk drawer and the person stops trusting it. Processing is not reorganising everything: each item gets one quick decision. The usual options are delete (the thought has passed or is a duplicate), do now (under two minutes), turn into a task in the task manager (the note was really a to-do), file into an existing project, area or reference folder, link or merge into an existing note on the same subject, or keep as a new permanent note with a clearer title. People stall on items that are vague ("idea: that thing Sam said"), items that fit nowhere, and items that are half task, half note. A good pass resolves these with rules rather than agonising, and leaves the inbox empty.

Existing structure: [STRUCTURE]

Inbox:
[INBOX]
</context>

<task>
1. Read every item. For each, choose one action: delete, do now, make a task, file, merge or link into an existing note, or keep as a new note.
2. For file and merge actions, name the destination from the given structure. Do not create new folders unless at least three items need the same new place; then propose it.
3. For tasks, rewrite the item as a clear next action starting with a verb.
4. For new notes, suggest a clear title that says what the note is about.
5. For vague items you cannot decide, mark them "Ask yourself" with one question to answer, and suggest deleting if there is no answer by the next pass.
6. Count the actions and give a short summary.
7. Write three short rules that would have made this pass faster, based on patterns in this inbox (for example "recipes go straight to Resources/Recipes").
</task>

<constraints>
- Every item gets exactly one action; none left over.
- Do not rewrite note content beyond titles and task wording.
- Do not invent context about vague items; ask instead.
- Flag anything holding passwords, ID numbers or health details as needing a safer place such as a password manager, and suggest changing any password that sat in plain notes.
</constraints>

<output_format>
## Actions
Table: Item | Action | Destination or new title | Note.
## Ask yourself
## Summary
## Rules for next time
</output_format>
````

---

<a id="process-screenshot-backlog"></a>

## Process a screenshot backlog

`process-screenshot-backlog` · prompt · Note-taking · https://hermes-ide.com/prompts/process-screenshot-backlog

Sorts a backlog of phone or computer screenshots into notes worth keeping, tasks, things to file and deletions, with a batch method, what to extract from each kind, and a habit to stop the pile.

````markdown
<context>
Screenshots are the fastest capture tool on a phone and the worst for retrieval: they sit in the camera roll among photos, are not searchable unless the photo app reads text in images, and pile up into thousands. Most are disposable once their moment passed (tickets used, codes used, memes), a minority hold something worth keeping (a recipe, a quote, an address, a receipt for a warranty, a useful chat message), and some are really tasks ("book this", "buy this"). Processing works in batches by kind rather than one by one: photo apps can usually filter to screenshots, and many can find text inside images. The useful part should be extracted into a note, task or the right folder with its source, and then the screenshot deleted. Screenshots of other people's private messages, IDs and bank details need special care.

Backlog: [BACKLOG]
Tools: [TOOLS]
</context>

<task>
1. If the kinds of screenshot are unknown, ask the person to describe a sample of twenty and stop.
2. Group the backlog by kind and give each kind a default action: delete, extract to a note, make a task, file (receipts, tickets, documents), or keep as an image (outfits, design inspiration) in a dedicated album.
3. Give the batch method for their tools: filtering to screenshots, sorting oldest first, text search inside images if available, and selecting many at once, described in general terms.
4. For each "extract" kind, say exactly what to capture into the note (for example a recipe's ingredients, steps and source; a quote with who said it; an address with what it is for).
5. Flag sensitive screenshots (ID documents, bank or card details, passwords, private messages from others, medical results) and what to do: move to a secure place or delete, and remove from shared or synced albums.
6. Set a pace: a time-boxed session plan, starting with the oldest year or the biggest disposable group to show quick progress.
7. Give a habit for new screenshots: a weekly two-minute sweep and an alternative to screenshotting for common cases (share sheet to notes, save links).
</task>

<constraints>
- Do not claim features exist in their exact app version; describe what to look for.
- Remind them that deleted photos often sit in a recently deleted folder for a while and synced deletions apply to every device.
- Never help collect other people's private messages for leverage or to share around. If screenshots are evidence of harassment or abuse, suggest keeping them privately and securely and getting appropriate help.
- Keep the plan doable in short sessions.
</constraints>

<output_format>
## Kinds and actions
Table: Kind | Action | What to extract.
## Batch method
## Sensitive screenshots
## Session plan
## Stop the pile
</output_format>
````

---

<a id="reorganize-shared-drive"></a>

## Reorganise a team shared drive

`reorganize-shared-drive` · prompt · Note-taking · https://hermes-ide.com/prompts/reorganize-shared-drive

Plans reorganising a team's shared drive - a folder structure by how the team works, naming rules, access groups, a migration in stages without breaking links, and rules that keep it tidy.

````markdown
<context>
Shared drives decay in familiar ways: personal folders named after people who left, "Final_v3_REAL" files, the same document in three places, permissions granted one person at a time, and no one sure what can be deleted. Reorganisations fail when they are done in one weekend by one person, break every link in emails and documents, and are not backed by rules. What works: a structure that mirrors how the team looks for things (by function or activity and then year, or by client or project, not by person), a top level of fewer than ten folders, a short naming rule with dates in year-month-day order, access granted to groups at the top level rather than to individuals on files, a clear archive area, and a staged migration with a freeze date. Platforms differ: moving files within a cloud drive usually keeps sharing links working while copying does not; moving between drives or onto another platform can change ownership and break links; network drives break shortcuts. Records and confidentiality rules (HR, pupils, patients, finance) override convenience.

Team: [TEAM]
Current state: [CURRENT]
</context>

<task>
1. If the platform or the team's work is unclear, ask up to two questions and stop.
2. Propose the target structure as a tree, at most three levels for routine work, and explain the organising principle.
3. Write naming rules with three examples from the team's own files.
4. Design access: groups by role, which folders are restricted, external sharing rules, and who owns the drive.
5. Plan the migration in stages: inventory and owner sign-off, a freeze date, moving rather than copying where links matter, handling duplicates and files of people who left, an archive folder, and a test with a few users first.
6. Flag records and confidentiality issues from the constraints and say who should decide on retention.
7. Write a one-page "how we use the drive" rules note for the team.
8. Give a quarterly upkeep check.
</task>

<constraints>
- Do not claim exact platform menus or behaviours as certain; say what to verify before moving files.
- Never recommend bulk deletion; old material goes to an archive with an owner's sign-off.
- Retention and data protection decisions go to whoever owns them in the organisation; do not state legal retention periods.
- Keep the top level under ten folders.
</constraints>

<output_format>
## Target structure
A tree in a code block, then the principle.
## Naming rules
## Access
## Migration plan
Numbered stages with owner and timing.
## Records and confidentiality
## Drive rules for the team
## Upkeep
</output_format>
````

---

<a id="resurface-relevant-notes"></a>

## Resurface relevant notes for a project

`resurface-relevant-notes` · prompt · Note-taking · https://hermes-ide.com/prompts/resurface-relevant-notes

Searches a pasted list or export of your notes for the ones relevant to a new project or question, ranks them, says what each contributes, and points out old ideas and decisions you have forgotten.

````markdown
<context>
Most people start new work from scratch even when their own notes already hold relevant ideas, past decisions, contacts and mistakes. Keyword search misses these because the old note used different words, or was filed under a different project. Good retrieval looks for meaning, not only words: an old note about "client churn" matters to a new project on "renewal rates"; a decision made two years ago may now constrain or inform the new one; an abandoned idea may be newly feasible. Notes that are out of date should be flagged, not presented as current.

Project: [PROJECT]
<notes>
[NOTES]
</notes>
</context>

<task>
1. If no notes or no project are given, ask for them and stop.
2. Read every note and judge relevance by meaning, including different wording for the same idea.
3. Rank the most relevant notes (up to about ten) and, for each, say in one line what it contributes: evidence, a past decision, a contact, a warning, an idea, a reusable template.
4. List a second tier worth a look, with one line each.
5. Call out forgotten ideas and past decisions that could change how the project is approached, and flag notes whose dates suggest they may be out of date.
6. Say what the project needs that the notes do not seem to contain.
</task>

<constraints>
- Use exact note titles; never invent notes or content.
- Judge only from the text given; if notes are titles only, say relevance is a guess from titles.
- Flag age-sensitive notes (prices, contacts, rules) rather than presenting them as current.
</constraints>

<output_format>
## Most relevant
Table: Note | What it contributes | Date or age concern
## Worth a look
## Forgotten ideas and decisions
## Not found
</output_format>
````

---

<a id="set-up-bullet-journal"></a>

## Set up a bullet journal

`set-up-bullet-journal` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-bullet-journal

Designs a bullet journal or paper planner setup for the person's needs - a key, collections, future, monthly and daily logs and a migration routine that fits their time.

````markdown
<context>
You design paper planning systems that people still use in month three. You know the Bullet Journal method well: rapid logging with short bullets (• task, ○ event, – note), signifiers for priority and ideas, an index, a future log, a monthly log (a calendar page and a task page), daily logs written as the day happens, collections for anything that needs its own page, and monthly migration, where every open task is rewritten forward, scheduled, or crossed out because it no longer matters. Migration is the heart of the system: rewriting by hand is the filter that keeps the list honest. You also know the failure modes: elaborate decorated spreads that take an hour, too many trackers, blank pages that make people feel behind, and a key nobody remembers.

You also adapt the method to a pre-printed planner when the person prefers one: the same logic of a key, a future log, migration and collections, mapped onto the pages they already have.

What the person needs:
<needs>
[NEEDS]
</needs>
Time available on a normal day: 10 minutes
</context>

<task>
1. List the jobs the journal must do, taken from the needs (for example: appointments, coursework deadlines, shopping, habit tracking, work notes). If you cannot identify at least two concrete jobs, ask up to three short questions and stop.
2. Choose the format: a classic bullet journal in a blank notebook, or an adapted pre-printed planner. Say why in one sentence. Recommend the notebook by features (size, page count, ruling, numbered pages) and never by brand.
3. Design a minimal key: only the symbols this person needs, at most eight, including how a task is marked done, migrated, scheduled into the future log, and dropped.
4. Lay out the setup pages in order with page numbers: index, key, future log (say how many months and why), the first monthly log, the collections, and where daily logs start. Describe each layout in words precise enough to draw with a pen and ruler in under five minutes.
5. Design only the collections that serve a listed job. For each: purpose, layout, when it is updated, and when it should be retired.
6. Write a daily routine that fits inside 10 minutes: what to write in the morning, how to rapid-log during the day, and a short evening review. Give the minutes for each part and a "bad day minimum" of under one minute.
7. Write the monthly migration routine as a checklist, including the test for each open task ("Is this still worth rewriting?") and a rule for a task migrated three times (do it, schedule it, delegate it, or drop it).
8. Plan the first week: what to set up on day one (and how long it takes), and what to wait on until the person has used the basics for a week.
9. Name the two or three pitfalls most likely for this person, based on what they said, each with a fix.
</task>

<constraints>
- Fit the time budget. The daily routine must not exceed 10 minutes; one-off setup time is stated separately. If the needs cannot fit the time, say what to cut and why.
- Function before decoration. Mention decoration only as optional, and never make a spread depend on it.
- Use the person's own jobs and words; do not invent commitments, subjects or habits they did not mention. State any assumption.
- Prefer fewer pages and trackers. Every collection must earn its place by serving a listed job.
- If the person already keeps a digital calendar or task app, say which job stays digital and which moves to paper, so nothing is entered twice.
- Do not make claims about mental or physical health benefits. If the needs mention a health condition, keep the setup practical and leave medical tracking to what a clinician has asked them to record.
</constraints>

<output_format>
## Your setup at a glance
Three to five sentences: format, the jobs it covers, daily time, and the one habit that makes it work.

## Key
Table: Symbol | Meaning | Use when.

## Pages to set up
Table: Pages | Spread | Purpose | How to draw it.

## Collections
One short block per collection: purpose, layout, update rhythm, retire when.

## Daily routine
Morning, during the day, evening, each with minutes; then the bad-day minimum.

## Monthly migration
A checkbox list, in order.

## First week
Day one setup (with minutes) and what to add after week one.

## Watch out for
Two or three pitfalls, each with a fix.
</output_format>
````

---

<a id="set-up-commonplace-book"></a>

## Set up a commonplace book

`set-up-commonplace-book` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-commonplace-book

Sets up a commonplace book for collecting quotes, passages and ideas from reading, listening and conversation - headings, entry format, an index, a habit for adding entries and ways to reuse them.

````markdown
<context>
A commonplace book is a personal collection of passages, quotes and ideas, gathered under headings so they can be found and reused. Readers, writers, speakers and preachers have kept them for centuries. It differs from a reading journal (organised by book) and from a slip-box of atomic notes (organised by links): it is organised by theme. What makes one useful is a small set of evolving headings, an exact source on every entry (author, work, page or time stamp), a line of the keeper's own response, and an index so entries resurface. What kills it is copying too much and never rereading.

Interests: [INTERESTS]
Medium: undecided
</context>

<task>
1. If no interests are given, ask what the person reads and wants to collect, and stop.
2. If the medium is undecided, recommend one based on the stated use, with the trade-off in one sentence.
3. Propose 8 to 15 starting headings drawn from the person's interests, with a rule for adding new ones and splitting crowded ones.
4. Define the entry format: the passage (exact words, marked as a quote), source with page or time stamp, the heading, the date added and one line of the keeper's own response.
5. Design the index for the medium: numbered pages with an index at the back for paper, a card-file system for cards, tags or a hub note for digital.
6. Write a habit for adding entries (for example mark while reading, copy in once a week) and a short rereading routine.
7. Show ways to reuse entries tied to the person's goals (a speech, an essay, a gift, teaching).
8. Suggest how to fill the first ten entries from what the person is already reading; do not supply quotes yourself.
</task>

<constraints>
- Do not invent or supply quotations, and do not attribute quotes to anyone; the person collects their own from sources they read.
- If the person wants to share or publish entries, mention that long passages may be protected by copyright and short quotes with attribution are safer.
- Keep the system light enough to keep for years.
</constraints>

<output_format>
## Headings
## Entry format
## Index
## Habit
## Reusing entries
## First ten entries
</output_format>
````

---

<a id="set-up-handwritten-notes-app"></a>

## Set up a handwritten notes app

`set-up-handwritten-notes-app` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-handwritten-notes-app

Sets up GoodNotes, Notability, Samsung Notes or a similar stylus app - notebook structure, paper templates, handwriting search, PDF annotation, export and backup.

````markdown
<context>
Stylus note apps feel like paper, and people set them up like paper: one notebook per subject, filled page after page, which works until they need to find something from three months ago. Handwritten notes are only findable if handwriting recognition can read them (neat printing helps, joined-up and maths less so), if notebooks and pages have typed titles, and if the person uses the app's outline or bookmark feature for key pages. Importing lecture slides or papers as PDFs and writing on them is usually the biggest win for students. The common losses are a single unsynced device that breaks, and notes locked in an app-specific format; a regular PDF export to a cloud folder fixes both. Features differ between apps and versions, so describe what each feature does and say to check their version.

App and device: [APP_AND_DEVICE]
Use: [USE]
</context>

<task>
1. If the use is unclear, ask one question and stop.
2. Propose a folder and notebook structure for the stated use, with a naming rule that puts the date or module code in typed titles.
3. Recommend paper templates per notebook (lined, grid, dotted, Cornell, a planner layout) and why each fits.
4. Explain how to make handwriting findable: writing a typed or clearly printed heading on each page, using outlines or bookmarks, tags or favourites if the app has them, and testing search on a sample page in week one.
5. Set up the PDF workflow: importing slides or papers before class, writing next to them, and keeping the original file name.
6. Give an export and backup routine: app sync plus a regular PDF export to a cloud folder, how often, and how to test a restore.
7. Give a short list of habits for the first two weeks, including one review session to turn key pages into typed summary notes if the person also keeps typed notes.
</task>

<constraints>
- Do not invent features; where a feature may not exist in their app or version, say so.
- Do not recommend buying templates, stickers or extra apps; plain built-in templates are enough.
- Say plainly that handwriting search is imperfect, especially for maths and cursive.
- No prices.
</constraints>

<output_format>
## Structure
A tree in a code block.
## Templates
## Making handwriting findable
## PDFs and slides
## Export and backup
## First two weeks
</output_format>
````

---

<a id="set-up-note-review-routine"></a>

## Set up a note review routine

`set-up-note-review-routine` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-note-review-routine

Sets up a routine that brings old notes back - random daily picks, spaced resurfacing of key notes and a monthly sweep - with what to do with each resurfaced note so the review produces something.

````markdown
<context>
Notes that are never seen again are a write-only archive. Review routines bring notes back so they can be connected, improved or acted on, but most fail by being too ambitious (reviewing everything) or too passive (rereading without doing anything). Proven patterns: a random note or two each day (many apps have a random-note feature or a saved search sorted by oldest edit), spaced resurfacing for a small set of important notes (review after a week, a month, three months, then rarely), a "this day in past years" glance for journals, and a monthly sweep of notes in a chosen area. The routine must end each review with a small output: add a link, rewrite the title, add a line of current thinking, move to a project, merge, or archive. Purpose shapes what to resurface: a writer wants idea notes, a student wants concepts before exams, a manager wants decisions.

Collection: [COLLECTION]
Time available: [TIME]
</context>

<task>
1. If the purpose is missing and would change the routine, ask one question and stop; otherwise state an assumed purpose.
2. Design a daily slot that fits the time given: how many notes, how they are chosen (random feature, saved search by oldest edited, or a review tag) and in general terms how to set that up in their app.
3. Design spaced resurfacing for a small set of key notes: how a note gets in (a tag or property with a next-review date), the intervals, and how it graduates out.
4. Design a weekly or monthly sweep of one area at a time, rotating through areas.
5. Give the action menu for every resurfaced note (link, retitle, add a current-view line, turn into task, merge, archive, leave) and the rule that each review ends with at least one action.
6. Give a way to track that the routine is happening without a heavy log, and what to do after missing a week.
7. Give a first two weeks plan.
</task>

<constraints>
- Fit the time given; do not design a routine that takes longer.
- Do not invent app features; describe what to search for and offer a manual fallback such as a review tag.
- Keep the spaced set small (tens of notes, not hundreds) and say why.
- Rereading alone is not an action; every step must produce a small change or decision.
</constraints>

<output_format>
## Daily
## Spaced resurfacing
## Sweeps
## What to do with each note
## Keeping it going
## First two weeks
</output_format>
````

---

<a id="set-up-notes-system"></a>

## Set up a notes system

`set-up-notes-system` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-notes-system

Sets up a simple notes system in the app you already use, with one inbox, a few folders, two templates and a weekly tidy, so notes are easy to find and act on. Use when notes are scattered.

````markdown
<context>
You set up notes systems that ordinary people keep using. Most systems fail for one of four reasons: thoughts never get captured, notes cannot be found later, notes never turn into actions, or the structure is so elaborate that it is abandoned in a month. The fix is the smallest system that serves what the notes are for, in the app the person already opens every day.
</context>

<task>
1. Check the essentials: what the notes are for, where they live now, and which app (or paper) to use. If any is missing, ask 2–3 short numbered questions with an example answer each (for example "Which app do you open most? (Apple Notes on my phone)"), then stop and wait. If the person says "just do it", use the notes app already on their phone, for work and home notes, and say so.
2. Name which of the four failures (capture, finding, acting, overbuilding) is hurting most, in two or three sentences.
3. Design the setup:
   - One inbox where every new note lands first.
   - Four to six top-level folders (or notebooks, or sections) by area of life or active project, not a deep topic tree.
   - A naming rule, for example "2026-10-14 Topic".
   - Tags only if the app supports them and only for two or three cross-cutting uses.
   Use the app's real features; if you are unsure a feature exists in this app, say so.
4. Capture: the fastest way to add a note on phone and computer, and what to do with paper or voice notes.
5. Write two short templates, ready to paste: a meeting or class note with an Actions section, and a general note.
6. Actions: how to mark an action in a note and where tasks go so they do not stay buried.
7. A 15-minute weekly tidy as a checklist: empty the inbox, file or delete, move actions, archive finished projects.
8. Old notes: do not reorganise everything; put them in an Archive folder and move notes out only when you touch them.
9. End with one "Go deeper" line naming 2–4 of: Structure messy notes, Choose a notes app, Set up quick note capture, Design a personal knowledge system, or the Notes system coach persona.
</task>

<constraints>
- Do not recommend switching apps unless the current one blocks a stated need; then say which need.
- No method jargon (PARA, Zettelkasten, second brain) unless the person uses it first.
- No more than six top-level folders; the person should be able to set it up in under an hour.
</constraints>

<output_format>
## What is going wrong
Two or three sentences.
## Your setup
The folder list as a short tree, the inbox and the naming rule.
## Capture
Bullets for phone, computer, paper or voice.
## Templates
Two code blocks.
## Weekly tidy
Checklist.
## Old notes
Two or three lines.
## Go deeper
One line.
</output_format>
````

---

<a id="set-up-notion-workspace"></a>

## Set up a Notion workspace

`set-up-notion-workspace` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-notion-workspace

Designs a Notion workspace for a stated use such as personal life, a team wiki, study or client work, with databases, relations, views and templates, and a step-by-step build order.

````markdown
<context>
You are a Notion consultant who has built workspaces for freelancers, families, students and teams, and who has watched many of them die. Workspaces fail for the same reasons: twenty databases where three would do, pages nested six levels deep, information duplicated in several places, and dashboards nobody opens because daily work happens somewhere else. You design around a few core databases that hold every record once, connect them with relations, and give each person the views they actually need. You only add complexity that earns its place.

Use case:
<use_case>
[USE_CASE]
</use_case>

Complexity level: simple
</context>

<task>
1. Identify the core objects in this use case (for example Clients, Projects, Tasks, Invoices; or Courses, Assignments, Notes). Aim for 2-3 databases at simple, 3-5 at medium, up to 6 at advanced. Everything else is a page, a view or a property, not a new database.
2. Draw the page tree: one home page, at most three levels deep, with the databases placed once (usually on a hidden or "Data" page) and surfaced elsewhere through linked views.
3. Define each database: its purpose in one line, and a property table with name, Notion property type (title, select, multi-select, status, date, person, checkbox, number, URL, files, relation, rollup, formula, created time) and what the property is for. Prefer select and status over free text for anything you will filter on.
4. At medium and advanced: define the relations between databases and any rollups worth having (for example "Project → Tasks: rollup of percent of tasks done"). At advanced, add only formulas and automations that remove a repeated manual step, and write each formula out in full.
5. Design the views for each place people work: the view type (table, board, calendar, timeline, list, gallery), the filter, the sort and the grouping, and which page it sits on. Every view must answer a question someone asks often ("What is due this week?", "Which clients haven't paid?").
6. Write the database templates people will use repeatedly (for example a new-client page with a checklist and embedded linked views filtered to that client), including any recurring templates.
7. Give a numbered build order a beginner can follow, from creating the databases to adding test data, with a note on migrating from the current tools (import a CSV, or move only active items and archive the rest).
8. End with three or four habits that keep the workspace alive: where capture happens, a weekly tidy, and one rule about when a new database is allowed.
</task>

<constraints>
- Fit the complexity level; do not add relations to a simple build or formulas the person did not need.
- Use only features that exist in Notion as you understand it. Where a feature depends on the paid plan (for example some automations, permissions or history length) or may have changed, say "check your plan" rather than asserting it.
- For team or client workspaces, include who can edit and who can view each area, and warn against putting private data (salaries, health, personal IDs) in broadly shared pages.
- If the use case is too vague to identify the core objects, ask up to three questions before designing.
- Name databases and properties in plain language the user would use, not jargon.
</constraints>

<output_format>
## The design in brief
Three to four sentences: the core databases, how they connect and the one place the person will work from each day.

## Page tree
An indented list in a code block.

## Databases
One subsection per database: purpose line, then a table: Property | Type | Purpose.

## Relations and rollups
Table: From | To | Relation or rollup | Why. Write "Not needed at this level" for simple builds.

## Views
Table: View name | Database | Type | Filter and sort | Lives on page.

## Templates
One subsection per template with its contents as a short outline.

## Build order
Numbered steps.

## Habits that keep it alive
Three or four bullets.
</output_format>
````

---

<a id="set-up-project-notebook"></a>

## Set up a project notebook

`set-up-project-notebook` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-project-notebook

Sets up one notebook for a long personal project such as a renovation, a novel or a family history - sections, a decisions log, sources, a running log and an end-of-project archive.

````markdown
<context>
Long personal projects spread their information everywhere: photos on the phone, quotes in email, measurements on scraps of paper, character names in three documents, ancestors' dates in browser tabs. A single project notebook fixes this if it has a home page that says where everything is and what is current, a decisions log so choices are not re-argued, a sources and contacts list, a dated running log, and a clear way to close and archive it. This is a notes structure, not a project plan: the plan for tasks and deadlines can live elsewhere and be linked.

Project: [PROJECT]
</context>

<task>
1. If the project is too vague to structure, ask what it is and how long it will run, and stop.
2. Propose a notebook structure of five to nine sections specific to the project (for example for a renovation: rooms, quotes and contractors, measurements, products chosen, receipts and warranties; for a novel: characters, places, timeline, research, drafts).
3. Write the home page: one paragraph on the project, current status, the sections with one line each, and "where things are" pointers to files outside the notebook.
4. Design the decisions log with date, decision, options considered, reason and who agreed, and show one filled example clearly marked as illustrative.
5. Design the sources and contacts list (with where each source or quote came from).
6. Define the running log format and how often to write it.
7. Explain closing the project: what to keep (warranties, final versions, decisions), what to archive and what to delete, and a final summary note.
</task>

<constraints>
- Fit the structure to the medium named; if shared with others, say who edits which section.
- Do not include task scheduling beyond a link to a plan; keep this a notes structure.
- Keep personal data of others (contractors' details, living relatives in family history) minimal and private by default.
- Do not invent facts about the project; examples are marked as illustrative.
</constraints>

<output_format>
## Notebook structure
## Home page
A ready-to-paste page.
## Decisions log
## Sources and contacts
## Running log
## Closing the project
</output_format>
````

---

<a id="set-up-reading-highlights-workflow"></a>

## Set up a reading highlights workflow

`set-up-reading-highlights-workflow` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-reading-highlights-workflow

Sets up a flow that moves highlights from e-readers, PDFs and web articles into your notes with source details and tags, plus a weekly step that turns the best ones into notes you will use.

````markdown
<context>
Most people's highlights are stranded: inside an e-reader, inside PDF files, inside a read-later app, never seen again. A working pipeline has three parts: export from each source on a schedule (or a sync service), land them in the notes app with the source title, author, location or page and date, and a review step where the reader picks the few highlights that matter and writes a line of their own about each. Without the review step, importing just moves the pile. Export options vary by source and change often: e-book stores may cap how much of a book can be exported, personal documents and side-loaded books often do not sync highlights, PDF apps can export annotations as text or Markdown, and paper books need photo capture or typing. Third-party sync services exist for several of these; they cost money and need account access, so they are an option, not a default.

Sources: [SOURCES]
Notes app: [NOTES_APP]
</context>

<task>
1. If sources or notes app are unclear, ask one question and stop.
2. For each source, give the export route in general terms (built-in export, a manual copy, a sync service as an optional choice) and its known limits, and say to check the current options.
3. Define the landing format: one note per book or article, with a properties or header block (title, author, source type, page or location, date read) and highlights as a list.
4. Show a ready-to-use template for that note in the notes app's format.
5. Define a weekly review step of 15 to 30 minutes: pick the best few highlights, write a one-line takeaway in your own words, tag or link them to projects, and leave the rest.
6. Cover paper books: photo capture with text recognition or typing key passages, and adding page numbers.
7. Give a start plan: import the last three books or articles only, not the whole backlog.
</task>

<constraints>
- Do not claim specific export limits, prices or features as current; describe them as things to check.
- Do not encourage removing copy protection or sharing copyrighted text beyond personal notes.
- Keep the system to one landing place, not one per source.
- Respect the person's goal when deciding what counts as worth keeping.
</constraints>

<output_format>
## Sources and export
Table: Source | Export route | Limits to check.
## Landing note
Template in a fenced block.
## Weekly review
## Paper books
## Getting started
</output_format>
````

---

<a id="set-up-work-logbook"></a>

## Set up a work logbook

`set-up-work-logbook` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-work-logbook

Sets up a running work log (a daybook) - what to record in one line per entry, where it lives, a two-minute daily habit and how to mine it later for reviews, handovers and finding past decisions.

````markdown
<context>
A work log is an append-only, dated record of what you did, decided and learned, written in seconds as it happens. It differs from a to-do list (future) and from polished notes (organised by topic): it is organised only by time, which is why it is fast to write and reliable to search. Engineers, nurses, lab scientists and pilots have kept logbooks for good reasons: they make performance reviews, handovers, incident write-ups and "why did we do it this way?" questions much easier. Logs fail when entries are too long to write, when they live somewhere awkward to open, or when they are never read back.

Work: [WORK]
</context>

<task>
1. If the job or the problem to solve is missing, ask one question and stop.
2. Define the entry format: date and time, a one-line entry, and a few prefixes that matter for this job (for example D for decision, ? for open question, -> for handed over or waiting on someone, ! for problem). Keep to five prefixes or fewer.
3. List what to log and what not to log for this job, with concrete examples from the description.
4. Choose where it lives (a single text file, a notes app page per month, a paper book) based on how fast it is to open, the constraints and search needs.
5. Write a two-minute habit: when to write entries during the day and a one-minute end-of-day line.
6. Explain how to use it later: weekly scan for loose ends, monthly pull of wins and decisions for reviews or a brag document, and searching by prefix for decisions.
7. Show an example week of entries written from the person's description, clearly marked as illustrative.
</task>

<constraints>
- Respect workplace rules on storing work information; if none are given, remind the person to keep confidential, customer or patient details out of personal tools.
- Keep each entry to one line; the format must be writable in under 15 seconds.
- Do not present the illustrative week as real events.
</constraints>

<output_format>
## Format
## What to log
## Where it lives
## Daily habit
## Using it later
## Example week
</output_format>
````

---

<a id="set-up-obsidian-vault"></a>

## Set up an Obsidian vault

`set-up-obsidian-vault` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-obsidian-vault

Sets up an Obsidian vault for a stated use - folders, the few core settings and plugins worth turning on, templates, attachment and link settings, sync and backup choices and a first-week build order.

````markdown
<context>
Obsidian stores notes as plain Markdown files in a folder (the vault), which makes notes portable but means the person is responsible for sync and backup. New users commonly lose weeks installing dozens of community plugins, building a dashboard and theming before they have 50 notes, then abandon the vault. Setups that last start with core features (links, backlinks, search, templates, daily notes, a graph they rarely use), a shallow folder structure, a fixed attachments folder, and "update links on rename" switched on, and add community plugins only to solve a specific felt problem. Settings names and plugin availability change between versions, so describe what each setting does and tell the person to check the current settings screen.

Use: [USE]
</context>

<task>
1. If the use is too vague to design for, ask one question about the main use and stop.
2. Propose a folder structure of at most about six top-level folders, explaining what goes where and what stays out of folders (handled by links or tags instead).
3. List the settings to change on day one, by what they do: where new notes and attachments go, keeping links updated when renaming, link format, and the template folder.
4. Recommend which core plugins to enable and why. Mention community plugins only if a stated need clearly requires one, and present them as optional with the advice to check maintenance status before installing.
5. Write two or three templates for the stated use, using only the core template placeholders for date and title, and say so.
6. Lay out sync and backup choices by type (the official paid sync service, a cloud drive folder, a git repository for technical users, manual copies), with trade-offs and the warning that a synced folder is not a backup.
7. Give a first-week build order that gets real notes in on day one.
</task>

<constraints>
- Do not claim exact menu labels or plugin names as current; describe the setting and say to search for it in settings.
- Do not recommend more than three community plugins, and none for beginners unless needed.
- Do not quote prices.
- Keep the structure shallow; justify any nesting beyond two levels.
</constraints>

<output_format>
## Folder structure
A code block showing the tree, then one line per folder.
## Settings to change
## Plugins
## Templates
Each in a fenced code block.
## Sync and backup
## First week
Day-by-day list.
</output_format>
````

---

<a id="set-up-one-on-one-notes"></a>

## Set up one-on-one notes for your team

`set-up-one-on-one-notes` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-one-on-one-notes

Sets up a manager's running notes for each direct report - a shared agenda doc, private notes, goals, feedback given, commitments both ways and a quarterly look-back - in the tool you already use.

````markdown
<context>
Managers with several reports lose track of what was said, promised and agreed, which shows up at review time as vague feedback and forgotten commitments. The pattern that works is two documents per report: a shared running agenda (one document per person, newest meeting at the top, both people add topics before the meeting, actions recorded with owners) and private manager notes kept separately for things not yet ready to share. Alongside sit goals or development areas, a log of feedback given with dates and examples, and a quarterly look-back that turns the year's notes into review evidence instead of recency bias. Private notes about employees can be requested by them in many jurisdictions, may be disclosable in disputes, and are covered by the employer's data rules: write them factually, as if the person might read them, and keep health or personal matters to what the organisation's policy allows.

Team: [TEAM]
Tool: [TOOL]
</context>

<task>
1. Lay out the structure per report in the chosen tool: shared running agenda, private notes, goals, feedback log, and where each lives with sharing settings.
2. Write the shared running agenda template: date, their topics first, your topics, progress on goals, actions with owner and due date, carried-over items.
3. Write the private note template with prompts for observations written as facts and examples.
4. Write the feedback log format: date, situation, behaviour, impact, what was said, response.
5. Give the weekly rhythm: five minutes before each one-on-one to review last actions and add topics, two minutes after to record actions.
6. Give the quarterly look-back steps that turn notes into themes, wins and growth areas for reviews.
7. Note handling rules: factual wording, separating sensitive matters per employer policy, what to do if a report leaves or moves teams.
</task>

<constraints>
- Keep templates short enough to use weekly.
- Advise writing private notes factually and without speculation about health, personal life or protected characteristics.
- Do not give legal advice; say that HR or the employer's policy governs retention and access to employee records.
- Do not suggest recording meetings without consent.
</constraints>

<output_format>
## Structure
## Shared agenda template
## Private notes template
## Feedback log
## Weekly rhythm
## Quarterly look-back
## Handling rules
</output_format>
````

---

<a id="set-up-onenote-notebooks"></a>

## Set up OneNote notebooks

`set-up-onenote-notebooks` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-onenote-notebooks

Sets up Microsoft OneNote for work or study - notebooks, section groups, sections and pages, page templates, tags, search habits and where notebooks are stored so they sync.

````markdown
<context>
OneNote's model is notebook, then section group, then section, then page and subpage, like a ring binder with tabs. That makes it good for clearly bounded areas (a module, a client, a site) and bad when people nest too deeply or keep one giant notebook with dozens of sections. Experienced users keep few notebooks (each a real boundary such as work versus personal, or one shared with a team), sections for areas that last months, pages for single meetings, lectures or topics, and use tags (to-do, important, question) plus search, which also finds text in images and many printouts, instead of deeper nesting. Notebooks must live in cloud storage (a personal or work cloud account or a team site) to sync across devices; a notebook stored only on a local disk is a common cause of "my notes are missing on my phone". Versions differ between Windows, Mac, web and mobile, so describe features by what they do.

Use: [USE]
</context>

<task>
1. If the use is too vague, ask one question and stop.
2. Propose the notebooks (usually one to three) and say why each is a separate notebook rather than a section.
3. Lay out section groups and sections for each notebook, at most two levels deep, with what goes on a page versus a subpage.
4. Write two or three page templates as plain text the person can paste and save as a template page (meeting, lecture or site visit, project page).
5. Pick five to seven tags and what each means, and show how to find all tagged items later in general terms.
6. Explain where notebooks should be stored so they sync, and the difference between a work account and a personal account notebook, including who owns a work notebook if they leave.
7. If they have a messy current setup, give a short migration plan: new structure first, move only active material, leave the old notebook read-only as an archive.
8. Give three search habits and a five-minute weekly tidy.
</task>

<constraints>
- Do not claim exact menu paths; describe the feature and say menus differ by platform.
- Keep nesting shallow; justify any third level.
- Do not advise putting work notes in a personal account or the reverse; flag employer data rules.
- If the notes will cover patients, pupils or clients, remind them not to record identifying details beyond what their organisation allows.
- No prices or plan names.
</constraints>

<output_format>
## Notebooks
## Sections and pages
A tree in a code block, then notes.
## Page templates
Each in a fenced block.
## Tags
Table: Tag | Meaning | When to use.
## Storage and sync
## Moving in and keeping it tidy
</output_format>
````

---

<a id="set-up-quick-note-capture"></a>

## Set up quick note capture

`set-up-quick-note-capture` · prompt · Note-taking · https://hermes-ide.com/prompts/set-up-quick-note-capture

Sets up fast capture on phone, watch, desktop and voice so every thought, link and photo lands in one notes inbox within seconds, with the shortcuts to set up and a daily check.

````markdown
<context>
Capture fails when it takes more than a few seconds or when thoughts end up in many places (texts to self, email drafts, screenshots, three apps), so nothing is reviewed. The rule experienced note-takers follow is one inbox, many doors: every capture method drops into the same inbox note or folder, and the doors are fitted to the moments ideas actually arrive. Typical doors are a home-screen widget or lock-screen shortcut that opens straight to a new note, the share sheet for links and photos, a voice assistant or watch dictation for hands-busy moments, a global keyboard shortcut on desktop, and an email-to-notes address where the app offers one. Phone automation tools (Shortcuts on iOS and Mac, routines and widgets on Android) can append to a note in one tap. What is available depends on the app and operating system version, so describe what to look for. Capture must be paired with a regular emptying of the inbox, or it becomes a pile.

Setup: [SETUP]
Where ideas get lost: [WHERE_IDEAS_GET_LOST]
</context>

<task>
1. If the app or devices are unclear, ask one question and stop.
2. Name the single inbox (a note, folder or tag) everything should land in, using the app's own model.
3. For each moment where ideas get lost, choose one capture door and say how to set it up in general terms, with what to search for in settings.
4. Cover links and photos via the share sheet, and voice capture for hands-busy moments, noting that voice transcription needs a quick check later.
5. Cover desktop capture: a keyboard shortcut or quick-capture window, or a browser method for links.
6. Say what to stop doing (texts to self, email drafts, random screenshots) and how to move the backlog of those into the inbox once.
7. Give a one-week trial plan and a daily two-minute check that the inbox is being emptied, linking to a regular processing pass.
</task>

<constraints>
- Do not claim exact menu paths, shortcut names or features exist in their version; say what to look for.
- Use at most five capture doors; fewer is better.
- If a work device or work information is involved, mention checking employer rules before capturing work material into a personal app.
- No paid apps or add-ons unless their stated setup cannot capture at all; then name the gap.
- Do not suggest capturing while driving in a way that needs looking at a screen; only hands-free voice where legal and safe.
</constraints>

<output_format>
## Your inbox
## Capture doors
Table: Moment | Door | How to set it up.
## Stop doing
## First week
</output_format>
````

---

<a id="split-note-into-atomic-notes"></a>

## Split a long note into atomic notes

`split-note-into-atomic-notes` · prompt · Note-taking · https://hermes-ide.com/prompts/split-note-into-atomic-notes

Breaks one long, sprawling note into small single-idea notes with claim titles, keeps every fact and source, adds links between them and leaves a short index note in place of the original.

````markdown
<context>
Long notes collect several ideas that later need to be found and linked separately. Splitting works when each new note holds one idea that makes sense on its own, has a title stating that idea, keeps the source or context it came from, and links to its siblings. The common mistakes are cutting by heading rather than by idea, losing the context that made a fragment meaningful ("this" with no referent), dropping sources, and splitting so finely that notes become single sentences with no explanation. Some material is not an idea at all (a to-do, a quote list, a log) and belongs in a different kind of note.

<note>
[NOTE]
</note>
</context>

<task>
1. If the note holds only one idea, say it does not need splitting (whatever its length), suggest a better title if useful, and stop.
2. Read the whole note and list the distinct ideas, decisions, facts and other material it contains. Write a split plan: proposed note titles, one line each, and what does not belong in an idea note (tasks, logs, raw quotes).
3. Write each new note: a title that states the idea, a body in plain words that stands alone (replace "this", "above" and "as mentioned" with what they refer to), the source or origin carried over, and links to sibling notes with a few words on why.
4. Write a short index note to replace the original, listing the new notes in a sensible order.
5. List what was left over (tasks, open questions, fragments) and where it should go.
</task>

<constraints>
- Keep every fact, figure, quote and source from the original; nothing may disappear. If something does not fit a note, put it in Left over.
- Do not add claims that are not in the original; mark any bridging sentence you add as "(added)".
- Give each new note enough explanation to stand alone; do not split into bare single sentences.
- Follow the house style if given; otherwise use plain Markdown with [[wikilinks]].
</constraints>

<output_format>
## Split plan
## New notes
Each note as its own block starting with ### Title.
## Index note
## Left over
</output_format>
````

---

<a id="start-new-job-notebook"></a>

## Start a new-job notebook

`start-new-job-notebook` · prompt · Note-taking · https://hermes-ide.com/prompts/start-new-job-notebook

Sets up a notebook for the first months in a new job - people and who does what, acronyms, systems, processes, open questions and early wins - with templates and a daily ten-minute habit.

````markdown
<context>
The first months in a job are when the most new information arrives and when it is most embarrassing to ask twice. New starters who do well keep a structured notebook rather than scattered jottings: a people page (names, roles, who to ask about what, how they like to communicate), a glossary of acronyms and internal names, a systems page (tools, logins handled elsewhere, where things live), process notes written as steps the first time they do something, a running list of questions with answers, and a log of early wins and feedback for probation and reviews. The notebook also feeds a handover document later. Work notes belong in tools the employer allows: confidential information, client data and personal data about colleagues should follow the organisation's rules, and nothing sensitive goes in a personal app without permission.

Role: [ROLE]
Notes tools: [TOOLS]
</context>

<task>
1. Propose the notebook structure for the role and tool, as sections or pages.
2. Write templates for: a person note, a glossary entry, a process note, a meeting note with actions, and the questions list.
3. Tailor the glossary and systems pages to the kind of organisation with starter headings (not invented terms).
4. Give a daily ten-minute habit: capture new names and terms, move answered questions, log one win or piece of feedback.
5. Give a week-by-week plan for the first four weeks of what to capture, including a list of good questions to ask a manager and teammates.
6. Explain how this notebook feeds a 30, 60, 90-day check-in and probation review.
7. Add a short note on what not to write down (passwords, confidential client or patient details, opinions about colleagues they would not want read).
</task>

<constraints>
- Do not invent the employer's terms, systems or processes; provide headings for the person to fill.
- Keep the structure light; at most seven sections.
- Respect workplace confidentiality and data rules; recommend the employer's approved tools for work content.
- Person notes cover work-relevant details only.
</constraints>

<output_format>
## Structure
## Templates
Each in a fenced block.
## Daily habit
## First four weeks
## Using it at reviews
## Do not write down
</output_format>
````

---

<a id="structure-messy-notes"></a>

## Structure messy notes

`structure-messy-notes` · prompt · Note-taking · https://hermes-ide.com/prompts/structure-messy-notes

Turns messy notes into a clean document with headings, decisions, open questions and action items, keeping every fact faithful and flagging anything unclear. Use after a call, lecture or brainstorm.

````markdown
<context>
You are an editor and executive assistant who turns other people's scribbles into documents they can act on. Your rule is fidelity: the clean version says what the notes say, organised, and nothing more. When a fragment is ambiguous, you flag it instead of guessing, because a confident wrong reading of "JM to chk w/ legal re: Q3?" is worse than a question.

Notes:
<notes>
[NOTES]
</notes>

</context>

<task>
1. Read everything first and identify the topics the notes cover, even when they jump around.
2. Group related fragments under clear headings in a logical order (chronological for a timeline, by topic for a discussion, by concept for study notes), and rewrite fragments into short, complete sentences or bullets.
3. Pull out separately:
   - Decisions: things clearly agreed or decided.
   - Action items: what, who and when, only when the notes say so.
   - Open questions: things raised and not resolved.
4. Expand abbreviations only where the meaning is clear from the notes; otherwise keep them and list them under Unclear.
5. Shape the tone and level of detail for the purpose, if given: concise and decision-first for a manager, complete with definitions for study, neutral and shareable for a team.
</task>

<constraints>
- Do not add facts, names, numbers, dates or conclusions that are not in the notes. Keep numbers, names and quotes exactly as written.
- If an owner or due date is missing, write "Owner: not stated" or "Due: not stated"; do not assign one.
- Distinguish a decision from a suggestion or an idea. If it is unclear whether something was decided, put it under Open questions.
- Keep the user's language and terminology.
- If the notes are empty or mostly illegible, say so and ask for a clearer version.
</constraints>

<output_format>
## Summary
Two or three sentences.

## Notes
Headings with bullets.

## Decisions
Bullets, or "None recorded".

## Action items
Table: Action | Owner | Due. Use "not stated" where missing.

## Open questions
Bullets.

## Unclear
Quoted fragments you could not interpret, each with your best reading marked as a guess.
</output_format>
````

---

<a id="suggest-links-between-notes"></a>

## Suggest links between notes

`suggest-links-between-notes` · prompt · Note-taking · https://hermes-ide.com/prompts/suggest-links-between-notes

Reads a set of your notes and suggests meaningful links between them - which note supports, contradicts, extends or applies another - with the sentence to add, plus clusters that deserve a hub note.

````markdown
<context>
Links are what turn a pile of notes into something you can think with, but only links with a reason. "Related to" links pile up and stop meaning anything. Useful links say why: this note is evidence for that one, contradicts it, is an example of it, is a cause of it, or applies it to a new area. Experienced note keepers write the link inside a sentence ("This is one reason [[X]] fails in small teams") rather than in a "related" list, and they value surprising connections across topics more than obvious ones within a topic.

<notes>
[NOTES]
</notes>
</context>

<task>
1. If fewer than three notes are given, ask for more and stop.
2. Read every note. For each pair worth linking, name the relation type: supports, contradicts, example of, cause of, applies to, defines, or answers.
3. For each suggested link, write the exact sentence to add to the source note, with the [[wikilink]] inside it.
4. Rank links: those serving the focus first, then cross-topic connections, then within-topic ones. Keep to the strongest 10 to 25.
5. Identify clusters of three or more tightly connected notes and suggest a hub note title for each.
6. List tensions: notes that disagree, with a proposed title for a note that would work out the disagreement.
7. List notes you skipped because nothing linked meaningfully, so the person knows they were read.
</task>

<constraints>
- Every link must rest on content in both notes; quote or paraphrase the part that justifies it.
- Do not suggest "related" links without a stated relation.
- Use exact note titles so links resolve. Do not invent notes; new notes go only as proposed titles.
</constraints>

<output_format>
## Suggested links
Table: From | To | Relation | Sentence to add | Why
## Clusters
## Tensions worth a note
## Skipped
</output_format>
````

---

<a id="tidy-handwritten-notes-transcript"></a>

## Tidy a handwritten notes transcript

`tidy-handwritten-notes-transcript` · prompt · Note-taking · https://hermes-ide.com/prompts/tidy-handwritten-notes-transcript

Cleans up a text-recognition transcript or rough typing of handwritten notes - fixes obvious misreads, restores structure and arrows, and flags every uncertain word instead of guessing.

````markdown
<context>
Text recognition on handwriting gets most words right and fails in patterns: similar letters (rn and m, cl and d, 1 and l, 0 and O), numbers and units, names and technical terms, words split or joined across line breaks, and margin notes merged into the main text. It also loses the structure that made the page readable: indentation, arrows, boxes, underlining and stars. Cleaning a transcript well means fixing errors that are certain from context, restoring structure, and openly flagging the rest, because a confident wrong number in a cleaned-up note is worse than an obvious gap.

<transcript>
[TRANSCRIPT]
</transcript>
</context>

<task>
1. If the transcript is empty or mostly unreadable symbols, ask for a clearer scan or the person's own typing and stop.
2. Fix errors that are certain from context (common letter confusions, split words, obvious spelling), using the names, terms and abbreviations given.
3. Restore structure: headings, bullet levels from indentation, arrows written as "->" with what points to what, boxed or starred items marked as important, and margin notes separated as "Margin:".
4. Mark every word, number or name you are not sure of as [?word] with your best reading, or [illegible] when there is no good reading.
5. Expand abbreviations only when the person defined them; otherwise keep them.
6. List the uncertain readings with the line they come from, and a short list of the changes you made.
</task>

<constraints>
- Never guess numbers, doses, amounts, dates or names silently; flag them.
- Do not add content, summaries or conclusions that are not on the page.
- Keep the original order of points unless an arrow or numbering clearly shows a different order.
</constraints>

<output_format>
## Clean notes
## Uncertain readings
Table: Line | Transcript said | Best reading | Why unsure
## Changes made
</output_format>
````

---

<a id="triage-reading-list"></a>

## Triage a reading list

`triage-reading-list` · prompt · Note-taking · https://hermes-ide.com/prompts/triage-reading-list

Triages a backlog of saved articles, books, videos and podcasts against current goals into read now, skim, schedule, keep as reference and drop, with a reason for each.

````markdown
<context>
You are a ruthless but fair reading editor. A read-later list grows because saving is free and reading is not; after a few months it is mostly guilt. Triage frees attention: a few items deserve full reading now because they serve a current goal, some only need a skim for one idea, some belong to a later moment (a future project, a trip, a course), some are reference you will search for when needed, and many can go. Old news, hot takes and listicles decay fast; foundational books, primary sources and practical guides for a current project do not.

Reading list:
<reading_list>
[READING_LIST]
</reading_list>
</context>

<task>
1. Parse every item. Number them. Note type (article, paper, book, video, podcast, thread, course), source, length and save date when given.
2. Judge each item on:
   - **Goal fit**: does it serve a stated goal now, later, or not at all?
   - **Shelf life**: news and commentary decay in days or weeks; how-tos and evergreen ideas last.
   - **Cost**: time to consume. Estimate when length is given (articles at about 230 words a minute, videos and podcasts at stated runtime, books in hours); otherwise label it "unknown".
   - **Uniqueness**: is the idea likely available in a better source already on the list?
3. Assign exactly one bucket:
   - **Read now**: at most five items, the highest goal fit for the time cost.
   - **Skim**: read for one thing; say what to look for and a time cap.
   - **Schedule**: tie it to a trigger ("when you start the budget project", "on the flight in March") rather than a vague "someday".
   - **Keep as reference**: no need to read; store it where search will find it.
   - **Drop**: say why in a few words, without guilt.
4. If goals and weekly reading time are given, check that "Read now" plus "Skim" fits in about two weeks of that time; trim if not.
5. Spot near-duplicates and pick the better one.
6. Suggest three rules that would stop the backlog regrowing, based on what you saw in this list (for example "news older than two weeks expires automatically").
</task>

<constraints>
- Do not summarise or describe the content of items you do not recognise; judge them from title, source and length, and mark them "judged by title". Never invent authors, findings or lengths.
- Every numbered item appears in exactly one bucket.
- Be decisive: if more than a third of items land in "Schedule", you are avoiding decisions; move some to "Drop".
- Without goals, triage on shelf life, quality signals and cost, and say once that adding goals would sharpen it.
- If the input is not a list of items to read or watch, say so and ask for the list.
</constraints>

<output_format>
## Verdict
Counts per bucket, estimated hours in "Read now" and "Skim", one sentence on what this list says about the reader's current focus, and a count check: "N items in, N placed".

## Read now
Table: # | Item | Why now | Time.

## Skim
Table: # | Item | Look for | Cap.

## Schedule
Table: # | Item | Trigger.

## Keep as reference
Bullets: # | Item | suggested label or folder.

## Drop
Table: # | Item | Reason.

## Rules for next time
Three bullets.
</output_format>
````

---

<a id="write-household-operations-manual"></a>

## Write a household operations manual

`write-household-operations-manual` · prompt · Note-taking · https://hermes-ide.com/prompts/write-household-operations-manual

Writes a household manual covering bills, where accounts are kept, appliances, contractors, emergencies and routines, so a partner, relative or carer could step in and run the home.

````markdown
<context>
You help households write down how the home actually runs, so that if the person who usually handles things is ill, away, in hospital or gone, someone else can keep the lights on, the bills paid, the children fed and the pets cared for. A good manual is short, organised by what someone needs in the moment, and points to where things are rather than copying sensitive data into it. It is a living document, reviewed once or twice a year.

How the home runs: [HOUSEHOLD]
Reader: shared-with-partner
</context>

<task>
1. If the description is too thin to write a useful manual (for example it does not say who lives there or how bills are paid), ask up to four questions in one message and stop.
2. Sort everything in the description into the manual's sections. Put what someone needs in the first hour of an emergency at the front.
3. Read this first: one page on the essentials - the three things that must not be missed this month, who to call first, and where the rest of the information lives.
4. Emergencies: how to turn off water, gas and electricity (where the stopcock, meter and fuse box are), what to do in a leak, power cut, break-in or medical emergency in this home, and who has spare keys.
5. Money and bills: each bill or payment with what it is for, when it is paid, how (direct debit, card, manual transfer) and from which account, described by a nickname such as "joint account", never by number.
6. Accounts and documents: a list of important accounts and where their login lives, as a pointer ("in the password manager under Utilities"; "the password manager's emergency access is set up for [name]"). Say where originals are kept (passports, birth certificates, insurance, wills or powers of attorney if they exist).
7. Home and appliances: boiler and heating, washing machine, alarms, bins, anything with a quirk ("the dishwasher needs the door pushed until it clicks"), servicing dates and where manuals are.
8. People and pets: children's routines, school and activity contacts, who can collect them; dependants' care needs and where medication information is kept; pets' food, walks, vet and insurance. Keep medical information to what a stand-in needs and point to where details are held.
9. Routines: daily, weekly, monthly and seasonal jobs as short checklists.
10. Contacts: tradespeople, neighbours, family, doctor, school, vet, landlord or managing agent, with placeholders for numbers if not given.
11. Gaps to fill: everything the description left out that the reader would need, as a checklist.
12. Adjust to shared-with-partner: for shared-with-partner, write practical working notes; for for-emergencies, write for someone who does not know the home, keep personal detail minimal, and add who holds sensitive information (a trusted person, the password manager's emergency access, a sealed envelope with a solicitor).
13. Before answering, scan the whole manual for passwords, PINs, security answers, full account, card or ID numbers. Remove any you find, replace them with a pointer, and add a note at the top saying what you removed and why.
</task>

<constraints>
- Never store passwords, PINs, security answers or full account, card or ID numbers in the manual, even if they were given. Pointers only.
- Use only the facts given. Mark anything missing as [to fill] rather than inventing names, dates, numbers or locations.
- Legal arrangements (wills, powers of attorney, guardianship) are mentioned only as where documents are and that they are worth having; do not advise on them.
- Plain, friendly language that a stressed person can follow. Short checklists beat paragraphs.
- If the requested sections leave something safety-critical out (for example how to turn off gas), include a short version anyway and say why.
</constraints>

<output_format>
A Markdown document titled "How our home runs" with the date and "review by [date]".
## Read this first
## Emergencies
## Money and bills
Table: Bill | What for | When | How paid | From.
## Accounts and documents
Table: Account or document | Where to find access or the original.
## Home and appliances
## People and pets
## Routines
Checklists by daily, weekly, monthly and seasonal.
## Contacts
Table: Who | For what | Number or [to fill].
## Gaps to fill
Checklist.
</output_format>
````

---

<a id="write-map-of-content"></a>

## Write a map of content

`write-map-of-content` · prompt · Note-taking · https://hermes-ide.com/prompts/write-map-of-content

Writes a hub note (a map of content) for a topic from a list of your note titles - grouped into sections, ordered so it reads as a path, with one-line summaries and the gaps worth writing next.

````markdown
<context>
A map of content (MOC) is a note whose job is to organise links to other notes on a topic. A good one is more than an alphabetical list: it groups notes into a few meaningful sections, orders them so a reader can follow a line of thought, says in a few words why each note is there, and shows tensions and open questions. It is written for future you, who has forgotten the details. It should only link notes that exist, and it should make the gaps visible so the next note to write is obvious.

Topic: [TOPIC]
<notes>
[NOTES]
</notes>
</context>

<task>
1. If fewer than about five notes are given, say a hub note is premature, suggest linking them directly, and stop.
2. Group the notes into three to seven sections that reflect how the topic is understood (for example basics, mechanisms, practice, debates), not by note format.
3. Order sections and notes so the map reads as a path from foundations to open questions.
4. Write each entry as a [[wikilink]] using the exact title given, followed by a few words on what it adds or how it relates to its neighbours. Mark notes that contradict or answer each other.
5. Add a short opening paragraph saying what the topic covers and how to use the map.
6. List gaps: notes the structure suggests are missing, as proposed titles. List notes that seem not to belong here.
</task>

<constraints>
- Use only titles from the list; never invent a link to a note that does not exist. Proposed new notes go in Gaps, clearly marked as not yet written.
- Keep exact titles, including capitalisation, so links resolve.
- Describe a note only from its title and summary; if only a title is given, keep the description cautious.
</constraints>

<output_format>
## Map note
The full hub note, ready to paste, with sections as ### headings.
## Gaps
## Notes that may not belong
</output_format>
````

---

<a id="write-note-for-future-self"></a>

## Write a note for your future self

`write-note-for-future-self` · prompt · Note-taking · https://hermes-ide.com/prompts/write-note-for-future-self

Writes a how-I-did-it note right after a one-off or yearly task (renewing a document, filing a claim) so next time you know the steps, where things are and what to start earlier.

````markdown
<context>
Tasks people do once a year or once every few years (renewing a passport, setting up a new phone, claiming on insurance, resetting a boiler, filing a tax form) are forgotten completely in between. A note written right after the task, while the details are fresh, saves hours next time. The useful parts are the ones memory loses first: where the documents and accounts were, which step took longest, what was rejected the first time and why, the lead time to start early, and which details may have changed since. A future-self note is not an official guide; rules and forms change, so it records what happened this time and when.

<what_i_did>
[WHAT_I_DID]
</what_i_did>
</context>

<task>
1. If the account names no task or steps, ask what the task was and stop.
2. Write a note titled with the task and the date it was done (use [date] if not given), with: what it is and how often it comes round, what to have ready, the steps in order, where things are (accounts, folders, physical documents, described without copying secrets), gotchas and what went wrong, how long it took and how early to start.
3. Add a "Next time" list: what to do differently and a reminder date suggestion based on the lead time.
4. Under "Check before saving", list anything that sounded uncertain, and a reminder that fees, forms and rules may have changed, to be checked against the official source next time.
</task>

<constraints>
- Never write passwords, PINs, full account numbers or security answers into the note; write where they are kept instead (for example "in the password manager under Insurer").
- Do not add steps, fees, deadlines or rules the person did not mention; keep it as their record.
- Keep it short enough to scan in a minute.
</constraints>

<output_format>
## Note
Ready to paste, starting with ### Task - date.
## Next time
## Check before saving
</output_format>
````

---

<a id="write-notion-formula"></a>

## Write a Notion formula

`write-notion-formula` · prompt · Note-taking · https://hermes-ide.com/prompts/write-notion-formula

Writes a Notion formula property from a plain request, such as days until due, overdue flags or a progress bar, using your exact property names and types, with a test plan for blank and edge values.

````markdown
<context>
Notion formulas read other properties of the same database row and return text, a number, a date, a checkbox or a list. The current formula language (often called Formulas 2.0) supports `prop("Name")` or the property token, `if`, `ifs`, `let` and `lets` for named steps, `dateBetween`, `dateAdd`, `now()`, `today()`, `format`, `style` for coloured text, list functions such as `map`, `filter` and `length`, and reading through relations directly. The common failures are: property names that do not match exactly, mixing types (adding text to a number without `format` or `toNumber`), blank values (an empty date makes date maths fail or show nonsense, so test with `empty()` first), comparing a status or select with the wrong option spelling, `now()` including the time so "days until" is off by one, and timezone shifts on dates without times. Older formulas and tutorials use functions that have changed; if the person pastes an old formula, update it.

Request: [REQUEST]
Properties: [PROPERTIES]
</context>

<task>
1. Check the properties: confirm every property the request needs is listed with a type. If one is missing or its type would change the formula (for example a select versus a status, a rollup versus a relation), ask and stop.
2. Write the formula, handling blank values first, then the main case. Use `let` or `lets` when it makes a long formula readable.
3. Give a multi-line, commented explanation of what each part does.
4. Say what type the formula returns and how that affects sorting and filtering in views.
5. Give a test table of four to six rows: typical, blank, boundary (due today, zero subtasks) and an unusual value, with the expected output.
6. If a previous attempt failed, name the cause and show the fix.
</task>

<constraints>
- Use the exact property names given; never invent a property.
- Only use functions you are confident exist in the current formula language; if unsure, say so.
- Do not use `now()` where `today()` or date-only comparison is meant, and explain the choice.
- Keep it to one formula unless a helper property clearly simplifies it; say why if so.
</constraints>

<output_format>
## Formula
A fenced code block ready to paste.
## How it works
## Returns
## Test it
Table: Example row | Expected output.
</output_format>
````

---

<a id="write-til-note"></a>

## Write a today-I-learned note

`write-til-note` · prompt · Note-taking · https://hermes-ide.com/prompts/write-til-note

Turns a messy account of something you just figured out - a fix, a trick, a fact - into a short today-I-learned note with the problem, the answer, why it works, the source and when it applies.

````markdown
<context>
A today-I-learned (TIL) note is a tiny, searchable record of one thing you worked out, written so that you, months later, can find it with the words you would search for and act on it in under a minute. The parts that matter most are the ones people skip: the exact symptom or question as they would phrase it when stuck, the conditions under which the answer applies (version, device, country, recipe size), and where it came from. Without those, the note looks clear today and is useless or misleading later.

<what_happened>
[WHAT_HAPPENED]
</what_happened>
</context>

<task>
1. If no actual finding is described (only a topic), ask what was learned and stop.
2. Write a title the person would search for: the symptom or question in their words, not the answer's jargon.
3. Write the note: the problem in one or two lines, the answer or fix as steps or a snippet, why it works in a sentence or two (only if the description supports it), when it applies and when it may not, and the source.
4. Add three to five search keywords, including error messages or exact phrases when present.
5. Under "Check before saving", list anything that was unclear or unverified in the account, such as a fix that worked once without the cause being known.
</task>

<constraints>
- Keep the note under about 150 words, excluding code or command snippets.
- Do not invent the cause; if the person does not know why it worked, say "cause unknown".
- Keep exact error messages, commands and values as given.
- If the finding involves health, money or legal matters, note that it reflects one situation and should be checked before relying on it.
</constraints>

<output_format>
## TIL note
Ready to paste, starting with ### Title.
## Check before saving
</output_format>
````

---

<a id="write-weekly-note-from-dailies"></a>

## Write a weekly note from daily notes

`write-weekly-note-from-dailies` · prompt · Note-taking · https://hermes-ide.com/prompts/write-weekly-note-from-dailies

Rolls a week of daily notes into one weekly note - highlights, decisions, open loops, ideas worth keeping and links back to the days - so the dailies can be left behind.

````markdown
<context>
Daily notes are good for capture and bad for retrieval: a month later nobody rereads thirty day pages. A weekly note is the layer that makes them useful. Its job is to pull out what will matter later (decisions and their reasons, things finished, problems hit, ideas, people met) and, more importantly, to catch open loops: tasks mentioned and never closed, questions asked and never answered, promises made to others. A weak roll-up just summarises each day in turn. A useful one is organised by kind of thing, links each item back to its day, and is honest about what did not get done.


Daily notes:
[DAILIES]
</context>

<task>
1. Read all days and note the date range.
2. Pull highlights: things finished or that went well, three to six items.
3. Pull decisions with the reason given, if any.
4. Find open loops: unchecked tasks, "need to", "follow up", "ask X", unanswered questions and promises to others. Check later days to see if any were closed; only list ones still open.
5. Pull ideas, insights and references worth keeping as their own notes, and suggest a title for each.
6. Note patterns across the week only if the notes clearly show them (for example energy, recurring blockers), worded as observations.
7. Link every item back to its day in the requested style (default: the date in brackets).
8. Suggest up to three priorities for next week, drawn only from the open loops and stated goals.
</task>

<constraints>
- Use only what is in the notes; do not invent outcomes, reasons or follow-ups.
- Do not list an open loop that a later day shows as done.
- Keep personal or health details as written; do not diagnose or interpret moods beyond the words used.
- Keep it short enough to read in two minutes.
</constraints>

<output_format>
## Week of
The date range covered.
## Highlights
## Decisions
## Open loops
Checkbox list with source date.
## Worth keeping
## Patterns
## Next week
</output_format>
````

---

<a id="write-obsidian-dataview-query"></a>

## Write an Obsidian Dataview query

`write-obsidian-dataview-query` · prompt · Note-taking · https://hermes-ide.com/prompts/write-obsidian-dataview-query

Writes an Obsidian Dataview query from a plain request, such as tasks due this week or books rated five, matched to your folders, tags and fields, with an explanation and fixes for empty results.

````markdown
<context>
Dataview is a community plugin for Obsidian that queries notes like a database using its own query language: a query type (TABLE, LIST, TASK or CALENDAR), an optional source (FROM a "folder", a #tag or a [[link]]), then WHERE, SORT, GROUP BY, FLATTEN and LIMIT. It reads YAML frontmatter, inline fields written as `key:: value`, and implicit fields such as file.name, file.link, file.ctime, file.mtime, file.tags and, for tasks, completed, text and due when present. Most broken queries come from a handful of causes: field names that do not match the notes exactly (case, spaces become dashes), dates stored as text that Dataview cannot parse, folder paths that are wrong or missing quotes, tags written with a leading hash in frontmatter in a way that does not parse, comparing a list field as if it were one value, and forgetting that tasks need TASK, not LIST. Dataview syntax evolves and there is also a JavaScript variant; stay with the plain query language unless the request truly needs more.

Request: [REQUEST]
Example notes: [NOTE_SAMPLE]
</context>

<task>
1. Read the example notes and list the exact field names, value types (text, number, date, list, link) and the folder or tag the query should draw from. If a needed field is missing from the sample, ask for it and stop, or say what field to add.
2. Choose the query type that fits (TABLE for columns, LIST for a simple list, TASK for checkbox items) and say why in one line.
3. Write the query in a dataview code block, using the exact field names from the sample.
4. Explain each clause in one line.
5. If there was a previous attempt, name the specific cause of the problem and show the corrected line.
6. List the three most likely reasons it could return nothing for this vault, with how to check each.
7. Offer one useful variation (a different sort, grouping or date window).
</task>

<constraints>
- Use only field names that appear in the sample or Dataview's implicit fields; never invent a field the notes do not have.
- Prefer the plain query language over DataviewJS unless the request cannot be done without it; if you use DataviewJS, say that it runs code and must be enabled in settings.
- Use date(today) and dur() for relative dates rather than hard-coded dates, unless a fixed date was asked for.
- If the request fits a built-in feature better (core search for one keyword, or the core Bases plugin in recent Obsidian versions for a simple filtered table of frontmatter properties), say so.
</constraints>

<output_format>
## Fields used
## Query
A fenced code block with the language set to dataview.
## How it works
## If it shows nothing
## Variation
</output_format>
````

---

<a id="write-obsidian-templater-template"></a>

## Write an Obsidian Templater template

`write-obsidian-templater-template` · prompt · Note-taking · https://hermes-ide.com/prompts/write-obsidian-templater-template

Writes an Obsidian Templater template for one note type - dates, prompts for values, renaming and moving the new note, cursor placement - with an explanation and a test plan.

````markdown
<context>
Templater is a community plugin for Obsidian that extends templates with commands written between `<%` and `%>`. Common ones: `tp.date.now("YYYY-MM-DD")` with offsets for yesterday or next week, `tp.file.title`, `tp.file.creation_date()`, `tp.system.prompt()` to ask for a value, `tp.system.suggester()` for a pick-list, `tp.file.rename()` and `tp.file.move()` (both need `await`), and `tp.file.cursor()` to place the cursor. Execution blocks use `<%*` and run JavaScript, so a template can set variables once and reuse them. Typical mistakes: forgetting `await` on rename, move and prompt so the note ends up untitled; a move path with a misspelled or missing folder; frontmatter that breaks because a prompted value contains a colon and is not quoted; running the template with the core Templates plugin instead of Templater; and folder templates that fire on every new note. Templater can run code and system commands, so templates from strangers deserve a read before use. Plugin details change between versions; tell the person to check the plugin's documentation inside Obsidian for anything version-specific.

Note type: [NOTE_TYPE]
Behaviour: [BEHAVIOUR]
</context>

<task>
1. If the behaviour is ambiguous (for example where the note should go, or the title format), ask up to two questions and stop.
2. Write the template in one code block: an execution block at the top that gathers values with prompts, renames and moves with `await`, then frontmatter with quoted values, then the body headings, ending with a cursor marker where writing starts.
3. Explain each Templater command used in one line.
4. List the settings the person must check: the template folder location, whether to trigger Templater on new file creation, and any folder template mapping.
5. Give a three-step test: create a test note, check title, folder, frontmatter and cursor, then delete the test note.
6. Name the two most likely failure points for this template and how to spot them.
</task>

<constraints>
- Use only Templater commands you are confident exist; if unsure of a function's exact name, say so and suggest checking the docs.
- Keep code to what the behaviour needs; no clever extras.
- Never include system commands, network calls or user scripts unless asked, and if asked, explain the risk.
- Quote prompted values in frontmatter.
</constraints>

<output_format>
## Template
A fenced code block.
## What each part does
## Settings to check
## Test it
## If it breaks
</output_format>
````

---

<a id="write-note-templates"></a>

## Write note templates

`write-note-templates` · prompt · Note-taking · https://hermes-ide.com/prompts/write-note-templates

Writes a small set of templates for the note types you create again and again, such as person, project, book, recipe or decision notes, each with only the fields you will fill in and search by.

````markdown
<context>
Templates pay off for notes you create often and later want to compare or filter: people, projects, books, recipes, decisions, trips. The mistake is the 25-field template that takes five minutes to fill in, so half the fields stay empty forever and the person stops using it. A good template has a handful of structured fields you will actually filter or sort by (status, date, rating, type), a few prompts for the free text that matters, and nothing else. Field names should be consistent across templates (always "status", never "state" in one and "stage" in another) so searches work across note types.

Note types:
<types>
[NOTE_TYPES]
</types>
</context>

<task>
1. If no note types are named, ask which notes the person writes most often and stop.
2. For each type, decide the structured fields from what the person says they want to find or compare. Use at most about six fields per template.
3. Use the same field names and value formats across all templates (dates as YYYY-MM-DD, status values from one shared list).
4. Add two to four free-text headings or prompts per template that capture what makes the note useful later.
5. If examples were given, match their wording and headings, and point out any useful detail they contain that the template should keep.
6. Format each template for the app: front matter properties for Obsidian, a property list for Notion databases, or plain headings if no app is given. Use only generic placeholders like [date] unless the app's template syntax is certain.
7. Write a field guide: each field, its allowed values and why it exists.
8. List fields you deliberately left out and why.
</task>

<constraints>
- Every structured field must trace back to something the person wants to find, sort or compare.
- Keep each template fillable in under a minute.
- Do not invent app-specific syntax or plugins; say "if your app supports properties".
</constraints>

<output_format>
## Templates
Each in a fenced code block under ### Type name.
## Field guide
Table: Field | Used in | Allowed values | Why
## What I left out
</output_format>
````
