Gitty

Inspiration

We built Gitty to tackle Git Anxiety, that split-second dread before you press Enter. In classes, co-ops, and hackathons we kept seeing the same pause: Am I on the right branch? Did I stage only what I meant? Could this push break CI and make me look careless? Those tiny hesitations add up to lost focus and low confidence. Our goal wasn’t to hide Git, it was to make understanding the default. Turn a risky moment into a learning moment, so safe habits form and confidence compounds over time. That insight became Gitty, right inside VS Code.

What it does

Gitty is a VS Code extension that lets developers interact with Git using natural voice commands directly inside the editor. It listens for a wake word, converts speech into text, understands the user’s intent, and generates real Git commands based on the current repository context. Before any command is executed, Gitty shows a clear preview so the user can confirm exactly what will happen.

In addition to executing Git actions, Gitty includes a learning mode designed to help developers understand Git better. In learning mode, users can ask questions like “What does this command do?” or “Why did Gitty choose this command?”, and Gitty will explain the reasoning in plain language. This allows users to learn Git concepts and commands as they work, turning everyday workflows into learning opportunities.

Together, these features make Gitty both a productivity tool and an educational assistant, helping developers work faster while building confidence with Git.

How we built it

Gitty was built as a local first VS Code extension using a modular pipeline. Porcupine is used for wake word detection so the extension only listens when activated. Vosk handles speech to text locally for fast and private transcription. The transcribed text is sent to the Groq API, which translates natural language intent into structured, context aware Git commands. Gitty then displays a preview of the generated command and executes it using the system’s Git CLI only after confirmation. ElevenLabs is used to provide natural text to voice feedback so Gitty can confirm actions and guide the user.

Challenges we ran into

One of the biggest challenges was reliability. Voice input is inherently noisy, so we had to design the system to handle imperfect transcription while still producing correct Git commands. Safety was another major challenge, since Git can be destructive if misused. This required careful prompt design, validation, and a strict preview and confirmation step before execution. Integrating real time audio processing and AI inference inside the VS Code extension environment also required careful handling of performance and latency.

Accomplishments that we're proud of

We are proud that Gitty actually works end to end as a real VS Code extension, not just a prototype. The wake word detection, voice transcription, command reasoning, preview, and execution all work together smoothly. We are especially proud of the safety focused design, where users always see exactly what Git command will run before it executes. Achieving low latency voice interaction while keeping most processing local was also a major accomplishment.

What we learned

We learned that voice interfaces in developer tools require strong guardrails to build trust. Simply generating commands is not enough; transparency and confirmation are essential. We also learned how important latency is for conversational interfaces, which influenced our decision to use offline components and a fast inference API. From a technical perspective, we gained experience integrating speech systems, generative AI, and developer tooling inside a constrained environment like the VS Code extension host.

What's next for Gitty

Next, we want to expand Gitty’s understanding of more complex Git workflows, such as merge conflict assistance, smarter staging, and guided rebases. We also plan to improve contextual awareness, add customizable wake words, and refine the UI for even better usability. Long term, Gitty could integrate more deeply with platforms like GitHub to help developers manage pull requests and reviews using the same conversational approach.