Knowledge Systems
AI Product Building52 insights in this topic
52 insights
Compound engineering makes each unit of work improve all future work
The 80/20 ratio (80% plan+review, 20% work+compound) ensures learning compounds across iterations, not just code
Persistent agent memory preserves institutional knowledge that walks out the door with employees
When agents maintain daily changelogs, decision logs, and work preferences, organizational knowledge survives personnel changes
Files are the universal interface between humans and agents
Markdown and YAML files on disk beat databases because agents already know file operations and humans can inspect everything
Similarity is not relevance — relevance requires reasoning
Vector search finds semantically similar content, but what users need is relevant content, and determining relevance requires LLM reasoning, not just pattern matching — across documents, code and skills, structure navigated by reasoning beats flat similarity search
Cross-user knowledge transfer works without fine-tuning — just a database and prompt engineering
When one person teaches an agent something, another person benefits automatically — no RLHF, no training infrastructure, just structured storage and retrieval; the same store of past errors and fixes lets an agent stop repeating its mistakes without retraining
Skill graphs enable progressive disclosure for complex domains
Single skill files hit a ceiling — complex domains need interconnected knowledge that agents navigate progressively from index to description to links to sections to full content
Spec files are external memory that survives context resets
A structured specs/ folder (design.md, implementation.md, decisions.md) bridges human intent and agent execution across sessions
Evolving summaries beat append-only memory — rewrite profiles, don't accumulate facts
An evolve_summary() function that rewrites category profiles with new information handles contradictions naturally, unlike append-only logs
When agents write the code, engineering moves into the harness — and documentation becomes the system of record
OpenAI built a million-line production codebase with zero manually-written code in 5 months. The discipline shifted from writing code to designing the harness: architecture constraints, documentation, tooling, and feedback loops that make agents reliable at scale.
Intelligence location — code vs prompts — determines system fragility and flexibility
Critical architectural fork: prompt-driven systems (Pal's 400-line routing prompt) are flexible but break when models change; code-driven systems (our validate-graph.js) are rigid but reliable — best systems need both, so decide for each step whether its computation belongs in the model (latent space) or in code (deterministic space)
Agents learn at three distinct layers — model weights, harness code, and context configuration
Most people jump to model fine-tuning when discussing agent learning, but learning also happens at the harness layer (code, tools, instructions baked into all instances) and the context layer (per-user or per-tenant configuration like CLAUDE.md and skills)
Building real projects teaches AI skills faster than following structured curricula
A non-technical user who built a production WhatsApp bot reached 'Operator' level that a 30-day AI mastery roadmap targets — through building, not studying
CLAUDE.md should be a routing table, not a knowledge base
Treat CLAUDE.md as a minimal IF-ELSE directory pointing to context files — not a 26,000-line monolith that bloats every session
You can offload a task, or even a job, but you can never offload your learning
The real opportunity isn't picking the best model — it's building a learning loop on top of models where the firm's accumulated learning, the one thing it can't outsource, compounds across people and AI
Session capture turns ephemeral AI conversations into a compounding knowledge base
shadcn's /done pattern — dumping key decisions, questions, and follow-ups to markdown after each Claude session — applies file-based memory architecture to development workflow
Treat an agent as an operating system, not a stateless function
Agents need RAM (conversation context), a hard drive (persistent memory), garbage collection (decay/pruning), and I/O management (tools) — the OS mental model unlocks architectural clarity
Personal AGI is an asset you build, not a subscription you rent
Tan's distinction: a rented assistant resets when you close the tab and improves only when its vendor ships, while an agent on your own infrastructure reading memory you own gets better every day you use it
Context centralization is why coding AI works — git is a solved context repository, knowledge work has no equivalent
Engineering AI leads because git centralizes all context in one versioned repository; knowledge work fails on three axes: distributed, unstructured, unverifiable
If an action left no artifact, it didn't happen — legibility is the precondition, not a nice-to-have
Blomfield's practical prescription: record and transcribe everything, ban Slack DMs if you cannot read them, and treat any action that produced no written or recorded trace as invisible to the company brain
Once skill files accumulate, provenance becomes the binding constraint
The agentic-company loop works until the markdown files pile up; at that point Tan locates the failure in provenance and conflict management — two facts disagree, and provenance decides which one wins, enforced by a job that continuously sweeps for accuracy
A better model makes your library worth more, not obsolete — a smarter reader extracts more from the same books
Tan's answer to the bitter-lesson objection: each model release is a free upgrade to a workforce you already own, because the differentiator moves toward context precisely as the weights commoditize
Accumulated agent traces produce emergent world models — discovered, not designed
When agent decision trajectories accumulate over time, they form a context graph that reveals entities, relationships, and constraints nobody explicitly modeled
Retrieval is the primitive, not the product — being worth retrieving from is the product
Tan's answer to 'isn't this just RAG': the hard part is what gets written down at all, how it is enriched and linked, what gets promoted to hot memory, and who arbitrates when two facts disagree
Context inefficiency compounds three penalties: cost, latency, and quality degradation
Every wasted token in an LLM context window doesn't just cost money — it slows responses and degrades output quality, creating a triple tax on production agents
Context learning spans agent, tenant, and org levels — and you can mix all three
Agent-level context updates the agent's own configuration over time; tenant-level (user/org/team) gives each tenant their own evolving context; production systems mix multiple levels simultaneously
Don't be the discriminator — be the patron, not the judge
Taste (selecting from AI output) is the function that gets automated first; participating in creation through friction and will is what endures
Knowledge evolution is the biggest unsolved problem across all graph architectures
Almost nobody has solved how knowledge graphs grow without rotting — most are append-only, auto-decay is too aggressive, and even the best systems only add links without pruning, merging, or detecting contradictions
Own your skill files, because if you don't, your job becomes a skill file
Tan's political thesis: a skill file is your cognition extracted and made executable, and the same 40 files are either a career that compounds or an extraction that outlives you — the only variable is whose repo they sit in
A loss curve is reassurance, not analysis — pull a hundred failures and read every one
Experiments throw off far more information than you consume — transcripts, failure cases, the strange tail — and most of it dies unread. Most ML bugs live in the data and fail silently; Ng's move is to pull 100 failures, sort them into piles, and attack the biggest pile
Tribal knowledge is the irreducible human input that enables agent automation
Automated context construction handles most of the corpus, but the most critical context is implicit, conditional, and historically contingent — only humans can provide it
Derive the manual from observed practice — written SOPs miss the edge cases people actually handle
YC mined thousands of hours of recorded office hours to rewrite a 15-year-old, 500-page user manual, turning a document that decays into one that updates itself when the advice changes
Shared inputs produce shared conclusions worth nothing — old and cross-disciplinary material is criminally underpriced
If your information diet is trending arxiv plus the group chat, you reach the same conclusions as everyone else at the same time, which makes them worthless. Old material (MoE 1991, LSTMs 1997, the bitter lesson) and cross-disciplinary range are underpriced sources of differentiated ideas
If a smart intern could follow it, an agent can run it — which makes clear English a programming language
Tan's test for whether a skill file is ready, and the claim behind it: markdown is code and the compiler is a language model, which is why non-engineers at YC are shipping automation
Knowledge systems need dual-layer storage — narrative depth and structured queries can't share a format
Every system beyond 'markdown files in a folder' discovers that narrative depth (rich prose, context, reasoning) and structured querying (filter, aggregate, cross-reference) need different storage layers with a routing mechanism between them
Memory is a harness responsibility, not a pluggable component
Managing context — what enters, what survives compaction, what's queryable — is a core capability of the harness itself, not an add-on service
Metadata consumed by LLMs needs trigger specifications, not human summaries
When an LLM scans metadata to decide what to invoke, the description should specify when to activate — not summarize what the thing does — because LLMs are a fundamentally different consumer than humans
Taste is a muscle, not a gift — train it by forecasting every result before you see it
Predict the outcome of every experiment before running it, guess a paper's numbers from the method alone, call which releases will matter in two years and check your hit rate; a forecast plus a correction, repeated a few hundred times, trains the model in your head the way it trains any other model
A clear public explanation is a genuine contribution and an unfakeable credential
Fields choke on undigested ideas, so distilling something hard into a clear explanation is real work, not a service job — and a body of public writing doubles as the strongest credential you can hold, because it's an unfakeable sample of how you think
Compilation scales but curation compounds — two camps for knowledge graph construction
LLM-compiled systems (Karpathy, Pal) grow fast by feeding raw content through model judgment; human-curated systems (our graph, brainctl) grow slowly but every node is validated — compilation scales linearly, curation compounds through connections
Context layers supersede semantic layers for agent autonomy
Traditional semantic layers handle metric definitions but agents need a superset: canonical entities, identity resolution, tribal knowledge instructions, and governance guidance
Embeddings measure similarity, not truth — vector databases have a temporal blind spot
Vector search can't resolve contradictions or understand time; 'I love my job' and 'I'm quitting' retrieve with equal confidence
If you can find the edge of a field, it isn't interesting enough
A test for problem selection offered in conversation and credited to Chris Dixon: ask whether you can locate the boundary of a subject, because for the genuinely interesting ones you cannot find the intellectual edge even after exhausting the conversational one
An agent is its memory — keep its prompts, skills and tools portable and the agent can move between harnesses
An agent IS its memory — a zip of markdown (system prompt + skills + tools) defines its identity; making that portable between harnesses is the current frontier
Navigation beats search for knowledge retrieval — let each data source keep its native query interface
Vector similarity search flattens everything into one embedding space, losing native query affordances; better to let SQL be SQL, files be files, and build a routing layer that picks the right source per question type
Tiered retrieval prevents context overload — summaries first, details on demand
Reading category summaries first, then drilling to items, then raw resources only if needed keeps memory retrieval within token budgets
A ubiquitous-language file cuts AI verbosity and keeps implementation aligned with the plan
Borrowed from Domain-Driven Design: a shared markdown glossary of codebase terminology, kept open during planning, measurably reduced verbosity in the AI's thinking traces and improved plan-to-implementation alignment
Writing is the cheapest defense against fooling yourself — the page finds the gaps your head papers over
An idea feels fully formed until you try to word it; writing exposes the untested assumption, the step that doesn't follow, the two claims that contradict. Darwin made it procedural — log disconfirming evidence on the spot, because memory deletes inconvenient results faster than convenient ones
Consolidating your context doesn't create the risk — it takes custody of a risk you already had
Tan's answer to the leak objection: the default is not privacy but a life already scattered across ten clouds whose incentives are not yours, searchable by everyone except you
Hot-path and offline learning are two temporal modes for agent context updates — each with different tradeoffs
Agents can update their context in the hot path (during task execution, like saving to memory while working) or offline (batch processing recent traces after the fact, like OpenClaw's 'dreaming'), with an additional dimension of explicit vs implicit memory updates
Don't mistake document ingestion for memory — learning from interactions is a different and harder system
Knowledge (ingesting documents into RAG) is largely solved; memory (learning from task execution to improve future behavior) remains unsolved after 2+ years of industry effort
Agents need workflow-level tool strategies, not individual tool instructions — the hard part is how tools combine
In enterprise environments, the challenge isn't finding the right tool but understanding how tools work together; intentionally narrow strategies that capture workflow patterns generalize better than broad abstractions
Procedural memory is the highest-impact type of agent memory — it determines what the agent actually does
Of three memory types (semantic/episodic/procedural), procedural — instructions, skills, and tools — has the highest impact because it changes what the agent actually does