Background: After an in-depth conversation with AI (in phone mode), this article was generated by the AI itself based on our questions and answers. It is also my current, relatively superficial understanding of AI based on my own knowledge. If you have better solutions, vigorous discussion is welcome—as long as we keep it peaceful.
From Linear Q&A to Collaborative Thinking: Rethinking How We Interact with AI
Introduction: Do We Really Need an AI That “Answers More Completely”?
As generative AI moves beyond simple information queries into learning, writing, programming, research, and project development, the relationship between people and AI is changing. Early AI usage was very simple: “I have a question → AI gives me an answer.” This model works naturally for search-oriented tasks. But when someone begins collaborating with AI continuously for dozens of minutes or even several hours, problems emerge. This is especially true when AI is used for:
- Learning a complex body of knowledge;
- Discussing a long-term project;
- Doing Vibe Coding;
- Developing an AI Agent;
- Brainstorming creatively;
- Analyzing a complex problem;
- Making long-term decisions.
At this point, the “question-and-answer” chat model begins to reveal a fundamental problem: human thinking is not linear, but chat interfaces are still basically linear. This creates several related problems:
- Users constantly generate new associations;
- New associations interrupt the original discussion;
- The original thread gradually disappears;
- AI’s long answers create additional cognitive burden;
- Both the user and AI may forget unfinished content;
- Eventually, the chat history becomes longer and longer, while the actual structure of thought becomes increasingly vague.
Therefore, I would like to propose a simple idea: Future AI conversations should not maintain only “chat history”; they should also maintain “conversation state” and “thought structure.”
1. A Very Common AI Use Case
Suppose a user is learning about AI Agents. They ask, “How does an Agent actually work?” AI begins explaining: An Agent can be understood as… Halfway through, the user suddenly thinks, “Wait, what’s the difference between that and a traditional workflow?” AI answers this new question. The user then thinks, “What if it calls tools?” Then: “Does MCP count as part of this?” Then: “Could I build one myself?” At this point, an original question has become:
Agent
│
├── Workflow
├── Tool Calling
├── MCP
├── Coding
└── Project
This is not necessarily a bad thing. On the contrary, it may mean that the user is developing genuine understanding. The problem is that existing chat interfaces generally do not provide first-class support for this kind of thought structure.
2. Going “Off Topic” Is Sometimes Creativity
If someone suddenly goes from “Agent” to “tool calling,” then to “programming,” and then to “building a project,” we are quick to say, “They’ve gone off topic.” But from a cognitive perspective, this may be:
Concept A
↓
Activates concept B
↓
Discovers the relationship between A and B
↓
Generates new hypothesis C
In other words: Association itself may be thinking. The real question is not “How do we prevent all branches?” but rather: How do we allow branches to emerge without losing the main thread?
3. A Structural Problem with Current Chat Models
Current chat histories can broadly be understood as:
User 1
↓
AI 1
↓
User 2
↓
AI 2
↓
User 3
↓
AI 3
They are very good at preserving “what has happened,” but they do not naturally preserve “what is happening.” These are actually very different things.
4. “Having Been Said” Does Not Mean “Having Been Thought Through”
There is an easily overlooked problem here. Suppose AI is preparing an answer internally:
A
B
C
D
E
But after A and B, the user suddenly interrupts: “Wait, I just thought of something.” The final conversation record contains only:
A
B
The conversation then moves to another topic:
X
Y
Z
If the user says “Let’s go back to that” some time later, AI may be able to reconstruct C, D, and E through contextual reasoning. But that is not the same as AI having previously and explicitly maintained C, D, and E as content still waiting to be delivered. This is a layer that future conversation systems should consider: Pending Reasoning / Unfinished Response.
5. Therefore, “Conversation State” Should Be Richer Than Chat History
If we treat a long-term AI conversation as a system, it should maintain at least the following:
1. Main Thread
The current main thread. For example: how to establish an AI learning path suited to me.
2. Current Node
The specific issue currently being discussed. For example: why strong resistance arises when difficulties are encountered.
3. Pending Response
The answer AI had not finished when it was interrupted. For example:
Already explained:
A, B
Not yet expanded:
C, D
4. User Branches
New branches generated by the user. For example:
B1: Vibe Coding
B2: Multiple projects in parallel
B3: Capturing inspiration
B4: AI conversation protocols
5. Paused Threads
Discussions that have been temporarily suspended.
6. Next Action
The most natural next step.
This is already beginning to resemble a Conversation State Machine, rather than merely Chat History.
6. From “Chat” to a “Tree of Thought”
Taking this idea further, I believe chat interfaces could expand from a “timeline” into a “tree of thought.” For example:
Main Question
│
┌────────────────┼────────────────┐
↓ ↓ ↓
Branch A Branch B Branch C
│ │
A1 / A2 B1
But there is a very important design principle here: A tree of thought should not require users to manually manage a second productivity application. If users have to create nodes, add labels, build links, organize categories, and modify the structure every time, the system will quickly become a new burden. The ideal state should be: AI maintains the structure automatically, while the user focuses only on thinking.
7. What Does This Have to Do with Vibe Coding?
Actually, quite a lot. Many Vibe Coding workflows are undergoing a change: AI can write more and more code. A user may only need to tell AI, “Build a website,” and AI can begin creating files, writing code, modifying components, calling APIs, fixing bugs, and running tests. But this creates another problem: the speed of implementation exceeds the user’s speed of understanding. If AI is writing in a language, framework, or architecture the user has never encountered, the user may eventually end up thinking: “I know what I want AI to do, but I don’t know how it actually did it.” This creates a new kind of “cognitive black box.”
8. “Waiting Time” in Vibe Coding Also Deserves Redesign
For example, AI is generating code. The user may have two choices.
Choice A: Wait Completely
AI generates; the user does nothing.
Choice B: Immediately Switch to Another Project
AI runs Vibe Coding while the user studies mathematics, watches a course, or works on another project.
The second option appears highly efficient. But if it happens frequently:
Project A
↓
Project B
↓
Mathematics
↓
Project A
↓
Project C
↓
Project B
The user has to reload the context repeatedly. This creates a Context Switching Cost that can exhaust the human brain.
9. But We Must Not Go to the Other Extreme
“Do not switch tasks while AI is waiting” is not an absolute rule. If AI is going to run for ten minutes, sitting there doing nothing may not be reasonable. The real question is: What is the unit of switching? If AI only needs to wait a few dozen seconds, it is not worth starting another complex task. If AI needs to wait ten minutes, other activities can be arranged. But ideally: prioritize switching to tasks within the same project. For example, while AI is generating an Agent module, you can read relevant documentation, write tests, think about interfaces, review requirements, or record questions that need verification. This switches tasks rather than the entire cognitive context.
10. The Most Important Sentence for AI Coding
I think it can be summarized as: AI can implement things faster than I can, but it cannot understand them faster than I can for too long. This does not mean that every line of code must be written personally. It means that the core path must gradually enter the user’s own sphere of understanding. For example, after AI writes a module, the user should gradually be able to answer at least:
- What problem does it solve?
- Why is this module needed?
- What is the input?
- What is the output?
- What does it depend on?
- If something goes wrong, where should I roughly look?
- Why was this design chosen?
Otherwise, the larger the codebase becomes, the greater the cognitive debt may be.
11. Returning to the Original Question: Why Do Users Keep Having New Ideas?
There is also an interesting cognitive aspect here. When someone is learning A and suddenly thinks of B, B usually does not appear out of nowhere. It may be:
Existing knowledge A
+
New information X
↓
Connection formed
↓
New hypothesis B
Therefore: Associative thinking is itself a productive capability. The real problem is that working memory cannot hold too many things at once. Thus:
A
↓
B
↓
C
↓
D
By the time D appears, A may already have disappeared. This explains why many people feel, “I just thought of something really good,” only to find a few seconds later that they “can’t remember it.”
12. Why Is “Taking Notes” Not Necessarily the Perfect Answer?
Because if every thought requires “stop → open an app → write it out completely → categorize it → tag it,” the act of recording itself interrupts thinking. This creates a cycle: “To avoid forgetting → start recording → recording interrupts thinking → forget the original thought.” A more reasonable mechanism should therefore be: low-cost capture, rather than complete recording. For example:
“AI waiting”
“Not yet output”
“Multiple projects”
“Agent conversation”
All that is needed is a “hook” capable of bringing the context back.
13. The Truly Ideal AI Should Take on Part of Our “External Working Memory”
This may be one of the areas where AI can provide the greatest value. Traditional note-taking software requires people to record things actively. In the future, AI could automatically identify and temporarily store new branches as they arise. For example, when a user says, “Wait, I just thought of something…” AI could automatically determine that this is a new thought node and create the following in the background:
Branch #12
Topic: AI conversation protocols
Source: Generated from “capturing inspiration”
Status: Not yet expanded
The user would not even need to manage it immediately.
14. “Conversation” Could Thus Become a Dynamic System
In the future, a long AI conversation might not be “Message 1, Message 2, Message 3, Message 4… Message 1000,” but rather:
Current Main Thread
│
├── Completed
│
├── Current Question
│
├── To Discuss
│
├── User Branches
│
├── AI Unfinished Content
│
└── Paused Nodes
What the user sees can still be a chat window, but what AI maintains behind the scenes is: thought state.
15. This Also Explains Why We Need Conversation Protocols
If this capability is not yet natively supported by every product, users can simulate it through a protocol. For example, at the beginning of a new conversation, tell AI: “Use collaborative thinking mode for this conversation. Maintain the main thread and branches. I may interrupt you frequently. My interruptions do not necessarily mean that I want to end the current topic. If I say ‘open a branch,’ save the current position in the main thread. If I say ‘return to the main thread,’ restore the previously paused position. If I say ‘continue what was unfinished,’ resume the previously unfinished answer. If I present a new idea, first determine whether it extends the main thread or forms a new branch. Do not produce extremely long answers all at once just for the sake of completeness. Proceed in sections according to thought nodes. Maintain the current main thread, current node, paused branches, and pending questions.” The value of this is not how elegantly the prompt is written, but that: it defines how people and AI collaborate.
16. From Prompt to Protocol
I consider this distinction very important.
Prompt
“Please be a good learning assistant.” This describes what AI should be like.
Protocol
“How should new questions be handled?” “When should we pause?” “When should we resume?” “How should branches be handled?” “What should happen when AI has an unfinished answer?” This describes: how people and AI work together. If AI truly enters complex workflows in the future, I believe the latter will become increasingly important.
17. A Minimal Viable Protocol
No complex system is even necessary. Five actions are enough:
MAIN
BRANCH
PAUSE
RESUME
SUMMARY
- MAIN: The current main thread.
- BRANCH: Enter a new branch.
- PAUSE: Pause the current content.
- RESUME: Resume previous content.
- SUMMARY: Reorganize the current thought structure.
This alone could solve a considerable portion of the problem.
18. The Real Challenge Is Not the Model, but Interaction Design
Today, many AI products compete on larger models, longer contexts, stronger reasoning, faster speeds, and better tool calling. These are certainly important. But another frequently overlooked question is: When a person uses AI continuously for an hour, how should AI think together with that person? This is a completely different question. “Answering a question” and “jointly advancing an evolving thought process” are two different interaction paradigms.
19. I Believe Future AI May Develop Through Three Stages
Stage One: Answer Machine
You ask, I answer. Core metric: answer quality.
Stage Two: Agent
You set a goal, I execute it. Core metric: task completion rate.
Stage Three: Thinking Partner
We think, plan, execute, and review together. Core metric: long-term collaboration quality. AI must understand not only “what the user said,” but also “what the user is thinking.”
20. This Model Has Another Important Value
It applies not only to using AI with AI, but also to learning, programming, writing, product design, scientific research, creativity, project management, and long-term decision-making. These tasks share a common characteristic: the problem is not clearly defined all at once. The real process is often:
Problem
↓
Attempt
↓
Discover a new problem
↓
Change understanding
↓
Generate a new hypothesis
↓
Return to the original problem
↓
Redefine the problem
If AI can only handle “one problem → one answer,” it will struggle to genuinely participate in this process.
21. One Final Question: What Should AI Remember for Me?
I believe it should not prioritize all information or the entire chat history. Instead, it should prioritize remembering:
- What are we currently trying to solve?
- Why are we solving it?
- What conclusions have we reached so far?
- Which questions remain unresolved?
- Which branches have been temporarily paused?
- Does AI have any unfinished answers?
- Has the user just had an important association?
These seven things are closer to genuine long-term collaboration than the length of the chat history.
Conclusion: Perhaps What We Lack Is Not a Longer Context, but a Better “Thought State”
In the past, we often discussed whether AI’s context window could become longer. But today’s experience makes me feel that there is a more fundamental question: A long context does not mean a clear thought structure. An AI with hundreds of thousands or even millions of tokens of context may still only know “these are things the user has said” without knowing “which main thread are we actually discussing right now?” Conversely, an AI capable of maintaining the main thread, branches, pauses, resumption, unfinished answers, user associations, and next steps may be easier to collaborate with even in very long discussions. Therefore, an important future direction for AI may not simply be: make AI remember more. It may be: make AI understand more clearly what we are thinking about together. Because when people and AI collaborate over the long term, what matters most is never only the final answer. It is also how a question arose, why an idea appeared, which branch is worth pursuing, which question can be set aside temporarily, and—where we should continue when we come back next time. Perhaps this is the real step from “AI Q&A” to “AI collaborative thinking.”