chatgpt

OpenAI just dropped a massive new feature upgrade — and it’s going to change the way so many of us use ChatGPT forever.

Projects:

You know, we’ve been asking for ChatGPT to allow pinned chats for decades.

Like this is just really basic stuff every chatbot should have but they just refused to add it — even though it’d be really easy to implement.

But now we have Projects and it’s way better — not just “pinning” chats but structuring them in groups — to keep things tidy and make your work with AI more efficient.

But it goes even beyond chats.

Projects work like folders for your AI chats.

You can create them, name them, and even give them cool icons to keep things visually organized.

But Projects are not just dumb storage containers — you can add specialized instructions to a project to control exactly how ChatGPT responds in every single chat in the project.

You can add files that every chat in the project can use as context — incredible.

Even other chats provide context for new chats — you can drag and drop older chats into Projects to keep the flow going and avoid starting every time.

Maybe like me you already have something like Notion to manage tasks…

But this is really great what you’re doing revolves around ChatGPT — like long-term brainstorming or research.

It’s much easier to jump back into your work with all related chats and files grouped in one spot.

ChatGPT becomes more like a project partner than just a chatbot.

Not free for now though but soon — I wonder why? It should be a really easy code change to do that 🤔

For now Projects are only available to Plus, Pro, and Teams users. Enterprise and Edu users will get access early next year.

This feature is part of OpenAI’s holiday release spree called “Ship-mas.”

Along with Projects they’ve launched other cool tools like the Sora video generator and a side-by-side Canvas view for ChatGPT.

It’s like a December tech gift bundle for us.

What’s next?

We’re still expecting a new text generation to supersede GPT 4.5 from OpenAI this December — let’s see what happens.

OpenAI is showing they’re serious about making AI more practical and user-friendly.

Features like Projects are just the beginning. As they roll out more tool ChatGPT is quickly evolving from a simple chatbot into an essential productivity companion.

Projects make managing your AI interactions smoother, smarter, and way more organized.

Def worth checking out.

Yes it’s ChatGPT, the underrated + overrated chatbot used by self-proclaimed AI experts to promote “advanced skills” like prompt engineering.

But this isn’t a ChatGPT post about AI. It’s about JavaScript and algorithms…

Message editing; a valuable feature you see in every popular chatbot:

• Edit our message: No one is perfect and we all make mistakes, or we want to branch off on a different conversation from an earlier point.
• Edit AI message: Typically by regeneration to get varying responses, especially useful for creative tasks.

But ChatGPT is currently the only chatbot that saves your earlier conversation branches whenever you edit messages.

Other chatbots avoid doing this, probably due to the added complexity involved, as we’ll see.

OpenConvo is my fork of Chatbot UI v1, and this conversation branching feature was one of the key things I added to the fork — the only reason I made the fork.

Today, let’s put ourselves in the shoes of the OpenAI developers, and see how to bring this feature into life (ChatGPT’s life).

Modify the chatbot to allow storing previous user and AI messages after editing or regeneration. Users can navigate to any message sent at any time in the chat and view the resulting conversation branch and sub-branches that resulted from that message.

Just before we start this feature we’ll probably have been storing the convo as a simple list of messages👇. It’s just an ever-growing list that keeps increasing.

The 3 main functional requirements we’re concerned with, and what they currently do in a sample React app.

• Add new message: add item to list.
• Edit message: Delete this and all succeeding messages, then Add new message with edited content.
• Display messages: Transform list to JSX array with your usual data -> UI element mapping.

But now with the conversation branching feature, we’re going have some key sub-requirements stopping us from using the same implementation

• Every message has sibling messages to left and/or right.
• Every message has parent and child message to top and/or bottom.

We can’t use simple lists to store the messages anymore; we want something that easily gives us that branching functionality without us trying to be too smart.

If you’re done a little Algo/DS you’ll instantly see that the messages are in a tree-like structure. And one great way to implement trees is with: Linked Lists.

• Every conversation message is a node. A single “head” node begins the conversation.
• Every node has 4 pointers: prevSibling, nextSibling, parent, and child (←→ ↑ ↓) . Siblings are all on the same tree level.
• Every level has an active node, representing the message the user can see at that branch.

We either branch right by editing/regenerating:

Or we branch down by entering a new message or getting a response:

The most important algorithm for this conversation branching feature is the graph transversal. Dearly needed to add and display the messages.

Here’s pseudocode for the full-depth transversal to active conversation branch’s latest message:

1. Set current node to conversation head (always the same) (level 1 node)
2. Look for the active node at current node’s level and re-set current node to it. This changes whenever the user navigates with the left/right arrows.
3. If current node has a child, re-set current node to it. Else return current node.
4. Rinse and repeat: Go to step 2.

Add new message

So when the user adds a new message we travel to the latest message and add a child to it to extend the current branch.

If it’s a new convo, then we just set the head node to this new message instead.

Edit message / regenerate response

There’s no need for transversal because we get the node from the message ID in a “message edited” event listener.

At the node we find its latest/right-most sibling and add another sibling.

Display messages

Pretty straightforward: travel down all the active nodes in the conversation and read their info for display:

In OpenConvo I added each node to a simple list to transform to JSX for display in the web app:

View previous messages

No point in this branching feature if users can’t see their previous message, is there?

To view the previous messages we simply change the active message to the left or right sibling (we’re just attending to another of our children, but we love them all equally).

With this we’ve successfully added the conversation branching feature.

Another well-known way to to represent graphs/trees is an array of lists; that may have an easier (or harder) way to implement this.