"How did you find my post?"
The YC founder smiled. "Someone shared it in our Slack. We're building something similar. Your approach is very much aligned with what we've been thinking and building towards."
I write for a small network, mostly documenting my own experiments. But "How I Built an AI-First Knowledge System That Actually Works" seemed to resonate with builders facing the same problems I'd been trying to solve.
That conversation happened Friday morning, just a few days ago. A month has passed since I wrote that original post about AI-assisted capture, organization, and retrieval. The system I described worked well for getting information in and finding it again.
But I kept hitting a wall: retrieval isn't the same as synthesis, and organization doesn't automatically lead to action.
In How I Built an AI-First Knowledge System That Actually Works (Part 1), I showed how to build an AI-first knowledge system that solved capture and retrieval. Think of it as transforming your digital filing cabinet into a greenhouse where ideas could grow. But retrieval was just the beginning.
Part 2 of this journey has been about cultivation rather than collection.
Since my original post, I've thought a lot on that original system, tinkered a ton, and worked through how my intuition drew me to its primitive implementation. I've thought on how to evolve it from passive storage to an active thinking partner.
Here's what I've learned about building intelligence that compounds.
The Paradigm Shift: From Storage to Synthesis
Most knowledge systems, even AI-assisted ones, optimize for perfect retrieval. We've been trained by decades of Google to think in search terms. Find the right document. Surface the relevant passage. Even sophisticated approaches like retrieval-augmented generation (RAG) simply extend this pattern, hunting for relevant tokens in your knowledge base.
This approach is fundamentally limited. It misses why we retrieve information in the first place.
My first system fell into this trap. I built elaborate capture and retrieval mechanisms, proud of how quickly Claude Code I could surface any document. Then I noticed a pattern: every retrieval triggered immediate synthesis. I'd ask Claude, "Can you synthesize these ideas for my current situation?"
The retrieval was just step one. What I actually wanted was synthesis.
I don't care about finding the exact document from three months ago. I care about extracting the right insight, evolved and adapted to my current need.
The document is just storage format. The idea is what matters.
Traditional RAG systems use embeddings to find semantically similar text chunks. They ask, "What stored text best matches this query?" Synthesis asks instead, "What combination of my past thinking best serves my current intent?"
Synthesis asks instead, "What combination of my past thinking best serves my current intent?"
To enable this, I built trajectory logs into my system. These temporal maps capture how my thinking evolved. When approach A failed and I pivoted to approach B which succeeded, the system captures both outcomes and journey. This temporal understanding lets Claude contextualize insights based on what actually worked, not just textual similarity.
In addition to trajectory logs, I mixed this with a quasi-knowledge graph in Obsidian's Canvas mind-map format. I captured node-to-node relationships to help Claude Code crawl across the markdown files and better understand where it needed to travel to find the context it needed.
You optimize for conceptual connections instead of similarity scores. You synthesize themes instead of retrieving chunks. You reconstruct understanding instead of finding text.
When planning content strategy, I don't want old content plans. I want the system to understand which approaches led to engagement versus silence, how my audience evolved, what themes I've been building toward, and where natural next steps might lead.
I want to start from my last best attempt, remix it based on new context, and improve upon old flaws. I don't even need to see the old plan if the new one incorporates those learnings.
The shift from search to synthesis transforms a knowledge system from library to thinking partner. You cultivate intelligence instead of managing information.
The Five Laws of Contextual Intelligence
These principles separate systems that compound intelligence from those that merely accumulate information. Each emerged from practical experimentation, not theoretical design.
Law 1: Contextual Compounding
Every interaction should make the system smarter about your patterns, not just larger.
In practice, your system learns decision patterns without explicit programming. When I choose one content approach over another, the system notes the choice plus context: that week's events, my active goals, what had failed before. This compounds. Next time I face similar decisions, the system surfaces relevant context proactively.
Temporal awareness is key. A January decision might be wrong in June because context changed, not logic. My trajectory.md file captures this evolution, making past decisions useful rather than prescriptive.
Law 2: Cognitive Harmony
Your system should match how you think: associative, temporal, goal-driven rather than hierarchical or rigidly structured.
Embeddings often fail for personal knowledge because they match words, not thoughts. They find similarity, not significance. When I think about projects, I think in relationships. This idea led to that experiment which revealed this insight which connects to that goal.
The hub-and-spoke architecture reflects natural thinking. Stable zones (values, trajectory, memory, current goals) provide anchors. Flexible context islands form and reform based on current needs.
Law 3: Primacy of Intent
The system must understand why you're doing something and where you're headed, not just what you're doing.
Your trajectory file isn't a task list but a direction vector. When the system knows you're optimizing for depth over breadth this quarter, it filters opportunities accordingly. Understanding your trajectory lets it surface relevant patterns from past attempts.
This enables the "last best attempt" principle. You never start from scratch because the system reconstructs your best previous approach, adapted for current context.
Law 4: Manifestation Imperative
Insight without manifestation is entertainment. The system must bridge understanding to action.
Using Claude Code SDK or Vercel v0, the system creates what you need. It generates dashboards, builds integrations, creates workflows. Hub-spoke architecture covers 80% of use cases: context database, generative dashboards for visibility, simple agents for CRUD operations.
When I need to analyze client patterns, the system generates an interface for exploring them. When I identify a workflow gap, it creates the tool to fill it. The friction moved from capability to plumbing. The system handles complexity so you can focus on goals.
Law 5: Cultivator Principle
You guide growth through attention and feedback. The system learns from your corrections and choices.
Tinder-style feedback makes this practical. Instead of writing preference documents, you simply react: "this, not that." Pull out your phone, swipe through context validations, and you've taught current preferences without generating content.
My DSPy experiments (framework for programmatically optimizing LLM prompts) take this further. Conversational logs become training data for decision models. With cheap overnight batch inference, the system continuously improves its understanding of your patterns.
Technical Architecture That Enables This
The shift from retrieval to synthesis requires fundamentally different technical choices.
Context Islands Over Rigid Schema
Traditional knowledge bases force predetermined structure. Context islands emerge organically around needs. The hub-and-spoke model uses stable zones as consistent anchors while flexible context islands form around projects, themes, or investigations.
A client project might connect to technical learning, strategic insight, and process improvement simultaneously. Rigid schemas force you to choose one category. Context islands let all connections exist.
Hub-and-Spoke Search Pattern
At 500-2000 tokens per second, the system maps requests across the hub-spoke architecture efficiently.
It hits major hubs first (trajectory, recent logs, project outcomes), assessing relevance before exploring spokes. If trajectory shows active consulting work, it explores those context islands.
Otherwise, it moves to generation without wasting cycles.
Temporal Logs Beat Vector Search
Embeddings capture semantic similarity at a moment in time, missing how ideas evolve. A January insight might be semantically similar to a June insight, but January's version might be obsolete or reversed by experience.
Dated logs carry temporal context. The system knows what you thought, when, and in what sequence. This enables trajectory-aware synthesis. When you ask about content strategy, the system weights recent successes over old experiments, unless those old experiments have patterns worth revisiting.
Agentic Search at Scale
Claude Code spawning sub-agents revealed an important tradeoff:
Embeddings: 300ms response, high noise
Agentic search today: 60s response, high fidelity
Near-term projection: 3-6s response, same fidelity
Waiting one minute for the right answer beats instant clutter. Models approaching 2000 tokens/second represent 20x speed improvement. That 60-second synthesis becomes 3 seconds. The quality/speed tradeoff disappears.
Real Implementation: How This Actually Works
Let me show you a typical day with this system.
Morning Orientation (3 minutes)
I open Claude Code. Overnight synthesis has prepared a brief. Sub-agents reviewed my trajectory, logs, projects, and commitments. The synthesis agent wove these into context: where I left off, what needs attention, what changed overnight.
I start from my last best position.
Proactive Context Building
Throughout the day, micro-interactions teach the system. Walking to lunch, I see three quick prompts:
"Yesterday's client framework resonated. Develop this pattern?" Swipe right.
"You've been writing longer pieces. Intentional shift?" Swipe left.
This Tinder-style feedback requires no typing or context generation. Quick reactions teach current preferences through human reinforcement learning at its simplest.
Synthesis in Action
When I need a consulting proposal, I tell Claude: "New consulting proposal for context engine implementation."
The system instantly:
Maps my request across hub-spoke architecture
Assesses relevance at each hub before diving into spokes
Pulls successful proposal patterns
Identifies what worked in similar engagements
Checks current capacity from trajectory logs
Adapts my best previous approach to this client
Generates a first draft with my voice
The old proposal gets remixed, not retrieved. I edit synthesis, not fragments.
Generative Interfaces
When I need to track client patterns, I describe what I want. The system generates the interface: database for storage, adhoc dashboards for visibility in to the data, tool-calling agent for workflows. Twenty minutes from need to working tool.
The hub-and-spoke pattern applies here too. With my data acting as the spoke with tool calling agents for data manipulation, I can generate throwaway dashboards to better visualize whatever it is that I need. What remains useful persists, everything else drops away.
Week over week, the system learns my patterns. Month over month, operational velocity increases. Time from idea to artifact keeps shrinking.
Building the Future of Thought
The tools exist today. Open source models approach frontier capabilities at 10% cost. Claude Code turns natural language into working systems. SDKs generate interfaces from descriptions.
What's missing are products that embrace synthesis over storage, cultivation over collection, intelligence over information.
For builders: The opportunity is massive. Resist building the everything system. The best, most opinionated systems may offer 95% of possible features, but users access only 15% because there is friction in molding to a new tool. A tailored system starting at 30% capability but aligned to user needs grows rapidly in value, often exceeding any opinionated system.
For operators: Most knowledge workers need depth in specific areas, not comprehensive features they'll never use. A custom system handling your actual workflows at 100% beats a powerful system you use at 10%. Start experimenting. A few markdown files, Claude Code, and clear intent can transform your work within weeks.
I'm actively exploring these ideas and looking for others who see this future. If you're building in this space or want to implement these patterns in your workflow, reach out. Let's compare notes on what's working!
This is a very good read, I was tinkering to build a system that does something similar. I would love to connect and share notes, and maybe collaborate.