Resume

Capture coding context with a short note, failing output, and a Gemini-transcribed voice thought.
Resume turns that context into one concrete next step with verified file and line targets.
See commits and file changes that happened after the checkpoint was saved.
Jump straight back into VS Code at the exact relevant line of code.

Inspiration

Developers usually do not lose their files when they step away from a project — they lose their mental context.

Git can tell you what changed, your editor can reopen your tabs, and your terminal may still show an error, but none of those tools remember what you were thinking: what you were debugging, what you already tried, what your current hypothesis was, or what you planned to do next.

We built Resume around one question:

What if developer work had save states?

Resume lets developers save their working context before an interruption and restore it later instead of reconstructing everything from scratch.

What it does

Resume creates checkpoints for work inside a local Git repository.

Before stepping away, a developer can type a short note or use Voice Thought Dump to explain what they are working on out loud. Resume captures the repository state, including the branch, commit, changed files, diff, recent commits, terminal output, and relevant links.

Gemini then turns that raw context into a structured recovery plan with:

what you were working on
where you got stuck
what you already tried
relevant errors
the exact next step
the files that matter

When you return, Since You Left shows what changed in the repository after the checkpoint, and Resume Work opens VS Code directly at the relevant file and exact line.

If Gemini is unavailable or rate-limited, the checkpoint still saves with a basic recovery summary instead of failing.

How we built it

The frontend is built with React, TypeScript, Vite, and Tailwind CSS.

The backend uses FastAPI and Python, with SQLite for local checkpoint storage.

Resume reads the developer's local Git repository to collect deterministic context such as the branch, HEAD commit, changed files, diffs, and recent commits.

We use the Gemini API for two main tasks:

Transcribing Voice Thought Dumps.
Turning raw developer context into a structured recovery plan.

One important architectural decision was not to blindly trust the model. Gemini interprets the context, but file paths and line numbers are verified by the backend before they become editor actions.

Resume is also local-first. Checkpoints are stored locally in SQLite, Git access is read-only, sensitive files are excluded, detected secrets are redacted, and voice recordings are kept only in memory during transcription rather than saved to disk.

Challenges we ran into

One of the biggest challenges was making the AI useful without making the whole application depend on AI reliability.

During development, we encountered real Gemini availability and rate-limit errors. We added a primary/fallback model strategy with strict time limits, and if AI generation still fails, Resume saves a basic recovery summary so the user's checkpoint is never lost.

Another challenge was connecting AI-generated context back to real code safely. A model can mention a file or line that sounds correct but does not actually exist. We solved this by separating interpretation from verification: Gemini identifies relevant context, while the backend resolves and verifies the actual files and line numbers.

Voice Thought Dump also introduced browser-specific challenges involving microphone permissions, MediaRecorder formats, cleanup, and transcription failures. We tested the complete flow with a real Chrome microphone recording from recording through Gemini transcription and checkpoint creation.

Accomplishments that we're proud of

We are proud that Resume became more than a simple AI wrapper.

The system combines generative AI with deterministic Git context and backend verification. Gemini helps understand the developer's state, while our own logic verifies the exact files and lines used for Resume Work.

We also built the project to degrade gracefully. If Gemini is unavailable, the checkpoint still works. If voice transcription fails, the user can type instead. If a file cannot be verified, Resume does not expose a broken editor action.

We are especially proud of the complete end-to-end flow:

record your thought → save your coding state → return later → see exactly what changed → get one concrete next step → jump back into VS Code at the right line.

What we learned

We learned that AI can be more useful when it is embedded inside a workflow instead of presented as another chatbot.

The developer does not need to write a complex prompt. They simply save their state, and Resume turns that context into something useful when they return.

We also learned the importance of putting deterministic systems around generative AI. Gemini is good at understanding messy human context, but Git, validation, allowlists, and backend verification are what make that understanding reliable enough to turn into real actions.

What's next for Resume

We started with software development because Git gives Resume a strong source of truth, but the larger idea is broader.

Resume could become a save-state system for knowledge work.

The same capture → understand → restore loop could eventually apply to research, writing, data analysis, design, and other work where interruptions cause people to lose valuable mental context.

For now, Resume solves one simple problem:

Your computer remembers your files. Resume remembers your train of thought.

Pick up exactly where you left off.