Disclaimer
Is this project open source? Yes
Is this project completely free? Yes
Does this project use AI beyond the author’s ability to comprehend how it works? No
How I ended up using Obsidian as the source of truth for a long-term AI-assisted creative workflow
I’ve been working on the same fantasy world, Polaris, for years.
It started as worldbuilding for tabletop RPGs, but over time it grew into something much larger: lore, geography, magic systems, races, creatures, game mechanics, weapons, professions, historical events, and countless decisions that depend on decisions made months or even years earlier.
Eventually, I ran into a problem that I think many people using AI for long-term projects will recognize:
AI is incredibly useful while working on an idea, but conversations are a terrible place to maintain the state of a large project.
A long chat can contain hundreds of useful decisions, abandoned ideas, revisions, misunderstandings, and conclusions.
Start a new conversation, and some of that context is gone.
Keep using the same conversation, and it becomes enormous and increasingly difficult for me to navigate.
Use memory, and another problem appears: memory isn’t necessarily the same thing as the current canonical state of the project.
So instead of trying to make the AI remember Polaris, I eventually arrived at a different idea:
The AI doesn’t need to remember the entire project. It needs to know where to find the relevant information when it needs it.
That changed how I use Obsidian.
Obsidian stopped being my note-taking app
When I first started looking into Obsidian + AI workflows, I wasn’t particularly impressed.
A lot of what I found seemed to boil down to:
Put your notes in Obsidian → connect an AI → ask questions about your notes.
Useful, certainly, but I couldn’t see why I should reorganize my workflow around that.
I already had ways to store information.
What I needed wasn’t another way to talk to my notes.
I needed a way to work with AI on a project that could become much larger than any practical context window without losing coherence over time.
I decided to experiment with Polaris.
Eventually, something interesting emerged.
I stopped treating Obsidian as something the AI helped me write in.
Instead, Obsidian became the persistent state of the project.
Chats became temporary workspaces.
That distinction ended up being much more important than I expected.
The workflow that emerged
Today, my workflow has four distinct components:
Me → creative direction and final decisions
ChatGPT → exploration, criticism, design and development
Claude → integration, editing and consistency
**Obsidian → canonical source of truth
**
It isn’t a multi-agent autonomous system.
There are no elaborate pipelines.
I am still involved in every important decision.
The useful part is simply that each component has a clearly defined responsibility.
ChatGPT is my design room
When I have an idea, problem or rough concept, I bring it to ChatGPT.
This is where I want freedom.
We can challenge assumptions, compare alternatives, explore consequences, throw away ideas, rebuild systems, or spend an hour discovering that the original idea was better after all.
The conversation doesn’t need to be clean.
It doesn’t even need to remain useful afterward.
Its purpose is thinking.
Once we reach something I consider mature enough, we produce a structured report containing the decisions and reasoning that should survive the conversation.
That report is the artifact passed to the next stage.
Claude is the maintainer
Claude works differently in this setup because it has access to the Obsidian vault.
When I give it the report, its job isn’t primarily to invent the concept again.
Its job is to ask:
- Where does this information belong?
- What existing documents are affected?
- Does this contradict something already established?
- Which references need to change?
- Are there related concepts that should be updated?
- Does the index still represent what the actual files say?
Then it edits the vault.
This distinction became surprisingly valuable.
ChatGPT can be exploratory without worrying about contaminating the project with every hypothesis we discuss.
Claude can be conservative because it receives something that has already gone through the creative process.
And I remain the person deciding what becomes canon.
Obsidian is not memory. It is state.
This is probably the most important distinction I’ve learned from the experiment.
A conversation records process.
Imagine a discussion where we go through:
Idea A
↓
Problem with A
↓
Idea B
↓
Maybe C?
↓
Actually, combine A and B
↓
Final solution D
The conversation contains all of those states.
But the project only needs:
D
If six months later an AI retrieves part of that conversation, it might encounter B or C without understanding that those ideas were abandoned.
The Obsidian document doesn’t have that problem.
It represents what is currently true.
So my hierarchy is essentially:
Current vault > old conversations > AI memory
If an old conversation says one thing and the current document says another, the document wins.
This also means conversations can eventually become disposable.
I don’t need 50 giant chats to function as the memory of Polaris.
The useful information should eventually leave the conversation and become part of the project.
Context window as RAM, vault as storage
I asked Claude what it was like to work this way, and it gave me an analogy I really liked.
The context window behaves somewhat like RAM:
Fast, limited, temporary and expensive.
The vault behaves more like storage:
Large, persistent and searchable.
The important part isn’t loading the entire vault into the context window.
It is having enough orientation to know what to retrieve.
For example, Claude doesn’t need every weapon, creature, profession and magical rule loaded simultaneously when editing one mechanic.
It needs a map of the project and the ability to retrieve the relevant files.
This means the practical size of Polaris is no longer tightly coupled to the context window.
The vault can keep growing.
The model only needs to inspect the relevant neighborhood of information for the current task.
But “infinite context” creates a different problem
When I asked Claude to rate this workflow from 0 to 100, it gave it:
88/100.
What I found more interesting was why it didn’t give 100.
Its main criticism was essentially:
The bottleneck is no longer memory. It is coherence.
If information is spread across many persistent files, forgetting something becomes less dangerous.
But now several files can contradict each other.
You trade:
“What did we forget?”
for:
“What became desynchronized?”
And that’s a real problem.
If a concept appears in three documents and we change its definition, all three may need to be updated.
There’s also another subtle problem: the index can lie.
We use summary/index information to help Claude navigate the vault, but an index represents what was true when it was written.
The actual document remains the source of truth.
So the workflow requires a simple discipline:
Indexes point toward truth. Files contain truth.
When they disagree, update the index.
Why I don’t want more agents
Once this started working, the obvious temptation was to automate more.
Add specialized agents.
Add autonomous research.
Add validation pipelines.
Add databases.
Add scripts.
Add GitHub workflows.
Maybe some of those things would improve the system.
But I realized something important:
The current bottleneck is me.
Not Claude’s token limit.
Not ChatGPT’s output speed.
Not Obsidian’s storage.
My own creative energy.
I can spend an evening deeply developing one part of Polaris, but I’m not going to do that eight hours a day, five days a week.
And that’s fine.
So optimizing the system for maximum throughput would solve a problem I don’t have.
If Claude has spare context and tokens, I’d rather let it spend more of them checking consistency.
An 88/100 workflow that requires almost no maintenance is more useful to me than a 95/100 workflow that becomes another project I have to manage.
Why I think the small structure works
There is another advantage I didn’t anticipate:
I can still supervise everything.
I’m not delegating worldbuilding to a swarm of autonomous agents generating hundreds of changes.
The AI dramatically increases how much intellectual and operational work can happen around an idea, but the number of canonical decisions remains manageable.
That gives me leverage without losing authorship.
The roles remain very clear:
Me “What should this project become?”
Creative AI “What are the possibilities, problems and consequences?”
Maintenance AI “How does this decision affect what already exists?”
Obsidian “What is currently true?”
I think this clarity is more valuable than adding another layer of intelligence.
What I would improve
There is one thing I would change immediately if it became easy:
I would give the creative AI read-only access to the vault.
Currently, ChatGPT and I can develop ideas very effectively, but I still need to provide relevant context manually.
I don’t want it editing the vault.
I actually think keeping creative exploration separated from canonical editing is useful.
But I would like it to be able to retrieve current information before reasoning about a problem.
A strange analogy: hiring people
The more I use this workflow, the less I think about AI “memory.”
If I hired someone to work on Polaris, I wouldn’t expect them to memorize the entire project before becoming useful.
I’d give them access to the documentation.
They would learn the important concepts, understand how the project is organized, and consult specific information when necessary.
A good collaborator doesn’t need to remember every document.
They need to know:
where the knowledge lives, how to retrieve it, and which source has authority.
That’s increasingly how I think AI should interact with long-term projects.
Maybe the future isn’t an AI that remembers everything about me.
Maybe it’s an AI that can enter a specific knowledge environment, understand its structure, access exactly what I authorized, and become competent within it.
For Polaris, that knowledge environment happens to be an Obsidian vault.
What surprised me most
I started experimenting with Obsidian + AI because I wanted to see whether it could help manage a large worldbuilding project.
I expected better retrieval.
Maybe faster editing.
What I didn’t expect was that the most useful outcome would be a division of cognitive responsibilities.
I don’t need one AI that remembers, creates, critiques, edits, organizes and maintains everything.
I need different parts of the workflow to be good at different things.
And I need one persistent place that tells all of them what is currently true.
For me, that place became Obsidian.
The result isn’t perfect.
Claude rated it 88/100, and I think that’s fair.
But I’ve reached the point where the tools usually have more capacity than I have creative energy to use.
For a long-term creative project, that’s a very good problem to have.
Questions for the community
I’m curious whether anyone here has ended up with a similar architecture, especially for projects that have been evolving for months or years.
How do you handle the distinction between conversation history and canonical project state?
And for people using AI directly with large vaults: has consistency between documents become a bigger problem than retrieval itself?
I’m particularly interested in approaches that remain simple. I’m aware this could probably be pushed much further with custom RAG systems, scripts, Git, validation, agents, etc., but one thing I value about the current setup is that I don’t have to maintain the machinery that helps me maintain the project.