Skip to main content

Why decisions get lost in Slack (and how to fix it)

· 5 min read
The Align Team
The Align Team
Engineering decision intelligence

Most of your team's real decisions don't happen in a doc. They happen in Slack. Two engineers are debating a bug, a third jumps in, someone says "ok let's go with option 1," and that's it. The decision is made. Then the thread scrolls away and the reasoning goes with it.

A few weeks later someone asks "wait, why does this work this way?" and nobody can find the answer. It's in Slack somewhere. Good luck.

This is a scale problem, not a discipline problem​

If you've got eight engineers in one room, you don't feel this. Someone forgets why a thing was built a certain way, they ask, somebody remembers. Small, well-run teams genuinely do "just ask" and it works.

It breaks at scale. Past 50 engineers, multiple squads, and cross-team dependencies, "just ask" stops working because:

  • The person who made the decision is on a different team, or has left.
  • The decision touched three squads and none of them saw the others' context.
  • Nobody remembers which channel, which thread, which week.

So the failure isn't that your team is sloppy. It's that informal communication has a ceiling, and you've grown past it. The tools that work at ten people quietly stop working at a hundred, and nobody notices until the rework starts.

Why Slack specifically buries decisions​

Slack is brilliant for conversation and terrible for memory, by design:

  • Channels move too fast. An active channel does hundreds of messages a day. A real decision is on screen for an hour, then it's gone.
  • Threads are where knowledge goes to hide. The most detailed technical discussion happens in threads, which don't show in the main channel. If you weren't in the thread, you'll never know it existed.
  • Search needs the magic words. Slack search works if you remember the exact phrasing. Decisions made conversationally ("yeah let's just do the simpler one") have no searchable keywords.
  • Nothing separates signal from chatter. There's no native way to mark "this message is a decision" versus "this is a lunch order."

The result is a workspace full of decisions with zero traceability. Hundreds of decisions, no trail back to any of them.

The usual fixes, and why they don't hold​

"Just write an ADR / Confluence page." Right instinct, and you should. But the decision happened in Slack, and asking everyone to stop, switch tools, and write it up is friction. Most of the time it doesn't happen, and when the decision later changes in another Slack thread, the doc goes stale and now you have two contradictory sources of truth.

"Pin important messages." Pins don't scale past a handful and nobody curates them.

"Use a /decision bot." Closer. It captures the moment, but it's still manual, it lives in a separate list, and it doesn't connect to the decision when it changes in GitHub or Jira later.

The pattern: every fix asks a human to do extra work at exactly the moment they're trying to move on. That's why decisions keep slipping through.

What actually fixes it​

The decision needs to be captured where it happens, linked to everywhere it's relevant, and flagged when something later contradicts it. Three properties:

  1. Capture in place. No tool-switching, no template. The decision gets recorded from the conversation it happened in.
  2. One graph across tools. The Slack decision links to the GitHub PR that implements it, the Jira ticket that tracks it, the Confluence page that documents it. One source of truth, not five.
  3. Catch contradictions before they ship. When a new decision in one squad's channel contradicts an existing one in another's, someone hears about it before two teams build against each other.

That last one is the part no doc or bot gives you, and it's the part that saves the weeks of rework.

This is what we built Align to do. You connect Slack (and GitHub, Jira, Teams, Confluence), engineers flag decisions with a quick explicit action (no passive surveillance, you stay in control of what's captured), and Align links them into a graph your team and your AI agents can both query. When two teams head in contradictory directions, it surfaces the conflict early.

Where to start​

You don't have to boil the ocean. Start by noticing how often someone on your team asks "didn't we already decide this?" or "why does this work this way?" Those questions are the cost of lost decisions, and once you start counting them you'll see how much they add up to.

When you're ready to stop paying that cost, see how Align works.

Align captures engineering decisions across Slack, GitHub, Jira, Teams and Confluence, links them into a queryable graph, and catches cross-team conflicts before they ship. Related reading: Architecture Decision Records: the complete guide.