GUIDE

Updated March 2026

8 topics

Signals Guide

Learn how to use Signals for async project discussions — post announcements, ask questions, share ideas, and keep the team informed without meetings.

Jump to

What are Signals?Signal Categories Creating a Signal Draft and Publish Pinning Signals Discussion & Comments Real-Time Updates Best Practices

What are Signals?

Signals are async discussions that live inside a project. Unlike chat, signals are persistent, categorized, and searchable — making them the right place for things that matter beyond the moment: a decision that was made, a question the team needs to answer, or an idea worth exploring.

Every signal has a category, a title, a markdown body, and an optional thread of comments. You can publish a signal immediately or save it as a draft while you think it through. Important signals can be pinned so they stay visible at the top of the list.

Why Signals over chat?

Persistent: Signals don't disappear in a message history — they stay in the project
Categorized: Every signal has a type, so the team knows what kind of response is expected
Searchable: Find past decisions, answered questions, and accepted ideas by searching
Async-friendly: Post when you're ready; teammates respond on their schedule

Signal Categories

Every signal belongs to one of four categories. Choosing the right category sets expectations for how teammates should engage with it.

Announcement

Team-wide updates that don't require a response. Use for decisions made, releases shipped, or important changes everyone should know about.

Question

Async Q&A directed at the project team. Use when you need input, a decision, or clarification and want a record of the answer.

Idea

A proposal worth considering. Use when you want to share an approach, suggest a change, or float something for feedback before committing to it.

Update

Progress reports and status changes. Use to share where things stand on a workunit, milestone, or piece of ongoing work.

Tip: The category you choose signals intent. "Announcement" tells teammates they're being informed. "Question" tells them a response is expected. "Idea" invites discussion without pressure. Choose deliberately.

Creating a Signal

Navigate to the Signals tab inside a project and click 'New Signal'. The form has three parts:

1. Choose a Category

Select Announcement, Question, Idea, or Update. This determines how the signal is labeled and filtered in the list. You can change it before publishing.

2. Write a Title

Keep titles specific and descriptive. A good title lets teammates understand the signal without opening it. Aim for a single, clear sentence.

Examples:

"Switching auth library from Passport to Better Auth"
"Should we use SSE or WebSockets for real-time updates?"
"Idea: consolidate project and workunit settings pages"
"API rate limiting — shipped to staging"

3. Write the Body

The body supports full Markdown — headings, lists, code blocks, bold, links. Use it to provide context, reasoning, or background that teammates will need to understand or respond to the signal.

Signals with more context get better engagement. Include the "why" — not just the "what". A signal that explains its reasoning reduces back-and-forth in the comments.

Draft and Publish

When you create a signal, you can save it as a draft or publish it immediately. Drafts give you space to think before broadcasting to the team.

Draft

Only you can see a draft signal. It won't appear in the project's signal list for other team members. Use drafts when you're still refining your thinking or aren't ready to open discussion yet.

Published

Published signals are visible to everyone in the project. Teammates can read them, leave comments, and react. Publishing is the moment the signal enters the team's shared space.

You can edit a signal after publishing — but team members may have already read or commented on the original version. Significant edits are best acknowledged in a comment to avoid confusion.

Pinning Signals

Pin a signal to keep it at the top of the project's signal list. Pinned signals stay visible regardless of when they were posted — useful for ongoing references, open questions, or decisions the team should keep in mind.

To pin a signal, open it and use the pin action in the signal menu. To unpin, use the same menu. Pinned signals appear in a dedicated section at the top of the list, clearly marked.

Pinning limit: 3 per project

A project can have up to three pinned signals at a time. This limit encourages intentional use — pin signals that are genuinely important for the team to see right now, not everything that feels relevant.

Good candidates for pinning: An open question the team is actively working through, a decision that affects current work, or an announcement that newcomers to the project should read first.

Discussion & Comments

Every published signal has a comment thread beneath it. Use comments to respond, ask follow-up questions, share your take, or record the outcome of a discussion.

Writing Comments

Comments support Markdown formatting — the same as signal bodies. Use code blocks for snippets, bullet lists for options, or bold text to highlight key points. Submit with the comment button or press the keyboard shortcut.

Editing and Deleting

You can edit or delete your own comments at any time. Use the options menu on a comment you authored. Other team members cannot edit your comments, and you cannot edit theirs.

Keeping the Thread Useful

Comments are visible to everyone in the project. If a question gets answered, consider adding a brief "resolved" comment or editing the signal body to record the conclusion — this helps anyone who reads the signal later.

Real-Time Updates

Signals and comments update in real time across all browser tabs — no refresh needed. When a teammate publishes a signal, pins one, or adds a comment, the list and detail views update automatically.

What updates in real time

New signals appearing in the project list
Signals being published from draft
Signals being pinned or unpinned
New comments on a signal you're viewing
Comment edits and deletions

Real-time updates use Server-Sent Events (SSE). If your browser tab has been in the background for a while, updates may appear briefly after you switch back to the tab — this is normal behavior.

Best Practices

Get the most from signals by following these patterns:

Use Announcements for decisions

When a decision is made — in a call, a PR, or anywhere else — post an Announcement signal to record it. Decisions buried in chat or meeting notes get lost. A signal lasts.

Use Questions for async Q&A

When you need team input but don't need it right now, use a Question signal instead of pinging someone in chat. It gives people time to think and creates a searchable record of the answer.

Use Ideas for proposals

Floating a change or a new direction? Use an Idea signal. It separates brainstorming from execution and invites feedback before work begins, saving time on approaches that might not land.

Use Updates for progress

Post an Update signal when something ships, a milestone is hit, or the status of a workunit changes meaningfully. It keeps the project's story coherent without requiring a meeting.

Pin only what's truly active

The three-pin limit exists to force prioritization. When you want to pin a fourth signal, unpin one that's no longer actively relevant. Crowded pins lose their value.

Use Markdown for clarity

A well-formatted signal is easier to read and act on. Use headings to separate sections, bullet lists for options, and code blocks for technical details. Clear formatting reduces misunderstandings.

When NOT to use Signals

Urgent matters: If something needs attention in the next hour, use chat or a direct message — not a signal
Personal feedback: One-on-one feedback is better handled privately, not in a shared signal thread
Trivial updates: Not everything needs to be a signal. Save them for things that genuinely affect the project or the team
Replacing real conversation: Signals complement discussion, they don't replace it. Some topics are better resolved in a quick call

Keep going