When AI manages your project’s documentation, adding legacy documents seems straightforward—just drop them in the folder. But this silent import creates an invisible problem: the AI can’t distinguish between its own work and external materials. Everything becomes equally authoritative, and your context gets polluted.
There’s only one safe way to import legacy documentation: require the AI to question it first.
Why Silent Imports Always Fail
When you silently add a legacy document to an AI-managed project, you create ambiguity at the source of truth level:
Project folder contains:
- API_Design.md (AI created yesterday)
- Database_Schema.md (AI created last week)
- Authentication.md (you just added from 2023)
The AI sees three equally authoritative documents. It doesn’…
When AI manages your project’s documentation, adding legacy documents seems straightforward—just drop them in the folder. But this silent import creates an invisible problem: the AI can’t distinguish between its own work and external materials. Everything becomes equally authoritative, and your context gets polluted.
There’s only one safe way to import legacy documentation: require the AI to question it first.
Why Silent Imports Always Fail
When you silently add a legacy document to an AI-managed project, you create ambiguity at the source of truth level:
Project folder contains:
- API_Design.md (AI created yesterday)
- Database_Schema.md (AI created last week)
- Authentication.md (you just added from 2023)
The AI sees three equally authoritative documents. It doesn’t know:
- Which one is current
- Which reflects the actual project context
- Where conflicts should be resolved
When contradictions emerge, the AI can’t make informed decisions. It might defer to the legacy doc because it’s "more detailed," or ignore it because it conflicts with recent work. Either way, your context is compromised.
And here’s the critical problem: neither you nor the AI can identify the source of confusion. The AI doesn’t know an external document was added. You don’t know which part of the legacy doc is creating conflicts. The context degrades invisibly, and debugging becomes impossible.
The Question-Driven Protocol
When importing any external document, always use this pattern:
"Document created at <time>. Review it and ask questions before use."
This simple instruction accomplishes three things:
1. Declares External Origin
The AI recognizes this isn’t its own work. It’s a reference document that needs evaluation.
2. Triggers Active Verification
Rather than passively accepting content, the AI actively examines it against current context.
3. Opens Integration Dialogue
Questions create opportunities to bridge old and new understanding.
How Questions Bridge Contexts
Legacy documents always carry assumptions from their creation context—different tools, different time periods, different understanding. Questions are how you make these assumptions explicit.
When the AI asks questions, it’s identifying gaps between contexts:
AI: "This design uses basic authentication. Current best
practice is OAuth 2.0 with PKCE. Should we update?"
AI: "The schema assumes single-tenant. Your recent work
suggests multi-tenant. Which direction?"
AI: "This references v1.2 of the API. We're on v2.0 now.
Are these concepts still valid?"
Each question is a bridge. Through dialogue, you integrate what’s still valid and identify what needs updating. The context stays coherent because contradictions are resolved explicitly, not left to chance.
Real Example: The Six-Month-Old Spec
Earlier this year, I created a specification document using ChatGPT. When revisiting the project months later, instead of silently adding it to the codebase, I instructed:
"Specification I created in June. Review the content and ask if you find any issues."
The AI identified coverage gaps that would have caused problems later. Through the question dialogue, we determined the spec was incomplete for current needs.
If I had silently imported it, the AI would have treated it as authoritative—building on incomplete foundations. The resulting implementation would have seemed correct until the missing pieces caused failures.
The question process prevented this. The legacy doc was evaluated, found wanting, and we moved forward with current understanding intact.
Why This Is The Only Way
You might think other approaches work:
"Just read this document"
→ AI accepts it passively, doesn’t verify against context
"Use this as reference"
→ AI doesn’t know how to weight it against existing knowledge
"Incorporate this into the design"
→ AI forces integration without resolving conflicts
None of these preserve context integrity. They all assume the legacy document can be safely added without examination. That assumption is exactly how context collapses.
But legacy documents are always problematic—they come from different contexts, different times, different assumptions. The only safe way to import them is to force explicit verification through questions.
When the AI questions legacy content, it’s doing the essential work of context integration. It’s identifying where old and new understanding diverge, and creating opportunities for you to resolve those divergences deliberately.
Skip the questions, and you’re gambling that the divergences won’t matter. They always do.
The principle is simple: Legacy documents pollute context unless questioned first. Question-driven import isn’t just best practice—it’s the only practice that preserves context integrity.
When working with AI-managed documentation, protect your context. Make the AI question everything that comes from outside.
This article is part of the "Beyond prompt engineering" series, exploring systematic approaches to AI development collaboration.