--- mw_bundle: 1 type: hub_digest slug: memorywiki-demo author: "Ron" url: https://memory.wiki/hub/memorywiki-demo concept_count: 40 updated: 2026-06-24T08:09:16.729Z source: "memory.wiki" --- # Ron's knowledge — concept digest > A polished demo hub showing what Memory.Wiki can hold — research, engineering notes, reading log, project planning. Paste any URL into Claude or ChatGPT to see the cross-AI payload. _40 concepts extracted across this hub. Each entry links to the supporting documents — fetch any of them as `https://memory.wiki/raw/?compact=1` for the dense full text._ ## Concepts ### Long-context models *concept • weight 111 • 6 docs* > Core idea enabling retrieval-optional UX by keeping broader context in view. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Supabase RLS patterns I keep copy-pasting](https://memory.wiki/8512f1485e0c) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. - [A note to my future self](https://memory.wiki/06c21d15e0e5) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. _Related:_ makes optional → **Retrieval problem** · fundamentally changes → **Retrieval calculus** · reframes fundamentally → **Retrieval problem** · utilizes as context → **Memory.Wiki** · make optional → **Retrieval problem** ### Cross-AI portability *concept • weight 105 • 6 docs* > Portability across AI vendors enabled by public URLs that survive pivots. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [What "agentic" actually means in 2026](https://memory.wiki/ceaa85095951) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. _Related:_ enables via → **Permalink primitive** · portability core → **Permalink primitive** · enabled by → **Memory.Wiki** · requires infrastructure of → **Permalink** · implemented via → **Permalink primitive** ### Memory.Wiki *entity • weight 95 • 6 docs* > Central knowledge hub system referenced across documents as the platform for saving thoughts, URLs, photos and grounding AI responses. - [Meeting with the legal team — context dump](https://memory.wiki/6045a1f67e69) The hardest part of a 1-person startup isn't the work — it's the lack of a forcing function. Without a meeting on Tuesday, nothing has to ship on Monday. The schedule has to come from somewhere, and "because I said so" isn't enough. - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. _Related:_ enables → **Cross-AI portability** · implements context grounding with → **Long-context models** · implements pattern of → **Output-heavy design** ### Interface IS the product *concept • weight 81 • 6 docs* > Engine is secondary; design consistency, micro-decisions, and UX determine product success more than underlying technology. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. _Related:_ one screen linkage → **One-screen rule** ### Claude *entity • weight 63 • 6 docs* > AI provider evaluated for long context and instruction-following strength, with weakness in tiny prompt latency. - [Travel notes: Seoul → Tokyo](https://memory.wiki/cd48bf42bf7c) Markdown won because it was always good enough. Not the best at any one thing — never the fastest editor, never the prettiest output, never the most semantically rich. But always close enough that the switching cost killed every alternative. - [Supabase RLS patterns I keep copy-pasting](https://memory.wiki/8512f1485e0c) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… _Related:_ exemplifies strength in → **Long-context models** · is an example of → **Long-context models** · compared with → **GPT-4o** ### GPT-4o *entity • weight 58 • 6 docs* > AI provider evaluated for multimodal and fast performance, with weakness in long-session drift. - [Travel notes: Seoul → Tokyo](https://memory.wiki/cd48bf42bf7c) Markdown won because it was always good enough. Not the best at any one thing — never the fastest editor, never the prettiest output, never the most semantically rich. But always close enough that the switching cost killed every alternative. - [Supabase RLS patterns I keep copy-pasting](https://memory.wiki/8512f1485e0c) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… _Related:_ is an example of → **Long-context models** · compared against → **Claude** · alternative for multimodal → **Long-context models** · trades off in → **Long-context models** ### OpenAI *entity • weight 56 • 6 docs* > AI vendor whose structural moat is challenged by cross-AI portability via permalinks - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… _Related:_ cannot own alone → **Cross-AI portability** · cannot build → **Cross-AI portability** ### Anthropic *entity • weight 55 • 6 docs* > AI vendor whose structural moat is challenged by cross-AI portability via permalinks - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… _Related:_ cannot own alone → **Cross-AI portability** · cannot build → **Cross-AI portability** ### Markdown *entity • weight 51 • 6 docs* > Format mentioned as a practical, sufficient baseline. - [Travel notes: Seoul → Tokyo](https://memory.wiki/cd48bf42bf7c) Markdown won because it was always good enough. Not the best at any one thing — never the fastest editor, never the prettiest output, never the most semantically rich. But always close enough that the switching cost killed every alternative. - [Meeting with the legal team — context dump](https://memory.wiki/6045a1f67e69) The hardest part of a 1-person startup isn't the work — it's the lack of a forcing function. Without a meeting on Tuesday, nothing has to ship on Monday. The schedule has to come from somewhere, and "because I said so" isn't enough. - [What "craftsman SaaS" means to me](https://memory.wiki/dcd0c184a7af) Craftsman SaaS prioritizes thoughtful details like comprehensive error messages and good-enough solutions that reduce friction, while solo founders must create artificial forcing functions to maintain shipping discipline without external accountability. - [JSON schema for a doc with attachments](https://memory.wiki/e7a714048331) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [URL → markdown conversion (server-side recipe)](https://memory.wiki/4b4d23da4045) Reading other people's code is a higher-leverage activity than writing your own. You learn three things at once: what works, what doesn't, and why someone smart picked the trade-off you'd never have considered. The ratio of read-to-write hours quietly separates the engineers who plateau from the one… - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. _Related:_ exemplifies principle of → **Cross-AI portability** ### Cursor *entity • weight 45 • 6 docs* > Code-aware editor with specialized ranking, locked to editor environment. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [JSON schema for a doc with attachments](https://memory.wiki/e7a714048331) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. _Related:_ integrates with → **Long-context models** ### Permalink primitive *concept • weight 44 • 6 docs* > Advocates permalinks as the right primitive for cross-AI portability rather than API keys. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… _Related:_ infra relationship → **Cross-AI portability** ### Branding consistency *concept • weight 38 • 6 docs* > Branding is the sum of micro-decisions and is central to product perception. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. _Related:_ branding drives ui → **Interface IS the product** ### Branding *tag • weight 37 • 6 docs* > Branding as a set of micro-decisions rather than a logo. - [Vercel function payload caps and how to ship around them](https://memory.wiki/08f9334428e9) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. ### Forcing function *concept • weight 36 • 6 docs* > A forcing function is essential for momentum in a 1-person startup. - [What "craftsman SaaS" means to me](https://memory.wiki/dcd0c184a7af) Craftsman SaaS prioritizes thoughtful details like comprehensive error messages and good-enough solutions that reduce friction, while solo founders must create artificial forcing functions to maintain shipping discipline without external accountability. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [JSON schema for a doc with attachments](https://memory.wiki/e7a714048331) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. ### Delivery model matters *concept • weight 35 • 6 docs* > Core thesis that how you deliver content matters more than how you retrieve it. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [JSON schema for a doc with attachments](https://memory.wiki/e7a714048331) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [URL → markdown conversion (server-side recipe)](https://memory.wiki/4b4d23da4045) Reading other people's code is a higher-leverage activity than writing your own. You learn three things at once: what works, what doesn't, and why someone smart picked the trade-off you'd never have considered. The ratio of read-to-write hours quietly separates the engineers who plateau from the one… ### Error message design *concept • weight 33 • 4 docs* > Example of product quality where most implementations skip the third critical element: actionable next steps. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [What "craftsman SaaS" means to me](https://memory.wiki/dcd0c184a7af) Craftsman SaaS prioritizes thoughtful details like comprehensive error messages and good-enough solutions that reduce friction, while solo founders must create artificial forcing functions to maintain shipping discipline without external accountability. - [JSON schema for a doc with attachments](https://memory.wiki/e7a714048331) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [URL → markdown conversion (server-side recipe)](https://memory.wiki/4b4d23da4045) Reading other people's code is a higher-leverage activity than writing your own. You learn three things at once: what works, what doesn't, and why someone smart picked the trade-off you'd never have considered. The ratio of read-to-write hours quietly separates the engineers who plateau from the one… ### Ship one feature deeply *concept • weight 32 • 6 docs* > Deliver a core feature thoroughly before expanding to multiple features. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [JSON schema for a doc with attachments](https://memory.wiki/e7a714048331) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. _Related:_ feature-before-ui → **Interface IS the product** ### Code reading leverage *concept • weight 27 • 3 docs* > Learning methodology that teaches what works, what fails, and trade-off rationale simultaneously. - [URL → markdown conversion (server-side recipe)](https://memory.wiki/4b4d23da4045) Reading other people's code is a higher-leverage activity than writing your own. You learn three things at once: what works, what doesn't, and why someone smart picked the trade-off you'd never have considered. The ratio of read-to-write hours quietly separates the engineers who plateau from the one… - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. _Related:_ reveals through example → **Error message design** ### SwiftUI *entity • weight 27 • 6 docs* > iOS framework used for implementing state-persistent tab navigation patterns. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [JSON schema for a doc with attachments](https://memory.wiki/e7a714048331) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. ### UX *tag • weight 27 • 6 docs* > User experience focus across documents. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [Reading: Karpathy on LLM evals](https://memory.wiki/c9e5203af6ee) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. ### Linear *entity • weight 26 • 6 docs* > Design system referenced as source of the 'easy default, hard possible' principle. - [URL → markdown conversion (server-side recipe)](https://memory.wiki/4b4d23da4045) Reading other people's code is a higher-leverage activity than writing your own. You learn three things at once: what works, what doesn't, and why someone smart picked the trade-off you'd never have considered. The ratio of read-to-write hours quietly separates the engineers who plateau from the one… - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The 30-second cache rule](https://memory.wiki/dc400be3d9c2) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. ### One-screen rule *concept • weight 23 • 6 docs* > Anything important should fit on one screen; a constraint that forces clarity and discourages feature bloat. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… ### Retrieval problem *concept • weight 23 • 4 docs* > The challenge of deciding what to fetch and how to surface relevant information. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [A note to my future self](https://memory.wiki/06c21d15e0e5) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. ### Delivery model *tag • weight 21 • 6 docs* > Category around how products are delivered. - [Travel notes: Seoul → Tokyo](https://memory.wiki/cd48bf42bf7c) Markdown won because it was always good enough. Not the best at any one thing — never the fastest editor, never the prettiest output, never the most semantically rich. But always close enough that the switching cost killed every alternative. - [URL → markdown conversion (server-side recipe)](https://memory.wiki/4b4d23da4045) Reading other people's code is a higher-leverage activity than writing your own. You learn three things at once: what works, what doesn't, and why someone smart picked the trade-off you'd never have considered. The ratio of read-to-write hours quietly separates the engineers who plateau from the one… - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… _Related:_ enabled by → **Cross-AI portability** · related → **Latency optimization** ### Permalink *tag • weight 21 • 6 docs* > Permalink as portability and context primitive. - [What "agentic" actually means in 2026](https://memory.wiki/ceaa85095951) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. _Related:_ implements as primitive → **Cross-AI portability** ### Long-Context UX *concept • weight 20 • 4 docs* > The shift from retrieval-based systems to presentation-based systems enabled by large context windows. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The 30-second cache rule](https://memory.wiki/dc400be3d9c2) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. _Related:_ enables better → **Output-Heavy Systems** ### Portability *tag • weight 19 • 6 docs* > Portability across AI vendors and contexts. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. ### Latency optimization *tag • weight 19 • 6 docs* > Performance targets and caching strategies for different surfaces (capture, open, search). - [Meeting with the legal team — context dump](https://memory.wiki/6045a1f67e69) The hardest part of a 1-person startup isn't the work — it's the lack of a forcing function. Without a meeting on Tuesday, nothing has to ship on Monday. The schedule has to come from somewhere, and "because I said so" isn't enough. - [URL → markdown conversion (server-side recipe)](https://memory.wiki/4b4d23da4045) Reading other people's code is a higher-leverage activity than writing your own. You learn three things at once: what works, what doesn't, and why someone smart picked the trade-off you'd never have considered. The ratio of read-to-write hours quietly separates the engineers who plateau from the one… - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. _Related:_ enables fast surfacing → **Output-heavy design** ### Delivery model matters more than retrieval quality *concept • weight 17 • 5 docs* > How information reaches user is more important than how well it was retrieved or ranked - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The 30-second cache rule](https://memory.wiki/dc400be3d9c2) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. ### Output-heavy design *concept • weight 17 • 4 docs* > The document's central thesis that knowledge systems create value through retrieval and surfacing, not just capture. - [Meeting with the legal team — context dump](https://memory.wiki/6045a1f67e69) The hardest part of a 1-person startup isn't the work — it's the lack of a forcing function. Without a meeting on Tuesday, nothing has to ship on Monday. The schedule has to come from somewhere, and "because I said so" isn't enough. - [Supabase RLS patterns I keep copy-pasting](https://memory.wiki/8512f1485e0c) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. - [A note to my future self](https://memory.wiki/06c21d15e0e5) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. ### Three rules *concept • weight 17 • 6 docs* > Core operating principles: ship deeply, interface is the product, fit on one screen. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [Reading: Karpathy on LLM evals](https://memory.wiki/c9e5203af6ee) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. ### Delivery model > retrieval quality *concept • weight 17 • 4 docs* > How context reaches the user matters more than how well it was retrieved; thesis from W6 internal note on Graph RAG. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The 30-second cache rule](https://memory.wiki/dc400be3d9c2) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. ### AI infrastructure *tag • weight 16 • 4 docs* > Domain of delivery models, context management, vendor selection, and long-context capabilities. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The 30-second cache rule](https://memory.wiki/dc400be3d9c2) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. ### Permalink infrastructure *concept • weight 16 • 5 docs* > Public URL as durable context that survives pivots. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The 30-second cache rule](https://memory.wiki/dc400be3d9c2) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. - [Reading: Karpathy on LLM evals](https://memory.wiki/c9e5203af6ee) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. ### Retrieval calculus *concept • weight 16 • 1 doc* > Framework for deciding what to fetch vs. what to surface from context. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. ### Output-Heavy Systems *concept • weight 16 • 6 docs* > Knowledge tools that prioritize surfacing information over capturing it. - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [What "agentic" actually means in 2026](https://memory.wiki/ceaa85095951) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The 30-second cache rule](https://memory.wiki/dc400be3d9c2) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. ### Permalink Portability *concept • weight 16 • 6 docs* > Using public URLs as the primary primitive for AI context to ensure vendor independence. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. ### Anything important should fit on one screen *concept • weight 16 • 6 docs* > Design constraint that forces clarity and prevents information overload - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. ### Capture-organize-use indispensability loop *concept • weight 16 • 4 docs* > Cycle where use drives back to capture, creating habit and system stickiness; feedback loop sustains engagement. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [The 30-second cache rule](https://memory.wiki/dc400be3d9c2) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. ## Concept relations _20 highest-weight edges between the top concepts._ - **Long-context models** makes optional **Retrieval problem** - **Claude** exemplifies strength in **Long-context models** - **Long-Context UX** enables better **Output-Heavy Systems** - **Cross-AI portability** enables via **Permalink primitive** - **Long-context models** fundamentally changes **Retrieval calculus** - **Cross-AI portability** portability core **Permalink primitive** - **Permalink** implements as primitive **Cross-AI portability** - **Long-context models** reframes fundamentally **Retrieval problem** - **Long-context models** utilizes as context **Memory.Wiki** - **Cross-AI portability** enabled by **Memory.Wiki** - **Memory.Wiki** enables **Cross-AI portability** - **Long-context models** make optional **Retrieval problem** - **Long-context models** transforms retrieval to **Output-heavy design** - **Cross-AI portability** requires infrastructure of **Permalink** - **Cross-AI portability** implemented via **Permalink primitive** - **Long-context models** fundamentally reshape **Retrieval calculus** - **Cross-AI portability** structural moat for **OpenAI** - **Cross-AI portability** structural moat for **Anthropic** - **Cross-AI portability** improves utility of **Personal-knowledge tools** - **Claude** is an example of **Long-context models** ## All documents _20 public documents, ordered by recency. Each entry includes a one-paragraph gist for quick scanning. Fetch any as `https://memory.wiki/raw/?compact=1` for the full body._ - [The Saturday review ritual](https://memory.wiki/05f33b574071) Personal-knowledge tools should optimize for output (surfacing relevant notes at the right moment) rather than input, and portability through public URLs rather than vendor-specific APIs is the structural advantage that ensures longevity. Reading others' code is higher-leverage than writing your own because it teaches what works, what doesn't, and the reasoning behind tradeoffs that accelerate learning. - [Why long-context models change the retrieval calculus](https://memory.wiki/5e4777a425dc) Long-context AI models shift the retrieval landscape because user context can now be exported as portable, public URLs that function as infrastructure independent of any single AI vendor, making the permalink rather than the API key the critical primitive. - [What "craftsman SaaS" means to me](https://memory.wiki/dcd0c184a7af) Craftsman SaaS prioritizes thoughtful details like comprehensive error messages and good-enough solutions that reduce friction, while solo founders must create artificial forcing functions to maintain shipping discipline without external accountability. - [What "agentic" actually means in 2026](https://memory.wiki/ceaa85095951) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [On-device OCR is good enough for most capture flows](https://memory.wiki/930f037e970c) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Reading: Karpathy on LLM evals](https://memory.wiki/c9e5203af6ee) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Vercel function payload caps and how to ship around them](https://memory.wiki/08f9334428e9) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [Skeleton placeholders are an underrated upgrade](https://memory.wiki/59d449cb1db1) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Why I stopped trusting silent catch blocks](https://memory.wiki/53356e4339a7) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [The 30-second cache rule](https://memory.wiki/dc400be3d9c2) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. - [The Pragmatic Programmer revisit](https://memory.wiki/38374b9d8f59) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [Reading log: October-November](https://memory.wiki/53bac621b960) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. - [Notes from Show Your Work](https://memory.wiki/7c265e654e4f) Branding is not the logo. It's the consistency of every micro-decision: button radius, copy voice, error tone, empty-state warmth. The logo just labels the bag. The branding is what's inside it. - [A note to my future self](https://memory.wiki/06c21d15e0e5) Most personal-knowledge tools optimise for input. The friction is on the way in: capture this thought, file it, tag it, link it. But the value lives on the way OUT — when the system surfaces the right note at the right moment without you asking. Capture-heavy products are easier to build; output-hea… - [URL → markdown conversion (server-side recipe)](https://memory.wiki/4b4d23da4045) Reading other people's code is a higher-leverage activity than writing your own. You learn three things at once: what works, what doesn't, and why someone smart picked the trade-off you'd never have considered. The ratio of read-to-write hours quietly separates the engineers who plateau from the one… - [Supabase RLS patterns I keep copy-pasting](https://memory.wiki/8512f1485e0c) Cross-AI portability is the structural moat OpenAI and Anthropic can't build for themselves. The user's context, exported as a public URL, becomes infrastructure that survives any single vendor's pivot. That's why the right primitive isn't an API key — it's a permalink. - [JSON schema for a doc with attachments](https://memory.wiki/e7a714048331) A good error message answers three questions: what happened, why it happened, and what to try next. Most ship the first, hint at the second, and forget the third. The fix is usually a single sentence longer. - [Meeting with the legal team — context dump](https://memory.wiki/6045a1f67e69) The hardest part of a 1-person startup isn't the work — it's the lack of a forcing function. Without a meeting on Tuesday, nothing has to ship on Monday. The schedule has to come from somewhere, and "because I said so" isn't enough. - [Travel notes: Seoul → Tokyo](https://memory.wiki/cd48bf42bf7c) Markdown won because it was always good enough. Not the best at any one thing — never the fastest editor, never the prettiest output, never the most semantically rich. But always close enough that the switching cost killed every alternative. - [Letter to a future hire](https://memory.wiki/e6c954035423) The interesting thing about long-context models isn't that they can read more — it's that they finally make the *retrieval* problem optional. When a model can hold the whole repo in context, the question shifts from "what should I fetch?" to "what should I show?". That's a UX question, not an infrastructure one. --- _Need everything? [Full hub index](https://memory.wiki/raw/hub/memorywiki-demo?compact=1) lists every public document. [llms.txt manifest](https://memory.wiki/hub/memorywiki-demo/llms.txt) explains how to crawl this hub._