Git Out: A Local Voice Companion That Helps Developers Touch Grass

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Git Out is a local-first voice companion for developers who want to think through
technical problems without staying glued to a screen.

The idea is simple: take a walk, ask a question out loud, and get a useful answer
without opening a laptop, sending your voice to a cloud service, or losing your
train of thought to a dozen tabs.

Git Out is built for developers who are walking, commuting, taking a break, or
working away from their desk. It can help with questions such as:

• “What is the safest way to refactor this module?”
• “How should I think about this pull request?”
• “What Git workflow should I use for this change?”

The app records one deliberate voice turn, transcribes it on the Android device,
generates an answer with a local Qwen model, and reads the completed answer aloud
with the installed Android voice.

The screen is intentionally the shortest part of the experience. Pocket Mode has
large, high-contrast controls and explicit states for Ready, Listening,
Transcribing, Thinking, Speaking, and Error. There is no wake word,
no always-on microphone, and no automatic microphone restart in the background.

Git Out also includes an optional read-only GitHub workspace. When the backend is
configured, the app can show the connected account, repositories, assigned issues,
pull requests, and recent commits. The GitHub token stays on the server and is
never bundled into the mobile app.

Demo

Video demo:

The demo should show:

1. Loading the Qwen GGUF model from Android Settings.
2. Starting Pocket Mode and asking a question by voice.
3. The on-device transcript appearing on screen.
4. A local answer being generated and spoken by Android TTS.
5. Locking or backgrounding the phone while an answer is already speaking.
6. Returning to the app and showing that the answer remains readable.
7. Optionally opening the GitHub tab to show repository context.

This is an Android development build, so a short screen recording is the most
useful demo format. The project is designed to be tested on a physical Android
device because installed speech packs, TTS voices, audio focus, headset events,
and lock-screen behavior vary by device.

Code

The complete open-source project is available here:

Git Out on GitHub

The repository contains the React Native/Expo mobile app, the FastAPI backend,
the local AI abstraction, the Android speech and TTS integrations, GitHub API
services, tests, and setup documentation.

How I Built It

Git Out is an Android-first React Native app built with Expo and a small FastAPI
backend for the optional GitHub workspace.

Local AI

The core model is Qwen2.5-1.5B-Instruct Q4_K_M GGUF, loaded on the Android
device with llama.rn. The model file is
selected and stored locally by the user; it is not bundled into the repository or
downloaded automatically by the app.

The mobile conversation path is:

Voice question
    ↓
Android on-device speech recognition
    ↓
Local transcript
    ↓
Qwen GGUF through llama.rn
    ↓
Readable answer + optional Android TTS playback

Speech input and output

• expo-speech-recognition checks for an installed Android on-device language pack before recording.
• The app refuses to silently switch to network recognition when the requested offline language is unavailable.
• A handwritten GitOutTts Expo module wraps Android TextToSpeech.
• The TTS path handles exact installed voice matching, audio focus, headset removal, stop/cancel actions, and supported media-session controls.
• A scoped media playback foreground service is used only while an already-started answer is being spoken. It never starts the microphone.

Pocket Mode

Pocket Mode is a one-shot voice workflow rather than a continuous assistant. Each
tap starts one question, and the lifecycle is guarded so stale recognition or TTS
callbacks cannot submit an accidental second turn.

The state machine makes the interaction understandable while the user is moving:

Ready → Listening → Transcribing → Thinking → Speaking
                         ↘ Error

Optional GitHub workspace

The FastAPI service uses a server-only GITHUB_TOKEN and GitHub's REST API. It
exposes sanitized read endpoints for the authenticated user, repositories,
assigned issues, pull requests, and commits. The mobile app only receives
whitelisted response fields; it never receives the token.

GitHub is intentionally separate from local inference. Local conversation keeps
working when the backend or network is unavailable.

Visual design

The app uses a dark, minimal skeuomorphic interface: raised cards, recessed input
wells, tactile buttons, subtle shadows, and clear status pills. This gives the
controls a physical-device feel without adding a heavy UI library or image assets.

Why Does Open Innovation Matter?

Open innovation is what makes Git Out fit the Touch Grass theme instead of becoming
another cloud chat interface.

The open-weight Qwen model lets the main conversation run locally on the phone.
That makes several important things possible:

• Offline use: after the model and Android speech/TTS data are installed, a user can walk without Wi-Fi or mobile data.
• Private voice conversations: prompts, transcripts, and answers do not need to leave the device for the local AI loop.
• Model control: the GGUF model is a user-owned file that can be replaced or upgraded without rewriting the whole product around a hosted API.
• No per-request dependency: the core experience does not require a paid API key or a vendor's uptime.
• Inspectable building blocks: the app can combine an open-weight model, llama.rn, Expo modules, native Android speech APIs, and a local-first state machine in a way that can be inspected and changed.

A closed hosted API could make a quick prototype, but it would move the central
conversation onto a remote service and make a no-signal walking workflow much less
reliable. Open components gave me the control needed to make privacy and offline
behavior product features rather than marketing claims.

The trade-off is honest: a small on-device model has less capacity than a large
cloud model, and loading a GGUF requires enough memory on the Android phone. Git
Out chooses that trade-off because a private, available answer while walking is
more useful here than a larger answer that requires a network connection.

Prize Categories

I am entering the overall Hacktoberfest Open-Source AI Challenge. I am not claiming
a partner category because Git Out does not currently use partner-specific
technology.

What I Verified

The repository includes automated checks for the local AI guards, speech
recognition behavior, TTS lifecycle, voice-conversation transitions, Pocket Mode
state changes, and duplicate media-command handling.

The final frontend checks passed:

npm run typecheck   ✓
npm test            ✓ 50 tests passed
npx expo export --platform android   ✓
git diff --check    ✓

For the final device demo, I will report the phone model, Android version, speech
service, and TTS engine used. Device-specific speech, headset, background
playback, and lock-screen behavior can vary by device, so those details are part
of the demo notes rather than assumptions about every Android phone.

Closing

Git Out is a small experiment in making developer tooling less desk-bound. The
goal is not to keep people in an AI chat window. The goal is to let them ask one
useful question, hear a practical next step, and get back to the world outside
the screen.