Show HN: Gitwhisper: An app to convert GitHub into a private messaging app

How I built a private messaging platform using GitHub commits and why your team conversations belong in your repository

Built with a single prompt on Bolt.new for a hackathon

Imagine you’re up late fixing a bug. You’re toggling between Slack DMs, email threads, and GitHub comments — losing track of which insight belongs to which piece of code. I’ve been there, too. That’s why I made GitWhisper: a chatroom inside your GitHub repo where each message is a Git commit.

• Keeps Context Together
  Your code and the chat about it live side by side. No more hunting through different apps.
• Versioned Messages
  Every chat message is a commit. You can use git log to see who said what and even revert a conversation.
• Privacy & Control
  No external servers. Your Personal Access Token (PAT) never leaves your browser, and only people you invite can join.

• GitHub Integration
  Log in with a PAT that has repo access. GitWhisper talks directly to GitHub’s API.
• Private Repo Chat
  All messages go on a separate chat/main branch so they don’t mix with your code.
• Connection Management
  A simple setup page where you paste your PAT and repo name (username/repo-name).
• User Presence Detection
  Creates a .gitwhisper/presence.json file so you can see who’s online.
• Real-Time Polling
  Checks GitHub every few seconds for new messages and presence updates.
• Rich Text Formatting
  Supports bold, italic, and inline code.
• Intuitive UI
  Three views — Setup, Waiting Room, Chat — built with React, Tailwind CSS, and Lucide icons.
• Error Handling
  Shows clear messages for invalid tokens, merge conflicts, or rate limits, and retries automatically.
• Local Token Storage
  Your PAT stays in localStorage and is never sent to any server.

GitWhisperer turns GitHub’s commit system into a private chat platform. Here’s exactly how to set it up and use it with two people, John and Peter.

• Two GitHub accounts (for demo/testing)
• Permission to create private repos
• Two browsers or devices (so you can log in as both users)

1. Create a Private Repository

1. John logs into GitHub and clicks New → New repository.
2. Names it john/team-chat, selects Private, and clicks Create repository.
3. In that repo, John goes to Settings → Manage access → Invite a collaborator, enters Peter, and clicks Invite.
4. Peter logs into GitHub in a second browser and accepts the invitation.

2. Generate Personal Access Tokens (PATs)

Both John and Peter need a token that lets GitWhisperer read and write in the repo:

1. In GitHub, click your avatar → Settings.
2. Go to Developer settings → Personal access tokens.
3. Click Generate new token.
4. Give it a name like “GitWhisperer Chat Token.”
5. Only check the repo box (Full control of private repositories).
6. Click Generate token and copy it now — you won’t see it again.

3. Connect to GitWhisperer

1. Open two browser windows and go to

1. John’s window:

• Paste John’s PAT into the Personal Access Token field.
• Paste john/team-chat into the Repository Name field.
• Click Connect to repository.
• You’ll see “Monitoring repository for activities.”

1. Peter’s window:

• Paste Peter’s PAT and john/team-chat.
• Click Connect.

Tip: Chats are visible live on the app link itself — no page reload needed once you’re connected.

4. Wait for the Connection

• The setup takes about 30 seconds.
• You’ll both see avatars light up when connected.

5. Start Messaging

1. Type your message in the chat box and press Enter or click Send.
2. Wait a few seconds — GitWhisperer commits your message to GitHub, then shows it in the UI.
3. Your repo gains two things:

• A .gitwhisper/presence.json file that tracks who’s online
• Commits on the chat/main branch that store each message

• GitHub Commits: Every message is a Git commit — no extra servers.
• Polling: The app checks GitHub every few seconds for new commits and presence changes.
• Encoding: Messages are lightly encoded so only your team can read them.

1. Commit-Based Chat
   Messages use a prefix like chat: "..." on the chat/main branch.
2. Smart Polling
   Starts at 5-second intervals, backs off on rate-limit errors (403/429).
3. Merge-Conflict Handling
   On send, the app pulls the latest branch, merges, and retries if there’s a conflict.
4. Client-Side Security
   Tokens live in the browser. Safe markdown parsing prevents script injections.

• Rate Limits: We balanced speed with GitHub’s API quotas using exponential back-off.
• Merge Conflicts: Automatic pull→merge→commit retries keep chat flowing.
• No Backend: Handling everything in-browser taught us to manage localStorage and UI state carefully.

• WebSocket Push: True real-time updates without polling.
• Threaded Chats: Organize side discussions.
• End-to-End Encryption: Even collaborators can’t read messages without the app.
• Mobile UI: Smooth touch interactions on phones and tablets.

GitWhisper brings your conversations right into your code. By using Git commits as messages, it keeps chat versioned, searchable, and private in your own repo. Try it out today and stop losing context across tools!

👉 https://gitwhisper.netlify.app/
📧 [email protected]

Try making your own Single-Prompt app here: Bolt.new

“Shh… your chat’s so private it’s hiding in commits — because your secrets belong in your repo, not the cloud.”

This was a fun hackathon project built with a single prompt on Bolt.new — don’t blame me if it acts quirky or unpredictable. Use at your own risk!