[AI experiment] Default to Public Decisions, Not Private Context

[benbalter]

⚠️ AI drafting experiment — a draft, not for publication as-is.

This post was produced by an experiment: mining 16 years of this blog's archive with Azure AI Foundry, drafting the highest-potential ideas in my voice, and gating each draft against this repo's own anti-AI-pattern Vale style. It's committed with published: false and opened as a draft PR for review and voice comparison — not to merge blind.

Model in the diff: gpt-5.4. A gpt-4.1 draft of the same idea is included below so you can A/B the voice.

Before this could ship, a human must

• Replace every [BRACKETED] placeholder with a real number or lived anecdote.
• Verify or delete any specific statistic — some figures were model-invented and are not real.
• Edit for voice; several drafts in this batch share a "problem → playbook → objection → start small" spine — vary it.
• Fix internal links (e.g. communications debt currently points at leaders-show-their-work).

🅱️ gpt-4.1 A/B variant — same idea, different model (click to expand)

Title: Default to Decisions in Public—Stop Hoarding Context
Description: The async unlock isn’t just sharing docs—it’s making decisions discoverable, in public, and on the record. Here’s why your team’s autonomy depends on it.

---

A few months back, I started tracking how my teams shared information. The pattern was hard to ignore: for every 20 'FYI' posts announcing a thing already done, there was maybe one actual decision doc—a public thread where the thinking, tradeoffs, and reasoning were captured as they unfolded. The result? By the time most people learned what had happened, their best contribution was an emoji reaction, not a meaningful voice in shaping the outcome.

If you want real async, stop hoarding context

It’s not enough to move standups to Slack and call it async. The upgrade comes when your team’s decisions—product calls, process changes, policy shifts—happen in open, async forums. Otherwise you’re just digitizing the old power structure, and everyone not in the meeting is fighting uphill for relevance. If you care about autonomy, distributed collaboration, and not having to explain yourself in DMs for the fifth time this week, you have to default to decisions in public.

'FYI' is a red flag

Ask yourself: how often do you find out about a change as an FYI, long after the decision was made? How many times has your team burned cycles trying to reconstruct the 'why' behind a feature, policy, or incident response, only to realize the real context lives in a calendar invite, a private Slack, or someone’s memory? That’s not just annoying—it’s an organizational drag.

Every decision made in private is a tax on the future. You create communications debt each time you choose speed over transparency, and the bill always comes due: onboarding, debugging, or explaining yourself months later when the why has faded.

:quote[Private decisions slow teams and kill trust. Async doesn’t work if the only things you publish are finished artifacts.]{#decisions-are-the-unlock}

What you’re really losing

I’ve seen the same anti-pattern play out at organizations big and small:

• Product decision in a Zoom, summary in a DM, and a Jira ticket for the feature. Result: stakeholders confused, teams surprised, feedback comes too late.
• Policy change cooked up in a leadership chat, rolled out as a memo. No technical voice, edge cases missed, and the rollout derails on day one.
• Incident postmortem hashed out verbally, bullet points shared, but none of the real tradeoffs, lessons, or debates are recorded. Next time, history repeats.

The real async unlock isn’t just moving status updates online or documenting the what. It’s making the decision itself discoverable, as it happens, with all the messy context preserved. The process, not just the result.

Why teams default to secrecy—and why you must fight it

Yes, it feels lower friction to hash things out quickly in a chat. Yes, you can move faster when only three people need to agree. But if you buy speed today at the expense of transparency, you’re mortgaging your team’s autonomy, trust, and future velocity.

The pushback here is always the same: “People don’t want to follow endless threads,” or “Not everybody cares about every decision.” Fine. Don’t force people to read everything. But if you care about building an async, high-trust culture—one where context flows as freely as code—then you need to make the decision process open to those who do care. Invite feedback early, even if only two people take you up on it. Publish the reasoning, not just the outcome, so that folks can challenge, learn, or build on it later.

You don’t do this because you want to write more docs. You do it so you can stop being a human router for tribal knowledge, stop answering the same questions, and empower anyone on the team to reason about why things are the way they are.

How to move decisions from DM to daylight

Here’s the playbook. Copy, paste, and hold your team to it:

Async Decision-Making Checklist

• Does the decision impact more than one person? Publish it.
• Is there a meaningful tradeoff, risk, or context others will need later? Publish it.
• Is the decision point likely to come up again? Publish it.
• Are you tempted to write “FYI” or “Just a heads up…”? Ask yourself: could others have contributed, or will they need to understand why? If yes: publish the decision process, not just the FYI.
• Before you meet: start a thread, doc, or issue in a public channel. Outline what’s being decided, what options you’ve considered, and the constraints.
• During or after the meeting: summarize in that same thread, link to supporting docs, and—crucially—capture the reasoning, not just the result.
• Don’t rely on “ping me if you have questions.” Document the why while it’s fresh. If you wouldn’t want to explain this five times, explain it once—publicly.
• Link decisions to their execution: product PRs, policy rollouts, incident logs. Make the context discoverable at the point of use.

You don’t need a different tool to work this way. Use what you already have—GitHub issues, Google Docs, Notion pages, whatever—so long as the forum is open and the record durable.

Objections and edge cases

“But some decisions are sensitive.” Sure. Sometimes there are HR concerns, privileged info, or embargoed launches. That’s the exception, not the rule. Most decision-making can (and should) be open by default. If there’s a reason to keep it private, state it.

“People will see the messy parts.” Good. That’s where the learning happens. Most teams overestimate the risk of sharing in-progress thinking and underestimate the cost of hiding it.

“Nobody will read it.” Until they do. Most people aren’t interested in every detail, but when the why matters, they’ll be grateful you captured it—especially new hires, future incident responders, or the you of six months from now.

This is ‘show your work’ in practice

This isn’t just opinion. It’s the core of working open and async—the central thesis of every high-performing distributed team I’ve worked with. If you want to show your work—really show it, not just pretend—decisions need to be discoverable, challengeable, and linkable. The quicker you get comfortable with decisions in public, the faster your team becomes a self-healing, high-trust organism, not a collection of context-starved silos.

What you’ll notice when you make the shift

In every team I’ve coached through this transition, a few things always happen:

• The volume of “Can you explain why we did this?” DMs drops by [X% — fill with your real number].
• Passive observers become contributors, often surfacing edge cases or alternatives leadership missed.
• Onboarding gets easier, because the why is as discoverable as the what.
• Fewer “we already tried that” or “that’s not how it works here” conversations, because the history is public and linkable.
• Most importantly: people stop waiting to be told and start acting with autonomy, because they can see—and trust—the process.

The takeaway

Async isn’t magic; it’s discipline. If you want to unlock the benefits—autonomy, speed, fewer meetings, and a team that acts like owners—you have to stop hoarding context. Default to decisions in public. Make your process, tradeoffs, and reasoning part of the permanent record. Your future self (and everyone you onboard) will thank you.

---

🤖 AI experiment via Claude Code · drafted on 2026-08-01 with Azure AI Foundry (gpt-5.4 primary, gpt-4.1 A/B) · linted against the repo's AIPatterns Vale gate.