23 Ways ChatGPT Still Sucks After 3 years (And How to Fix Them)
Based on AI News & Strategy Daily | Nate B Jones's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
Chatbots need to shift from idea generation to workbench behavior: shareable, shippable outputs that teams can collaborate on and maintain.
Briefing
Chatbots are still strong at generating ideas but weak at turning those ideas into shippable work—and the gap shows up across sharing, intent, exports, trust, retrieval, and day-to-day usability. After roughly three years of rapid progress, the biggest frustration isn’t raw model quality; it’s product design. People can’t easily collaborate on the same thread, can’t branch experiments without breaking the original, and can’t reliably carry outputs into the tools where work actually gets done.
Collaboration and sharing are the first fault line. Users want to share a relevant slice of a conversation with someone else, start a new thread from that point, and keep editing together—rather than being locked into a single, linear chat. The current workflow often becomes “copy paste ping pong,” with tasks and decisions buried in scrollback. The same problem appears when trying to point others to a single “banger” answer: instead of a simple permalink to one message, users must share the entire back-and-forth to preserve context.
Intent handling is another bottleneck. Instead of typing a gist and letting the system convert it into a clean, structured request, users often have to prompt extensively to get reliable results. The desired future is a chat experience that dynamically generates interfaces—checkboxes, variable controls, and guided inputs—so people can confirm what matters without writing perfect prompts. Alongside that, users want control over “agenticness,” meaning the ability to dial how autonomous the assistant should be for a given task: short loops for quick back-and-forth, or longer “work for hours” behavior when appropriate.
Even when answers look right, turning them into real work remains fragile. Exports to tools like Docs and Notion frequently break formatting, especially code blocks and headings, forcing users to spend more time repairing output than producing it. Action items also need better surfacing—highlighted, calendar-aware, and visually tracked—rather than disappearing into chat. For stakeholders, there’s a demand for publishable, read-only summaries that show the best parts of a messy thread without exposing every intermediate step.
Keeping outputs updated without babysitting is still underdeveloped. Users want scheduled or source-aware updates that refresh automatically when underlying information changes, plus “diffs” that show what changed since the last run rather than dumping everything again. Trust and control also lag: people want clear receipts for claims (verifiable sources and the ability to validate URLs), transparent memory behavior (which memories are being pulled and editable), and better controls for sensitive work such as thread sharing and regional access.
Finally, retrieval and quality-of-life features are missing. Finished work gets buried because chats aren’t automatically organized into projects, pinned at the top, or searchable with context-aware “global search” inside a conversation. Users also want structured input modes—like dynamically generated forms when uploading PDFs—better tone controls with saved “fingerprints,” and quick restore/version rollback for canvases and artifacts. The overall prescription is consistent: move from clever chat toward a real workbench that’s shareable, shippable, self-maintaining, and easier to reuse—so the assistant doesn’t just talk, but helps teams build and maintain outcomes over time.
Cornell Notes
The core complaint is that modern chatbots generate ideas well but still struggle to convert them into durable, collaborative work. The most repeated pain points are product-level: sharing only works as whole-thread copy/paste, intent requires long prompting instead of structured, dynamically generated inputs, and exports often break formatting—especially code. Users also want better control loops: adjustable agenticness, source-aware updates with diffs, transparent citations (“receipts”), and editable memory. Finally, retrieval and usability lag, with weak project organization, limited in-chat search, clunky tone controls, and missing version rollback. The result is a workflow that feels like babysitting and repairing outputs rather than shipping work.
Why does collaboration feel broken in today’s chatbot workflows, and what would “slice sharing” change?
What does “intent” mean here, and why is long prompting still a problem?
How should users control how autonomous an assistant is for a task?
What’s wrong with turning answers into work, beyond model accuracy?
What would “smart updates” look like without constant reruns?
What trust and control features are missing for safe, verifiable use?
Review Questions
- Which chatbot capability is most emphasized as still weak: idea generation or converting ideas into shippable work—and what product features drive that conclusion?
- How would dynamic, checkbox-based interfaces reduce the need for long prompting? Give an example from the transcript.
- What combination of “receipts,” editable memory, and diff-based updates would most improve trust and maintenance over time?
Key Points
- 1
Chatbots need to shift from idea generation to workbench behavior: shareable, shippable outputs that teams can collaborate on and maintain.
- 2
Enable collaboration via message-level slice sharing, branching, and live co-editing instead of forcing whole-thread copy/paste workflows.
- 3
Replace long prompting with dynamically generated structured inputs (checkboxes/variable controls) so users can confirm intent quickly.
- 4
Make outputs operational: preserve formatting in exports, surface action items as tasks, and generate stakeholder-friendly publishable summaries.
- 5
Support source-aware updates with proactive refresh and diff views so users don’t have to rerun everything and reread the entire result.
- 6
Build trust through verifiable citations (“receipts”), transparent editable memory, and stronger controls for sensitive threads.
- 7
Improve retrieval and quality-of-life with project auto-grouping, smarter in-chat search, tone “fingerprints,” and quick version rollback/checkpoints.