RemNote

Promptfree, for everyone, and the only version there is

Copy the prompt for Claude CodeCopy the prompt for CodexCopy the prompt for Cursor

Copy

Build me notes with spaced repetition that replace RemNote: cards made out of the notes as I write them, and a scheduler that is not hand-rolled.

STACK
- Node 20+ with Fastify, server-rendered HTML with a little vanilla JS
- SQLite through better-sqlite3, WAL mode, with FTS5
- A PWA that works offline for the review sessions, which happen on a phone
- Caddy in front

THE ONE IDEA
- Making flashcards is a separate chore, and it is the step at which almost everybody gives up
- So the cards come out of the notes: you write an outline, and marking part of a line turns it into a card without leaving the document
- Everything below serves that. If a feature adds a step between writing and having a card, leave it out

THE DATA MODEL
- documents: id, title, parent_id, position, created_at, updated_at
- blocks: id, document_id, parent_id, position, content, kind, refs_json — the outline, one row per bullet
- cards: id, block_id, kind, front, back, cloze_index, created_at, suspended_at, buried_until — derived from a block and regenerated when it changes
- reviews: id, card_id, rating, reviewed_at, elapsed_ms, previous_interval_days, new_interval_days, stability, difficulty, state — append-only, and the whole basis of the scheduler
- decks: id, name, filter_json — a saved query, not a folder
- Card content is never stored separately from the block it came from. Editing the note updates the card and keeps its review history, which is precisely what a separate flashcard app cannot do

MAKING A CARD WHILE WRITING
- A line with a marker becomes a question and answer card: the text before it is the front, the text after is the back
- Cloze deletions inline: wrap part of a sentence and it becomes a card asking for that part, several per sentence, each scheduled independently
- A descriptor card from a term and its definition, in both directions if you want it
- Nested blocks become a list card, asking for the children of a parent
- The whole interaction is one keystroke. If it takes a dialogue, it will not be used

THE SCHEDULER
- Use a published, evaluated algorithm rather than inventing one. FSRS is the current best answer and it is free: it models stability and difficulty per card and schedules from them
- Store the parameters, and refit them from the review log once there are enough reviews — a scheduler tuned to your own memory is measurably better than default parameters
- Four ratings: again, hard, good, easy. Not two, not ten
- Interval caps, a daily new-card limit and a daily review limit, all configurable — the failure mode of spaced repetition is a backlog of nine hundred reviews on a Monday, and the limits are what prevent it
- Bury siblings: two cards from the same sentence should not appear in the same session
- Every review appended, never updated. The log is what lets you change scheduler and recompute

REVIEWING
- One card at a time, large, on a phone, offline
- Show the front, reveal, rate. Keyboard and touch both
- The source note reachable in one tap from any card, because half of remembering is context
- Session summary: how many, how long, and what is due tomorrow
- Undo the last rating, which is needed more often than you would think

WRITING
- An outliner: bullets, indentation, collapsing, drag to move
- Markdown, images, code, and links between documents by bracketed title
- Backlinks per document, resolved at save time
- Autosave with no save button
- Search across everything with FTS5, instant

DECKS AND QUEUES
- A deck is a filter over cards — by document, by tag, by state, by due date. Not a folder, so a card can be in several
- A cram mode that reviews without affecting scheduling, for the night before something
- Statistics: reviews per day, retention rate, workload forecast for the next month. The forecast is the number that keeps people from over-adding

SYNC AND ESCAPE
- Offline-first with a change feed ordered by a server counter, and conflicts kept rather than resolved
- Import from the common flashcard formats, preserving scheduling state where the format carries it
- Export everything: notes as Markdown, cards and their full review history as JSON and as a package the popular open tool can read. Years of review history is the most valuable thing here and must never be trapped

OPERATIONS
- .env: DATABASE_PATH, BASE_URL, SESSION_SECRET
- Migrations on boot, each once
- Nightly backup off the machine, restore script
- Health endpoint

WHAT MATTERS MOST
The one-keystroke card and using a real scheduler. Build those two, then use it yourself for a month — if making a card is not effortless, no scheduler saves the tool, and if the scheduler is homemade, the reviews will be at the wrong times and you will never know.

Give me the repository, the review PWA, migrations, .env.example, the scheduler with its tests, and a README with deploy steps behind Caddy and the algorithm named.