Knowledge Graph
258 insightsSource-verified knowledge across AI product building and mental models — from practitioners and timeless thinkers. Browse by topic, search, or explore the graph.
258 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
Context is the product, not the model
Anyone can call the API — differentiation comes from the data you access, skills you build, UX you design, and domain knowledge you encode
Verification is the single highest-leverage practice for agent-assisted coding
Giving an agent a way to verify its own work 2-3x the quality of output — without verification, you're shipping blind
A mediocre agent inside a strong harness outperforms a stronger agent inside a messy one
The surrounding machinery — metrics, rollback, scoping, observability — determines autonomous system performance more than model capability
Systems of record keep what was decided, not why — capture the reasoning at the moment a decision becomes binding
Systems store what happened but not why; capturing the reasoning behind decisions creates searchable precedent and a new system of record
The context window is the fundamental constraint — everything else follows
Every best practice in AI coding (subagents, /clear, focused tasks, specs files) traces back to managing a single scarce resource: context
Autonomous coding loops need small stories and fast feedback to work
The Ralph pattern ships 13 user stories in 1 hour by decomposing into context-window-sized tasks with explicit acceptance criteria and test-based feedback
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
AI compresses the distance between idea and execution but not between good and bad judgment
When everyone can build anything, the differentiator stops being speed and starts being judgment — what to build, what to say no to, when to change course
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
Domain-specific skill libraries are the real agent moat, not core infrastructure
An elite team can replicate any agent's tool architecture in months, but accumulated domain workflows (LBO modeling, compliance, bankruptcy) represent years of domain expertise
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
Treat AI like a distributed team, not a single assistant
Running 15 parallel Claude streams with specialized roles (writer, reviewer, architect) produces better results than one perfect conversation
When products and models converge, the moat is the institution — how a company attracts people, distributes authority and compounds judgment
When models improve fast, interfaces converge, and product velocity becomes cheap, the durable advantage moves to how a company attracts exceptional people, distributes authority, and compounds judgment over time
Proprietary feedback loops create moats that widen with every interaction
When usage generates data that competitors cannot replicate — correction patterns, preference signals, domain-specific edge cases — the product improves faster than any new entrant can catch up
Sell the work, not the tool — the services budget dwarfs the software budget, and every model improvement helps whoever sells the outcome
Copilots sell tools to professionals; autopilots sell outcomes to end customers and access the vastly larger services TAM from day one
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
Declarative beats imperative when working with agents
Give agents success criteria and watch them go — don't tell them what to do step by step
LLMs selectively destroy vertical software moats — 5 fall, 5 hold
Learned interfaces, custom workflows, public data access, talent scarcity, and bundling collapse under LLMs, while proprietary data, regulatory lock-in, network effects, transaction embedding, and system-of-record status remain defensible
Production agents route routine cases through decision trees, reserving humans for complexity
Handle exact matches and known patterns without AI; invoke the model for ambiguity, and route genuinely complex cases to human judgment
When non-deterministic AI feeds a deterministic system, the deterministic layer governs — software that owns coordination and accountability keeps its place
When non-deterministic AI feeds into deterministic systems (databases, approvals, audit trails), the deterministic system governs; SaaS is that system
Scaffolding is tech debt against the next model — the bitter lesson applied to product building
Code built to extend model capability 10-20% becomes worthless when the next model ships, making most product scaffolding an ephemeral trade-off rather than a lasting investment
B2B becomes B2A — agents become the buyer
Software is increasingly consumed by agents, not humans; the agent recommends, the human approves
The gains come from redesigning work around AI, not bolting AI onto human workflows
Like factory owners who first swapped waterwheels for steam engines and changed nothing else (modest gains), today's orgs bolt chatbots onto human-designed workflows — the explosion comes only when the work is redesigned around agents
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
Markdown skill files may replace expensive fine-tuning
A SKILL.md file that teaches an agent how to do something specific can match domain-specific fine-tuned models — at zero training cost
The system of work is the moat, not the model — the model is fungible underneath
A vertical app company wins by owning the surface where a company's work actually executes — data capture, workflow system of action, and governance — while each new model generation flows through underneath
Build for the model six months from now, not the model of today
AI product builders should target the capability frontier the model hasn't reached yet, because today's PMF gets leapfrogged when the next model ships
An orchestrator agent that manages other agents solves the parallel coordination problem without human bottleneck
Instead of humans managing AI agents, a meta-agent spawns specialized agents, routes tasks by model strength, and monitors progress — turning agent swarms into autonomous dev teams
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
The three-layer AI stack: Memory, Search, Reasoning
The emerging AI product architecture has three layers — Memory (who is this user), Search (find the right information), Reasoning (navigate complex information) — all running on PostgreSQL
Verification is a Red Queen race — optimizing against a fixed eval contaminates it
Eval suites degrade the moment you use them to improve an agent — the agent adapts to the distribution, and the eval stops measuring what it was designed to measure
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
A latticework of mental models beats isolated facts for real understanding
You can't know anything useful by remembering isolated facts — they must hang on a latticework of theory from multiple disciplines, with 80-90 key models carrying 90% of the freight
Observability is the missing discipline for agent systems — you can't improve what you can't measure
Agent systems need telemetry (token usage, latency, error rates, cost per task) as a first-class engineering concern, not an afterthought bolted on after production failures
Reasoning by analogy has a ceiling — you can never get beyond what already exists by copying what already exists
Analogy is faster, easier, and less mentally taxing — fine for most decisions — but it forecloses any solution outside the existing solution set; first-principles reasoning is the only path that can produce non-incremental answers
Closed harnesses behind APIs create memory lock-in by design
When the harness lives behind a proprietary API, memory state and schema become invisible and non-portable — model providers are incentivized to push more of the harness behind their APIs
The context flywheel is a Day 90 moat — Day 0 comparisons are misleading
Point-in-time capability benchmarks miss the compounding advantage: on Day 0 a raw model matches your product, but by Day 90 accumulated context creates an unbridgeable gap
In agent-native architecture, features are prompts — not code
The shift from coding specific functions to describing outcomes that agents achieve by composing atomic tools
First conclusions become nearly permanent — the brain resists its own updates
Inconsistency-Avoidance Tendency means early-formed habits and first conclusions are maintained even against strong disconfirming evidence
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.
Revealed preferences trump stated preferences — track what users do, not what they say
Users' actual behavior (what they click, skip, edit, redo) is the ground truth for product decisions; stated preferences in surveys and interviews systematically mislead
Systems that prevent bad behavior beat moral appeals — design the cash register, not the sermon
People who create mechanisms making dishonest behavior hard to accomplish are more effective than those who preach against dishonesty
Cap headcount, not compute — token spend per engineer replaces headcount as the scaling unit
At $1,000/month per engineer as table stakes, top engineers manage 20-30 agents simultaneously; R&D scales through compute investment, not hiring
AI strategy is a self-rewriting equation — solving one constraint changes which constraint matters next
SaaS metrics were downstream of just two forces (distribution cost + switching cost); AI has many coupled variables — capability, cost, latency, deployment, regulation, talent — each decomposing into sub-curves, so the equation rewrites itself faster than any fixed playbook can track
Policy enforcement must run independently of model cooperation — hooks, not prompt instructions
Hermes runs lifecycle hooks that block, rewrite, or audit operations at fixed events, so policy and side-effects never depend on the model choosing to comply
Evals are behavioral pressure vectors, not neutral measurements — poorly chosen evals distort agent development
Each eval shapes agent behavior like a selection pressure; accumulating tests without strategic purpose creates 'an illusion of improving your agent' while distorting development in unproductive directions, and correctness alone misleads because agents that succeed inefficiently create hidden cost
Every optimization has a shadow regression — guard commands make the shadow visible
When optimizing metric A, metric B silently degrades unless you run a separate invariant check (a guard) alongside the primary verification
Frontier companies absorb every useful agentic pattern into base products
If a workaround truly extends agent capabilities, OpenAI and Anthropic — the biggest power users of their own models — will build it in, making external dependencies temporary
Give an optimizing agent full traces, not compressed summaries — it has to see why past attempts failed
Meta-Harness gives its proposer agent a filesystem containing full source code, scores, and execution traces of every prior candidate, enabling up to 10M tokens of diagnostic context per iteration — dramatically outperforming prior methods limited to 26K compressed tokens
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)
Invert, always invert — many problems are best solved backward
Thinking in reverse is one of the most powerful problem-solving techniques: instead of asking what you want, ask what you want to avoid, then don't do that
Parallel agents create a management problem, not a coding problem
When AI agents can work on multiple projects simultaneously, the bottleneck shifts from writing code to coordinating parallel workstreams
Technology transitions create more of the 'dying' thing, not less
Every predicted death — mainframes, physical retail, traditional media — resulted in growth of both old and new; AI will create more software, not less
The trace→eval→harness flywheel compounds agent quality — every production interaction generates its own training data
Production traces where agents fail become eval cases; better evals improve the harness; better harnesses produce better traces — creating a self-reinforcing improvement loop
Agentic search beats RAG for live codebases
Claude Code abandoned RAG and vector DB in favor of letting the agent grep/glob/read — reasoning about where to look outperforms pre-indexed similarity search for code
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)
AI is steel for organizations — when software carries the context, human communication stops being the load-bearing wall
Before steel, buildings capped at six or seven floors because iron buckled under its own weight; AI that maintains context across workflows removes human communication (meetings, messages) as the structure that caps how far an org can scale before it degrades
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
Reason backward from an outcome you want to exist — it manufactures originality that absorbed problems can't
Absorbed problems hand you the conclusion without the reasoning, on a crowded racetrack; choosing an outcome you genuinely want and reasoning backward to the experiments drags you into territory no survey paper covers
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
Evaluate agent tools with real multi-step tasks, not toy single-call examples
Weak evaluation tasks hide tool design flaws — strong tasks require chained calls, ambiguity resolution, and verifiable outcomes
Inference-time compute makes cost-per-outcome a choice — and that's the application layer's counterattack on the labs
No prior software had a dial where 10x more compute buys a better answer; a 10-second and a 10-minute query on the same model are different products at different prices. Margin depends on the system's judgment of where to spend tokens, not on model pricing — the lab wants to expand usage, the application wants to spend only where the outcome is worth it
Agents need a REPL that keeps state between steps — the harness decides whether a tool protocol works, not the protocol
CLI tools beat MCP today only because they are reached through bash, which is a REPL whose state persists in the file system; that is a harness property, not something intrinsic to MCP
Meta-agents that autonomously optimize task agents beat hand-engineered harnesses on production benchmarks
AutoAgent's meta-agent hit #1 on SpreadsheetBench (96.5%) and TerminalBench (55.1%) by autonomously iterating on a task agent's harness for 24+ hours — every other leaderboard entry was hand-engineered
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
Self-disruption follows the value chain downward — software companies must eat their own agent layer before someone else does
Intercom deliberately disrupted their software business with agents, and now disrupts their agent business with AI models, because value accrues to the model layer
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
The 80/99 gap is where AI products die — demo accuracy and production reliability are infinitely far apart
Getting an AI system from 80% demo accuracy to 99% production reliability requires fundamentally different engineering than the first 80% — most teams underestimate this gap by orders of magnitude
Tool design is continuous observation — see like an agent
Designing effective agent tools requires iterating by watching actual model behavior, not specifying upfront; tools that helped weaker models may constrain stronger ones
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
A human in the loop is a gating mechanism — it caps the loop at human waking hours
Blomfield's framing: in most agentic systems the human is not a reviewer but the rate limiter — if the agent stalls at 3am waiting on input, nothing moves until someone wakes up
Without a learning mechanism you have an AI pipeline, not an AI loop
Blomfield's five-part anatomy — real-world signal, policy layer, tool layer, quality gates, learning mechanism — where only the last part closes the circuit back onto the system that produced the output
The model already knows the answer — it just can't reach it without the right tool
A model can hold all the facts needed to answer a question and still fail to produce the answer — until it's given a tool (code execution, a bash environment) that lets it act on what it already knows
Deep modules make a codebase both AI-legible and safe to gray-box
Ousterhout's deep-vs-shallow-module distinction determines whether an AI can navigate a codebase at all, and whether a human can delegate implementation while reviewing only the interface
Detect everything, notify selectively — the observability-to-notification ratio determines system trust
Watch every signal but ensure alerts reaching humans always mean something; teams ignore noisy monitors AND noisy agents equally fast
Evals are the gradient signal for harness engineering — the same data quality rigor from ML training applies
The analogy between ML training and agent development is structural: evals encode desired behavior like training data encodes ground truth, and the same principles (data quality, curation, train/test splits) determine outcomes
Model-market fit comes before product-market fit — without it, no amount of product excellence drives adoption
AI startups need a prerequisite layer beneath PMF: the capability threshold where models can actually satisfy market demands. Legal AI crossed it at 87% accuracy; finance AI at 56% hasn't — same demand, opposite outcomes.
Multi-model code review creates adversarial robustness — each model catches what others miss
Using 3 different LLMs to review the same PR exploits the fact that models have different failure modes, creating emergent coverage no single model achieves
AI is the computer — orchestration across 19 models is the product, not any single model
Perplexity launched a unified agent system orchestrating 19 backend models that delegate tasks, manage files, execute code, and browse the web. The differentiation isn't the models — it's the orchestration. 'The computer is the orchestration system.'
Open harnesses with customer-owned databases are the antidote to model-provider lock-in
An open, model-agnostic harness that stores memory in a database you control (Postgres, Mongo, Redis) keeps both model choice and memory portable
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
Permissioned inference is harder than permissioned retrieval — enterprise context graphs need reasoning-level access control
Controlling who sees data is solved; controlling whose history shapes reasoning for others is the unsolved trust layer enterprise context graphs require
Prompt caching makes long context economically viable
Prefix-matching cache enables 80%+ cost reduction for multi-turn conversations, making rich context systems affordable at scale
Tools are a new kind of software — contracts between deterministic systems and non-deterministic agents
Agent tools must be designed for how agents think (context-limited, non-deterministic, description-dependent), not how programmers think
Adversarial branch-walking beats review for planning — walk every design branch until resolved
The most effective planning intervention is not post-hoc review or divergent brainstorming but convergent, exhaustive questioning that traverses each branch of the decision tree with recommended answers
Amplification widens the judgment gap — AI magnifies clear thinking into compounding advantage and confused thinking into accelerating waste
Same tools, divergent outcomes — strong teams with clear strategies get faster and more focused, weak teams with vague strategies get noisier and more distracted
AI automation amplifies demand for expert human judgment rather than replacing it
Pre-labeling cuts costs 100,000x for simple tasks, but projects that needed 500 contributors now need 100 doing far higher-value work at up to $200/hour
Boring tech wins for AI-native startups — simpler stack means faster AI-assisted shipping
React + Node + TypeScript + Postgres + Redis scales to $1M ARR with 3 engineers; monorepo is a superpower for AI coding assistants
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
Context layers must be living systems, not static artifacts
Unlike semantic layers that rot when maintainers leave, context layers need self-updating feedback loops where agent errors refine the context corpus
Durable execution snapshots the whole interpreter, so a code-mode session survives restarts and hours-long waits
dquickts, a QuickJS fork Tobi Lutke called an excellent code mode env, can pause a running program even mid-loop, write its entire heap to bytes and resume it in another process; a REPL built on it keeps functions, variables and closures across restarts
Excessive self-regard makes fixable failures persist — people excuse poor performance instead of correcting it
The Tolstoy effect causes people to rationalize fixable shortcomings rather than address them, requiring meritocratic culture and objective evaluation as antidotes
Holdout eval sets are the generalization gate for autonomous harness optimization — without them, the loop overfits
Autonomous harness hill-climbing tends to overfit to the optimization set; splitting evals into optimization and holdout categories — mirroring ML train/test splits — is the structural defense
When the system routes information, IC and DRI are the only roles left
Blomfield's org prescription for AI-native companies: no directors or VPs, everyone an individual contributor who brings working prototypes rather than decks, and a single directly responsible individual instead of a committee
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
The map is not the territory — with a capable-enough agent, finding your unknowns becomes the real bottleneck
The plan/prompt/spec in your head is the map; the actual codebase and real-world constraints are the territory; wherever the agent hits territory your map didn't cover, that's an unknown it now has to resolve on its own
The price of intelligence is the new organizing axis — labs, applications, and countries are all fighting to set it
The cost of intelligence is no longer an input to software but the axis around which companies, markets, and geopolitics reorganize; labs want usage routed through them, applications want to allocate intelligence better than labs, countries want it cheap enough to be national infrastructure
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
Sand vs Stone — if models double in capability tomorrow, what washes away and what remains?
Framework for evaluating AI product durability: context flywheels and domain expertise are stone; model workarounds and clever engineering are sand
Sessions are runtime infrastructure, not just resumable transcripts
Hermes stores sessions in SQLite with search and lineage so CLI, messaging platforms, and scheduled jobs all attach to one session plane — routing can resolve before the model even runs
Speed without feedback amplifies errors — agents lack the self-correction mechanism that constrains human mistakes
Humans serve as natural bottlenecks who self-correct after repeated mistakes; agents perpetuate identical errors indefinitely at unsustainable rates
Humans should supervise agent loops from a leveraged point, not sit inside every one
Human-in-the-loop isn't always desirable — putting a person inside every iteration is the Red Flag Act (a man legally required to walk ahead of every car waving a flag); the goal is leveraged oversight of many loops, not manual inspection of each
The UI moat collapses — API quality becomes the purchasing criterion
When agents are the primary users of software, beautiful dashboards stop mattering and API design becomes the competitive surface
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
Agent edits are automatic decision instrumentation — every human correction is a structured signal
When agents propose and humans edit, the delta between proposal and correction captures tacit judgment as first-class data without requiring manual logging
Bash, code and tool calls could compile to one execution plan that is security-checked before it runs
Tobi Lutke's bet: an embeddable, sqlite-style mini execution environment that turns bash, TypeScript or tool calls into a common intermediate plan, checks it before executing, and is built for durable execution, so CLI, MCP and WebMCP become interchangeable inputs
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
Agent trust transfers from human credibility — colleagues adopt agents operated by people they trust
When a human's agent consistently performs well, other team members inherit that trust and willingly depend on the agent, creating a credibility chain
AI amplifies the architecture it works in — a hard-to-change codebase caps what any model can do for you
The specs-to-code movement assumes code is cheap; the opposite is true — a hard-to-change codebase blocks you from the full bounty AI can offer, so architecture quality now matters more, not less
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
Building in AI is running a trading book — you're long some curves, short others, and exposed to correlations that break when they matter
Value in AI is never captured once and defended; it's continuously repriced and relocated. Durable companies know which assumptions they're long and which they're short, choose which variables to bet on, know which can kill them, and build to recover faster than a wrong bet can compound
Circle of competence determines where you can win
Every person has a circle of competence — playing inside it with discipline compounds advantage, playing outside it guarantees loss, and it's very hard to enlarge
Commodity work's terminal value is zero but structured expert judgment compounds indefinitely
Appen collapsed from $4.5B to $140M as LLMs displaced commodity annotation, while Scale AI reached $29B by owning expert alignment infrastructure — the market is bifurcating
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
Emotional promises must be structural promises — if the structure doesn't back the pitch, the promise is fake
Each cultural claim — ownership, customer proximity, speed, talent density — is a structural commitment about decision rights, status hierarchy, and authority allocation; misalignment between the two reads as fake even when candidates can't articulate it
Engineering is no longer the junior partner — at the frontier, research and engineering have fused
The researcher who can build the harness, the eval, and the data pipeline is the one whose hypotheses actually get tested; everyone else waits in a queue. The split between 'has ideas' and 'can run them' has collapsed into one role
Harness improvements that encode domain patterns transfer across models — invest once and keep the gain through model swaps
Meta-Harness discovered a retrieval harness that improved math reasoning by 4.7 percentage points average across five held-out models it was never optimized for, suggesting harness quality is model-agnostic
First-principles thinking is uncomfortable because it transfers responsibility — analogy outsources blame to 'best practices'
When you reason by analogy you have a defense ('I did what everyone said'); when you reason from first principles you own the outcome. The discomfort most people feel about first-principles thinking is responsibility, not difficulty
Incentive-caused bias makes good people rationalize harmful behavior
People don't consciously choose to be unethical — incentive structures cause them to drift into immoral behavior and then rationalize it as virtuous
Institutional slowness is the runway, not the threat
Tan inverts the standard AI-doom framing: the bureaucracy and cognitive limits of every company, institution and government are what give builders a two-decade window, and he says this openly against the Silicon Valley consensus that startups will replace incumbents
The intelligence-to-judgement ratio determines which professions AI automates first
Intelligence work (complex but rule-based) is already automatable; judgement (experience, taste, intuition) remains human — software engineering crossed the threshold first
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
In AI the threat is layer migration, not a competitor — work relocates across layers when any variable moves
In SaaS a rival company killed you; the one exception was platform dependency, where a pricing or terms change could wipe you out. AI makes that exception the default — work migrates into the model, an open-weight alternative, the customer's data platform, an agent runtime, or the device itself
The quality gate should be a second adversarial model, not a human
Blomfield argues the reviewing step in an AI loop should be a human only in the most extreme cases — an adversarial LLM checking for prompt injection, policy breach, or code defects keeps the loop running unattended
Routing across the whole model market — and absorbing every migration — is a defense the labs can't copy
A vertical company picks the best model per sub-task across all vendors, absorbs eval/migration work on every upgrade, and sells the lowest cost for the exact intelligence each step needs
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
Private evals should measure business outcomes that matter — not external benchmarks
A firm's learning loop runs on private evals tied to real business outcomes and private RL environments trained on internal traces, so the model improves against what the company cares about rather than public leaderboards
Property-based testing explores agent input spaces that example-based tests miss
Generative tests that produce random or adversarial inputs discover edge cases in agent behavior that hand-written examples never cover — verification over testing means proving properties, not checking cases
Research speed is mostly the speed at which you discover you're wrong — which makes tooling a first-class research activity
The edge isn't a stroke of genius but volume: more runs per day, more wrong ideas discarded per week, a faster-updating model of reality. That makes one-command runs, config-reproducible experiments, and seconds-not-archaeology run comparison core research work, not chores
Rollback safety nets enable autonomous iteration — not model intelligence
The minimum viable safety net for autonomy is a quantifiable metric, atomic changes, and automatic rollback — these make cheap failure possible, which makes aggressive exploration safe
The comfortable middle is over — software companies must either accelerate AI growth or rebuild for 40%+ margins
Growth-path companies ship AI-native products in 4-person pods with token-based pricing; margin-path companies flatten management, raise prices, and let low-value customers churn — anything in between faces multiple compression
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
Task horizon breaks seat-based pricing — usage scales with workflow depth × length, not headcount
Task horizon is the length dial: how long an AI works on its own before a human steps in. The unit shifted from the call to the workflow — agents run for hours, spawn sub-agents, and burn millions of tokens per decision path, so usage stops scaling with seats; multiply length by depth to get the token bill
Technology helps moat businesses but kills commodity businesses
In commodity businesses, productivity improvements flow entirely to customers; in businesses with competitive advantages, the same improvements go to the bottom line — most people fail to do this second step of analysis
Deliberately overspending on inference buys lead time, not efficiency
Tan runs agents at full strength — 800,000 to a million tokens loaded into a single request — and describes the result as getting to live in 2028 today; the spend is uneconomic per task and that is the point
Traces are the universal substrate for agent learning — all three layers consume the same execution logs
Whether updating model weights, improving harness code, or refining context/memory, agent learning flows start from the same raw material: traces capturing the full execution path of what an agent did
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
WebMCP turns websites into agent-native interfaces
Chrome's MCP integration lets websites expose structured tools to agents instead of agents scraping and guessing at UI elements
Agent harnesses are persistent infrastructure, not scaffolding models will absorb
As models improve, old scaffolding disappears but new scaffolding replaces it — harnesses aren't going away, they're evolving
The intelligence lives in the workflow, not the model — and a model can't simply read it
In a real vertical, the decisive logic (what to escalate, which rule wins, when a human signs off) lives in SOPs and operational experience; the agentic workflow encodes it and becomes the carrier's operating memory
AI's self-improvement loop means each generation builds the next one faster
GPT-5.3-Codex was instrumental in creating itself — recursive improvement compresses timelines and explains why building for obsolescence is the only safe strategy
Auto-generated narrow monitors beat handwritten broad checks — a tight mesh over the exact shape of the code
1,000+ AI-generated monitors that each target specific code paths catch more bugs than 10 hand-written checks that cover general categories
Being chosen vs being seen — emotional validation captures founder-level intensity at employee-level structure
Being chosen is emotional: you are special, we believe in you, you belong here. Being seen is structural: scope, authority, economic participation, decision rights — the trap is paying in identity what you don't want to pay in structure
If a problem improves directly with raw model capability, the labs will take it
The Yellow Brick Road test — work that gets better with every pre/post-training dollar (code, writing, images) belongs to the labs; work whose value comes from scaffolding is defensible
Compression should be a forking lifecycle event, not a destructive rewrite
Instead of repeatedly overwriting one transcript, Hermes seeds a child session from each summary and records parent-child lineage — producing an auditable chain of compressions
Confluence of tendencies produces extreme outcomes — lollapalooza effects emerge when multiple psychological biases push the same direction
When several psychological tendencies combine toward the same outcome, the result is not additive but explosive — Munger's checklist method diagnoses these compound failures
Delegation is not orchestration — durable, externally-steerable child runs are the architectural leap
Hermes can spawn child runs with their own task IDs that return structured summaries, but they die with the parent; true orchestration needs run IDs, lifecycle control, and steering that survive parent completion
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
Guardrails aren't just safety — they're what the customer is paying for
Per-use-case, per-customer, continuously-audited governance is the product in a regulated vertical; becoming the compliance control plane is a moat a horizontal player can't credibly hold
Humans move to the edge where the model touches reality — a company brain that can't touch the world is just a database
Quoting Jack Dorsey, Blomfield puts people at the perimeter doing what models cannot — intuition, trust, ethical and existential calls — while the routing of information moves into the system
Hybrid search is the default, not the exception
Neither keyword nor semantic search alone is complete — combining BM25 and vector search with reranking is the baseline for production systems
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
LLM competition fragments markets from 3 incumbents to 300
When LLMs lower the cost of building vertical software, competition doesn't add one new entrant — it explodes combinatorially, explaining market repricing before revenue loss
Malleable software — a tiny core that writes its own plugins — replaces fixed-feature applications
Instead of adapting your workflow to the tool, the tool observes your workflow and extends itself to match it
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
The sovereignty test — can you swap out a generalist model without losing your 'company veteran' expertise?
A firm controls its IP only if it can switch the underlying generalist model while keeping the company-veteran expertise built into its learning system; that portability is the test of control and sovereignty in the AI era
New technology first imitates the medium it replaces — the transition form hides the final form
Early phone calls were telegram-terse, early movies were filmed stage plays, and today's AI is a chatbot mimicking a search box; McLuhan's 'driving into the future via the rearview window' is why we mistake the imitation phase for the destination
One session per contract beats long-running agent sessions
Fresh context per task contract outperforms 24-hour agent sessions because cross-contract context bloat degrades performance by construction
Point a second agent at the first agent's failure log and the system repairs itself overnight
YC's text-to-SQL agent kept hitting edge cases; a second agent that reads each day's successes and failures and opens pull requests overnight turned a static tool into a self-improving one
Reasoning evaporation permanently destroys agent decision chains when the context window closes
An agent's multi-step reasoning exists only in the context window; when the session ends, the output survives but the decision chain — why each step was taken — is gone forever
Agents eat your system of record — the rigid app was the constraint, not the schema
When agents can clone your entire CRM in seconds and become the real interface, the SaaS product becomes a dumb write endpoint. Data moats evaporate because agents eliminate the rigid app that demanded rigid schemas.
AI won't destroy SaaS moats — it'll make the biggest ones even bigger
Enterprise SaaS consolidates rather than fragments: we could see 5-10 individual trillion-dollar SaaS companies. Moats are people, relationships, and enterprise integrations — not code. Cheaper AI-built software doesn't overcome distribution advantages.
Scale advantages cascade toward dominance until bureaucracy kills them
Advantages of scale — cost curves, social proof, informational edge, advertising reach — compound toward winner-take-all, but large organizations breed bureaucracy and territoriality that can undo every advantage
Separate tool registration from tool exposure — install broadly, reveal narrowly
Hermes registers all tools into a central registry at import time but a separate layer decides what each run actually shows the model, scoped by platform and scenario
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
Technical knowledge can become a liability when working with AI
Experts get stuck on implementation details while novices describe outcomes and ship faster
The first enterprise-AI sale is a trust sale — buyers judge de-risking, not capability
Early AI deployments are bought on reliability, control, and whether the system can be trusted in real workflows; founders systematically over-index on demonstrating capability and under-index on de-risking the buyer
Time-bounded evaluation forces optimization for real-world usefulness instead of idealized performance
A fixed wall-clock budget per experiment makes results comparable, normalizes across hardware, and forces agents to optimize for improvement per unit time
Trust boundaries must be externalized — not held in engineers' heads
Where an agent's behavior is well-understood vs. unknown should be mapped, made auditable, and connected to deployment gates — not left as implicit tribal knowledge
Vertical models beat frontier models in their domain — specialization wins on every metric
Intercom's Apex, a specialized customer service LLM, beat every frontier model including Anthropic and OpenAI on resolution rate, latency, hallucination rate, and cost
The data flywheel is a UX problem — only vertical workflow surfaces can capture the knowledge
Two stacked flywheels (across-customer pattern recognition + within-customer tacit rules) accrue only through workflow-specific capture surfaces that horizontal tools structurally cannot shape
Your first subfield is an accident of timing — wander across several before you settle, because breadth is insurance
Pay tuition in interpretability, evals, rl, and systems before deciding where you live; somewhere is a corner where your specific weirdness is an unfair advantage. Subfields all saturate, usually right after they peak on twitter, and breadth is what carries you through the transition
Virtual filesystems replace sandboxes for agent navigation — intercept commands instead of provisioning infrastructure
Mintlify's ChromaFs intercepts Unix commands and translates them into database queries, cutting boot time from 46 seconds to 100ms and cost from $70k/year to near-zero
A frontier without an ecosystem is not stable — if a few models capture all value, the political economy won't tolerate it
The priority must be building a frontier ecosystem, not just a frontier model, so value flows broadly across companies and industries; concentrating all returns in a few models that hollow out industries has no societal permission and is not a stable equilibrium
Ask for 'no' not 'yes' — default-proceed framing accelerates organizational decisions
Framing proposals as 'I will do X unless you object' rather than 'Can I do X?' shifts the decision burden, maintains momentum, and shows ownership while preserving space for input
Causal triage must gate automated fixes — statistical regression detection alone can't distinguish your bugs from external failures
Raw error-rate spikes after deployment can't tell you whether YOUR code broke or a third-party API went down; a triage agent that establishes causal links between code changes and observed errors must gate any automated fixing agent
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
Data agent failures stem from missing business context, not SQL generation gaps
The industry initially blamed text-to-SQL capability for data agent failures, but the real blockers are undefined business definitions, ambiguous sources of truth, and missing tribal knowledge
Deputies and Sheriffs — distributed agent teams with hierarchical authority replace centralized software
Individual employees train specialized 'Deputy' agents while organizational 'Sheriff' agents manage permissions, rules, and onboarding across the team
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
Eval suites must shrink, not just grow — spring cleaning prevents stale behavioral pressure
Saturated evals waste compute without providing signal; more intelligent models or changed desired behaviors make old evals irrelevant, requiring regular pruning alongside addition
Every role codes when implementation cost drops to zero — the generalist builder replaces the specialist engineer
When AI handles implementation, the title 'software engineer' gives way to generalist builders who code, write specs, design, and talk to users
Knowing what to build is the scarce half, so agent leverage favors veteran founders
Tan reports a mega trend of founders in their late thirties and forties who have been around the block; the multiplier applies to whatever judgment it is given, so multiplying someone who already knows what to build can outperform a department at a large tech company
The rate of feedback is the AI's speed limit — TDD forces the small steps it won't take on its own
LLMs 'outrun their headlights' by default, producing huge amounts of code before checking types or tests; TDD forces the small-step discipline that keeps generation inside what the feedback loop can actually verify
The first-draft pattern is the killer app for long-horizon agents — agents produce, humans review
Long-horizon agents produce comprehensive first drafts (PRs, analyses, reports) that humans verify — this is where the 10x productivity gain actually lives
Great companies are wrappers around a kind of person — institutions that make a new kind of person possible
The most important companies are organizational inventions: they create a new kind of institution around a new kind of work, and in doing so, they let a certain kind of talent finally express themselves
Every firm must build two capitals — human capital and token capital — and they compound together, not at each other's expense
Human capital is the knowledge, judgment, relationships, and pattern recognition of a firm's people; token capital is the AI capability it builds and owns — and human capital only becomes MORE valuable as token capital grows
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
Long-horizon evals test compounding behavior, not point-in-time accuracy
Hex's Metric City benchmark simulates 90 days of agent use with evolving data to measure whether the agent gets smarter over time — Day 0: 4%, Day 90: 24%
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
Models are grown, not designed — treat a new model class as biology, not physics
You don't design a 99%-on-SWE-bench target and build to spec; you grow the model with data, feedback, and compute, then discover empirically what it can do — the same empirical stance has to carry over to how you work with it
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
Non-attached action enables clearer course correction — detach from outcomes to see reality
Acting without attachment to being right, to a specific outcome, or to whose idea it was lets you see when something isn't working and change course without ego friction
Pavlovian association builds durable brand moats that compound for over a century
Brands are conditioned reflexes — the trade name is the stimulus, purchase is the response, and Pavlovian association with things consumers admire creates advantages that scale economics alone cannot explain
Personal software grows through relationship, not configuration
Unlike traditional SaaS where users adapt to the tool, personal software agents grow personality and skills in response to their user through ongoing interaction
Peter Thiel's question is a detector for actual first-principles thinking — if your conclusions match the crowd, you're analogizing
'What important truth do very few people agree with you on?' is the diagnostic — most people can't answer because most people reason by analogy and end up with the same conclusions as everyone else
The pilot training model builds reliable knowledge — fluency, checklists, and maintenance prevent cognitive failure
Just as pilot training uses six elements to prevent fatal errors — wide coverage, practice-based fluency, forward and reverse thinking, importance-weighted allocation, mandatory checklists, and regular maintenance — the same structure should govern all serious professional education
Platform economics beat labor arbitrage — margins fund flywheels that body shops cannot
Scale AI's 50%+ gross margins fund ML pre-labeling and workflow optimization, creating a flywheel; Indian BPOs at 10-15% margins cannot invest in R&D and remain trapped competing on price
PostgreSQL scales further than you think
OpenAI runs ChatGPT on one PostgreSQL primary plus ~50 read replicas handling millions of QPS — no sharding of PostgreSQL itself, just excellent operations
Response UX should match retrieval intelligence
If your system uses semantic search to find results, the display should reflect that intelligence — keyword highlighting on semantic results creates a confusing mismatch
Same-model meta-task pairings outperform cross-model — agents understand their own architecture better than humans or other models do
Claude meta-agent + Claude task agent outperformed Claude meta-agent + GPT task agent because the meta-agent shares weights and implicitly understands how the inner model reasons
Shadow execution enables safe trace learning — replay write operations without touching production data
By replaying actions that would write to external apps in a shadow path, agents can learn from realistic end-to-end flows without impacting customer data
Social proof makes groups passive before visible harm — conformity overrides individual judgment even in life-or-death situations
Social-Proof Tendency causes individuals to follow the crowd into inaction or corruption, with bystander apathy and institutional silence as its most dangerous manifestations
You fail both ways: over-specified instructions block a needed pivot, under-specified ones default to the wrong assumptions
Being too precise stops an agent from deviating even when deviation is correct; being too vague lets it fall back on generic best-practice defaults that may not fit — both failures trace to not having accounted for your own unknowns
System or tool? Ask whether the customer would still need you if a lab shipped a direct competitor
Three tests for being safely off the Yellow Brick Road — tools-and-steps, system-vs-tool, and customer-P&L — with the system test (would they still need you?) as the sharpest discriminator
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
AI trace data has an indefinite useful lifespan — SaaS observability's 30-day retention model destroys institutional knowledge
Infrastructure metrics expire quickly but AI conversations and reasoning traces gain value over time; 30-day retention windows erase the very data that reveals failure patterns and training signals
Traces replace code as the source of truth for agent systems — debugging shifts from 'show me the code' to 'send me the trace'
In agent systems, execution traces replace source code as the primary debugging and collaboration artifact — you can't predict step 14's context from reading the code
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
Unattended agent jobs must run through the same permission machinery as interactive sessions
Hermes makes cron a first-class subsystem — scheduled jobs are gated by the same permissions, delivered through the same paths, and isolated per profile, instead of living as peripheral scripts
Unfocused agents develop path dependency — without a specific mission, they explore the same paths repeatedly
Agents given broad mandates (like 'find bugs') converge on familiar exploration paths, catching high-radius issues but missing narrow situational problems
Where inference runs decides who captures margin, owns the context, and earns trust
Value won't all accrue to the cloud — inference moves to wherever it's cheapest without breaking the product: cloud for frontier reasoning, edge for latency, on-device for privacy. Privacy matters more than in SaaS because the model isn't just storing data, it's reasoning over the user's context, memory, code, and permissions
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
Agentic UX (AUX) is a distinct design problem — agents don't want to use software the way humans do
AUX (Agentic User Experience) is neither human UX adapted for agents nor raw APIs — it's a third design discipline for how agents want to consume software
Agents running the platform vs. agents on the platform — the operator shift changes what software must be
The shift from agents as features inside your product to agents as operators running your product — passengers become pilots
AI erases the API line — the side that takes orders can now negotiate
Venkatesh Rao's rule was to fight your way above the API line, because below it you do what the API tells you; Tan argues agents dissolve the line, citing a YC company that shipped a bug-report endpoint built for agents rather than humans, which replies in real time with a triage decision and a workaround
Bet seldom but heavily when the odds are extreme
The wise ones bet big when they have the odds and don't bet the rest of the time — most of Berkshire's billions came from about ten insights over a lifetime
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
Enterprise agents need deterministic structure while startups need autonomous loops — same models, different harnesses
Enterprises need deterministic graph-based harnesses for predictability; startups benefit from autonomous loop agents — the harness choice, not the model, determines reliability
Evaluations must augment trace data in place — divergent copies drift by design
The moment you export traces to a separate eval system, the copy diverges from where annotations run; evals, annotations, and traces should share a single source of truth
Don't presume the tradeoff — do all of it and force reality to show you where the real constraint is
Anthropic's cultural belief that tradeoffs are not real: instead of reasonably ranking priorities against each other in advance, attempt everything and let reality — not your own assumption — reveal what actually can't be done
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
Ideology is among the most extreme distorters of human cognition
Heavy ideology locks your brain into dysfunctional patterns — if it can warp a genius like Chomsky, imagine what it does to ordinary minds
Inference capability lowers input fidelity requirements — smart listeners make imprecise input work
When the consumer of input has strong inference ability, the quality bar for that input drops — voice works not because transcription improved, but because the listener got smarter
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
Lakebases decouple compute from storage — databases become elastic infrastructure
Third-generation databases separate compute and storage entirely, putting data in open formats on cloud object stores; the database becomes a serverless layer that scales to zero
Latent demand is the strongest product signal — make the thing people already do easier
People will only do things they already do; you can't get them to do a new thing, but you can make their existing behavior frictionless
LLM-as-judge must be calibrated against human judgment — uncalibrated judges are worse than no judges
An LLM judge without human-labeled calibration data produces false confidence; the bridge is humans labeling traces, then training the judge to replicate those labels
LLMs complete Aggregation Theory by collapsing the interface layer
Ben Thompson's framework reaches its final chapter: LLMs eliminate the interface layer that protected software suppliers, turning the entire web into a backend database where suppliers compete on data quality alone
Mission strength is measured by who it repels — the strongest missions make some people refuse to work there
A mission that offends no one, selects for no one, and costs nothing is functionally fake; the strongest missions take a side, and the people they repel are the same signal as the people they attract
Negative maintenance teammates reduce future work for everyone around them
The rarest team archetype isn't high-performers or low-maintenance people — it's those who actively make life easier for others by solving problems upstream before they propagate
Open source captures value through services, not software
Free software builds billion-dollar companies because the money is in support, cloud, and governance layers — not the code itself
Order the system prompt by volatility to keep prompt prefixes cache-friendly
Hermes composes the system prompt in three tiers — stable, context, volatile — so the unchanging prefix stays cacheable while turn-by-turn data lives at the end
Separate research from implementation to preserve agent context for execution
Mixing research and implementation pollutes context with irrelevant alternatives — split them into separate agent sessions so the implementer gets only the chosen approach
Small concessions trigger disproportionate reciprocation — even at the subconscious level
Reciprocation Tendency operates below conscious awareness, making tiny favors or concessions produce outsized compliance — the only reliable defense is structural prohibition
Software abundance unlocks entire categories of applications that never existed
Software has always been more expensive than we can afford; when AI drops costs 10-20x, previously unviable software becomes economically possible
Specs-to-code without reading the code is vibe coding by another name
Iterating purely by rewriting the spec and re-running the compiler, while deliberately never inspecting the generated code, produces progressively worse code each cycle — an empirically observed failure mode, not a hypothetical one
Stronger models expand the verification gap, not close it
More capable models increase the deployment surface and raise the stakes of failures, making verification infrastructure more valuable rather than less
Templates encode someone else's constraints — copying a playbook silently imports its assumptions about audience, resources, and strengths
Templates work because they were tuned for a specific situation; copying them imports invisible assumptions about who you are, what you have, and what you're optimizing for — and the misfit only shows up after you've spent the time
Type 1 vs Type 2 decisions — irreversibility decides whether to spend first-principles thinking or analogy
Bezos's split: irreversible decisions deserve slow, methodical first-principles thinking; reversible ones should use fast analogy. The mistake is misallocating — burning fundamentals on what to eat for lunch, or analogizing your way through a one-way door
Uncorrelated context windows are a form of test time compute — fresh perspectives multiply capability
Multiple agents with independent context windows avoid polluting each other's reasoning, and throwing more context at a problem from different angles increases capability
Users describe solutions within the constraint set they know — 'faster horses' is what stated preferences look like outside the existing tool set
When asked what they want, users reason by analogy from existing tools and return better versions of those tools; first-principles asks what underlying problem is being solved, which is invisible to the user but where the actual opportunity lives
Weaponize sycophancy with adversarial agent ensembles instead of fighting it
Deploy bug-finder, adversary, and referee agents with scoring incentives that exploit each agent's eagerness to please — triangulating truth from competing biases
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
Conflicting context causes agent collapse, not graceful degradation
When an LLM encounters contradictory information in its context, it enters extended deliberation loops rather than choosing one interpretation — production finding from Hex
Already-outsourced tasks are the autopilot wedge — vendor swap beats reorg
If work is already outsourced, budget exists, external delivery is accepted, and the buyer purchases outcomes — substitution is frictionless
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
Resolve ambiguity before passing it downstream — don't forward confusion
Ambiguity compounds as it flows through an organization; the person who encounters it first should resolve it, suggest a path forward, or take a first pass rather than forwarding it unresolved
Teacher-student trace distillation with consensus validation beats single-oracle learning
A single high-reasoning teacher trace isn't reliable enough for enterprise learning; comparing multiple student traces under production constraints with consensus validation produces trustworthy strategies
Time-denominated promises decay invisibly — 'over time' is the most dangerous denomination because time doesn't announce itself as it leaves
Promises in the 'over time it'll be bigger / you'll own more / the structure will catch up' shape rot silently because they lack a written mechanism that forces them to mature; you arrive at a later version of your life and realize the future-tense promise never came to be