Create Issues
by Voice

The Context Switch That Kills Your Flow

You're deep in a debugging session. You find it — the token expiry is set to 5 minutes but the password reset email takes 10 minutes to arrive. Users can't log in. You need to file a GitHub issue before you context-switch away and lose the details.

So you open GitHub. Navigate to the repo. Click "New issue." Type the title. Write the body. Add labels. Click "Submit new issue."

By the time you're done, two minutes have passed. You've lost the mental model of the auth flow you were tracing. You switch back to the code. Where were you again?

What if you could just speak?

Three seconds. No browser. No clicking. No context switch. You're still in your editor, still tracing the auth flow.

How It Works

Your voice ──▶ SpeechButton STT ──▶ Gemma 4 Local AI ──▶ GitHub REST API
  (7ms)         (Parakeet V3,        (structures as         (creates issue)
                 100% offline)         title + body +
                                       labels, local)

Three components:

1. SpeechButton captures and transcribes your voice locally on Apple Neural Engine
2. Local AI (Gemma 4) reads your prompt file and extracts a structured issue (title, body, labels) from your transcription — entirely on your Mac
3. A Python script in your integrations/ folder sends the JSON to GitHub's REST API

The result: a well-formatted GitHub issue from your spoken description, in under 4 seconds total. Everything is local except the final GitHub API call — no Anthropic API key needed.

Setup

Four steps. Under five minutes.

Convert speech into a GitHub issue JSON. Extract:
- title: concise issue title (under 80 chars)
- body: detailed markdown body with steps to reproduce
- labels: array of label strings (bug, enhancement, etc.)

Output ONLY valid JSON:
{"title": "...", "body": "...", "labels": ["bug"]}

# ~/.config/speechbutton/config.toml

[global]
model = "parakeet-tdt-0.6b-v3-int8"
language = "en"
auto_punctuation = true

[audio]
vad_enabled = true
vad_silence_threshold = 1.0

# GitHub — create issue from voice
[[hotkey]]
key = "RightCommand"
channel = "5"
name = "github"
transform = "prompts/github_issue.md"
exec = "GITHUB_TOKEN=ghp_xxx GITHUB_REPO=owner/repo integrations/send_github.py"

#!/usr/bin/env python3
"""Create a GitHub issue from stdin JSON."""
import json, os, sys, urllib.request

def main():
    text = sys.stdin.read().strip()
    if not text: sys.exit(0)

    # Strip markdown code fences
    if text.startswith("```"):
        lines = text.split("\n")
        text = "\n".join(lines[1:-1] if lines[-1].startswith("```") else lines[1:])

    try:
        data = json.loads(text)
    except json.JSONDecodeError:
        data = {"title": text[:80], "body": text, "labels": []}

    token = os.environ.get("GITHUB_TOKEN")
    repo = os.environ.get("GITHUB_REPO")
    if not token or not repo:
        print("GITHUB_TOKEN and GITHUB_REPO required", file=sys.stderr)
        sys.exit(1)

    req = urllib.request.Request(
        f"https://api.github.com/repos/{repo}/issues",
        json.dumps({"title": data.get("title", "Untitled"),
                     "body": data.get("body", ""),
                     "labels": data.get("labels", [])}).encode(),
        {"Authorization": f"Bearer {token}",
         "Accept": "application/vnd.github+json",
         "Content-Type": "application/json"})
    result = json.loads(urllib.request.urlopen(req, timeout=15).read())
    print(f"Created #{result['number']}: {result.get('title','')[:50]}")

if __name__ == "__main__":
    main()

chmod +x ~/.config/speechbutton/integrations/send_github.py

Real Workflows

Why Voice Beats Typing for Issue Creation

GitHub issues created by typing tend to be either too terse ("fix auth") or take too long to write well. Voice hits the sweet spot:

The result is a better issue than you'd type manually, created in a fraction of the time. The AI transform handles the formatting you'd skip when rushing and the structure you'd over-think when not.

And because SpeechButton captures in 7ms, you can rapid-fire multiple issues in sequence. Hold, speak, release. Hold, speak, release. Three GitHub issues filed before you'd finish typing the first one.

Privacy

Here's exactly what stays on your Mac and what goes to the cloud:

With the default local AI transform, everything stays on your Mac except the final GitHub API call: voice → local STT (Parakeet V3, Apple Neural Engine) → local AI transform (Gemma 4, on your Mac) → GitHub API. No audio leaves your machine. No transcription leaves your machine. Only the structured issue data reaches GitHub's servers — which is where it needs to go anyway. No Anthropic API key required. If you prefer higher accuracy at the cost of privacy, you can optionally switch to the Claude API transform (Option B) — in that case, transcribed text is sent to Anthropic's servers for structuring.

Prerequisites

• macOS 15 or later
• Apple Silicon (M1 or newer)
• GitHub account with a repository to file issues in
• A fine-grained GitHub token with Issues: Read & Write permission
• Python 3 (pre-installed on macOS)

Get Started