In the last edition, I said I was going to learn software engineering properly.
Fundamentals first. Build things with my own hands. Break them somewhere safe. Understand what the AI was doing instead of simply being impressed that it did anything at all.
So that is what I did.
It helped. Of course it helped. I understood more, spotted weak foundations earlier, and became less willing to call something finished because it had worked once.
But technical knowledge was not the only gap.
The conversation that split
It started as one conversation in one chat.
I was trying to work out what came next for Late2AI.
That one conversation produced three different ideas.
One was about what Late2AI could become. One was about how to run it over the next 90 days. One was about what the next Late2AI editions were actually about.
Three useful ideas, all coming from the same conversation.
Each idea needed more room, so I did what felt sensible. I split them out.
Three ideas became three chats. Each chat produced its own document: a strategic brief, an operating plan and an editorial direction.
It looked organised.
It was also where the problem began.
Three chats that could not talk
Each chat knew its own branch.
The strategy chat understood where Late2AI might go. The planning chat understood dates, platforms and publishing rhythm. The editorial chat understood the personal story I was trying to tell.
But none of them knew what the other two had learned after the split.
When an idea changed in the planning conversation, the strategy conversation did not change with it. When the editorial direction became clearer, the plan did not automatically understand why. Each chat continued confidently from the version of the conversation it had last seen.
They all came from the same root.
They just evolved separately.
The conflict only became obvious when I put the three documents back next to each other.
Different dates. Different publishing rhythms. Different assumptions about the website, the newsletter and what had already been decided.
None of the documents was entirely wrong. Each was an honest record of one branch.
The problem was that the branches had stopped talking.
A line and a graph
An AI chat is linear.
I say something. It answers. I say the next thing. It answers again. The entire conversation becomes a queue, however complicated the subject becomes.
I do not think like that.
I think in branches and graphs.
One question creates three more. One needs answering now. One belongs somewhere else. One looks irrelevant until a later fact makes it important again. Two branches may eventually become the same problem. Another may need to be rejected without being forgotten, because the reason we rejected it still matters.
The branches are separate, but they are still connected.
That connection is the part the chats lost.
The original words were still there. The three documents were still there. Every individual conversation looked coherent when I opened it.
What had disappeared was the shared evolution between them.
What I blamed
For a long time, I treated this as another technical weakness.
Maybe my prompts were not good enough. Maybe each conversation needed more context. Maybe the model needed better memory. Maybe I still did not understand enough about how these systems worked.
So I tried the usual fixes.
Better prompts produced cleaner answers. More context produced longer answers. A new chat gave me room to follow one branch but separated it from the others. A long chat kept everything together but buried the structure.
I was choosing between one crowded queue and several disconnected ones.
That was when the problem finally became clear enough to say plainly:
My ideas branch. The chat wants a queue.
A transcript can preserve the order in which I typed my thoughts.
It cannot, by itself, preserve their shape.
The documents were the symptom
I originally asked what seemed like a document question:
Do we make a master document? Do we align the documents? What do we do?
We did not create the master document.
We kept the three sources. We recorded their conflicts separately. We made explicit decisions where a decision was needed, and built a current plan that pointed back to the evidence instead of pretending the evidence had always agreed.
That fixed the immediate mess.
It did not solve the deeper problem. It contained the damage after three conversations had already evolved apart.
What I actually needed was not one enormous document or one endless chat.
I needed each branch to remember where it came from. I needed a change in one conversation to be able to affect the others. I needed to know why something had been decided, which alternatives had been rejected, which questions were still open and which later fact had changed an earlier conclusion.
That is more than AI memory.
It is continuity of understanding.
The problem underneath
The first 15 editions were mostly about a visible question: can I build with AI?
The answer was yes. Sometimes surprisingly well. Sometimes very badly. Often both in the same week.
But building was never the whole problem.
The next question is whether I can think with AI without flattening a graph into the order its branches happened to reach a chat box.
That is the question I am following now.
Not with another clever agent. Not with a grand framework. With one conversation that produced three ideas, three chats that stopped sharing what they learned, and three documents that exposed the gap between them.
The conversations had evolved.
They had just evolved apart.