Hindsight

Your team's memory in Slack. Hindsight captures decisions, recalls them with cited evidence and speaks up when someone's about to contradict a settled call. Hindsight is 20/20.

Comment

Inspiration

I'm a project lead. My team and I build projects together, and our conversations get huge. We mention important things in chat — like which tech stack we're going with — and days later, nobody can find it. The team gets confused about which stack we actually settled on, and someone has to scroll through hours of old messages to find that one decision.

We keep a document for project plans and stacks. But when we change a decision — because of some constraint or a better option — that change happens in chat, and half the time nobody updates the document. So the document lies, and the truth lives somewhere in the scrollback.

Then I came across a stat: teams spend about a third of their time just searching for information that already exists. That was exactly us. Chat is where decisions happen — and chat is where they disappear. Hindsight is my answer to that.

What it does

Hindsight is the teammate who remembers everything, so nobody else has to:

  • Capture — pin any message with pushpin (or let auto-capture detect decision-shaped messages and offer to save them) → it lands in the team's decision ledger
  • Ledger — /decisions shows a living record of every call: status, author, and links back to the original messages
  • Recall — ask @Hindsight what did we decide about auth? and it answers with receipts: the original messages, who made the call, and the reasoning
  • The Guardian — the part nobody else does. Hindsight watches every channel, and when someone unknowingly contradicts a settled decision, it replies in-thread within seconds: the original decision, the evidence, and two buttons — Still stands or We're rethinking it

Decision-tracking tools exist (Dcyde, ADRs) — but they're manual and passive. Hindsight is automatic and proactive. On Slack's free plan, messages vanish after 90 days; Hindsight's ledger never forgets.

How we built it

  • Node.js + Bolt (Socket Mode) — event-driven agent loop: perceive (Slack events) → remember (SQLite ledger) → reason (LLM) → act (Block Kit)
  • Search layer — RTS-first with automatic fallback to conversations.history, so it works on any workspace tier
  • Reasoning — Groq (Llama 3.3 70B) with conservative confidence gating: the Guardian only speaks at ≥85% confidence — it prefers silence over false alarms
  • Memory — the LLM is stateless; the SQLite decision ledger we built around it is the product. Swap the model, the memory stays
  • UI — polished Block Kit cards, App Home tab, and a warm human persona

Challenges we ran into

My first two days went entirely into just getting access. The developer sandbox wouldn't provision, and Slack's sign-in kept looping endlessly — different browsers, clean profiles, cleared cookies, even a different network. Nothing worked. At one point I genuinely considered giving up. Instead, I pivoted: set up a fresh workspace, switched from the new CLI platform to a classic Slack app with Bolt and Socket Mode, and got my first event flowing.

Then I discovered the Real-Time Search API was gated behind a sandbox tier I couldn't access. Rather than drop it, I built the search layer RTS-first with an automatic fallback to conversations.history — so Hindsight always tries the best available tool and degrades gracefully on any workspace tier.

The blockers were never the code. Working through the platform hurdles and still shipping every planned feature — capture, ledger, recall, the Guardian, and auto-capture — is the part I'm most proud of.

What we learned

The biggest lesson: the difference between a chatbot and an agent. A chatbot answers when asked — an agent watches, remembers, and speaks up on its own. Building the Guardian taught me that the hard part isn't calling an LLM; it's deciding when not to speak (confidence gating, preferring silence over false alarms).

I also learned that the LLM is stateless — it remembers nothing between calls. The memory you build around it is the real product. Swap the model and Hindsight still works, because the ledger, the evidence, and the reasoning pipeline are ours.

What's next for Hindsight

  • Decision graph — link related decisions across time and channels
  • Embedding-based recall — semantic search beyond keywords
  • Auto-detected duplicates — flag when two teams are solving the same problem
  • Weekly digest — decisions made, decisions challenged
  • Multi-workspace support for a Marketplace release

Built With

Share this project:

Updates