DEV Community: Sanvi Naik

ContextSwitch: An AI Assistant That Helps You Pick Up Where You Left Off

Sanvi Naik — Mon, 26 Oct 2026 05:41:17 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Have you ever reopened a project after a few days away and spent the first 20 minutes trying to remember what you were doing?

Which files changed? What did the last commits accomplish? What still needs attention? Where should you start?

I built ContextSwitch, a read-only project-resumption assistant designed to answer those questions.

Instead of manually piecing together repository history, ContextSwitch gathers Git commits, working-tree changes, documentation, and TODO-style markers into a structured report. It then suggests possible next steps, with an optional AI-generated briefing to make the information easier to digest.

The goal is simple: spend less energy remembering where you left off and more energy actually building.

Demo

Code

GitHub repository: https://github.com/sanvinaik/ContextSwitch

The project is written in Python and uses Git as its primary source of repository evidence.

How I Built It

ContextSwitch combines deterministic repository inspection with optional AI summarization.

The workflow collects:

Recent commits and repository identity.

Staged, unstaged, untracked, and deleted paths where available.

Readable file diffs.

Selected project documentation.

TODO, FIXME, HACK, XXX, and BUG markers from a bounded file scan.

Suggested next actions and an evidence register.

For AI-powered briefings, ContextSwitch uses Groq with the open-weight openai/gpt-oss-20b model. A no-AI mode is also available.

I wanted the tool to help developers regain context without taking control away from them. It does not intentionally modify the target repository or execute its project code.

Why Does Open Innovation Matter?

A developer's project context can contain sensitive information, so transparency and control matter.

Using an open-weight model gives the AI component a model choice that can be evaluated and potentially replaced with another compatible model or deployment. It also makes the model choice more transparent than relying on an opaque, fixed assistant.

There is an important trade-off in the current implementation: AI mode sends selected repository context to the configured Groq service. The no-AI mode avoids that AI-provider transfer and relies on local inspection and deterministic report generation.

Open innovation matters because developers should be able to inspect, adapt, and evolve the tools they depend on rather than being locked into a single closed workflow.

The Lazy Payoff

The idea is to turn the familiar “Where was I?” moment into a report that gives you somewhere concrete to start.

Rather than manually checking commits, searching for unfinished work, and reopening documentation one file at a time, you get those signals in one place.

ContextSwitch is an early version, so I am not claiming a measured time saving yet. Its purpose is to reduce the repetitive mental overhead of returning to interrupted work.

Prize Categories

Slow and Steady

QuoteCraft: An AI-Powered Quotation Generator for Freelancers

Sanvi Naik — Mon, 19 Oct 2026 05:55:15 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

The Problem

Freelancers and small development agencies often receive project requirements in the form of informal messages or lengthy descriptions. Turning these requirements into a professional quotation involves understanding the scope, identifying deliverables, estimating costs, and formatting everything into a document.

This process can be repetitive and time-consuming, especially when dealing with multiple potential clients.

I wanted to build something that could simplify this process and help freelancers spend less time preparing quotations and more time working on their projects.

What I Built

QuoteCraft is an AI-powered quotation generator that transforms natural-language client requirements into structured, professional project quotations.

Users can simply paste a client's project description, and QuoteCraft automatically generates:

Project Overview: A concise summary of the client's requirements and proposed solution.

Deliverables: A structured breakdown of the work involved.

Estimated Timeline: An approximate project completion timeframe.

Pricing Breakdown: Itemized cost estimates for different components of the project.

Assumptions: Important considerations and uncertainties associated with the project.

PDF Export: A downloadable quotation that can be shared with clients.

One feature I particularly wanted was editability. AI-generated estimates shouldn't be treated as final, so users can modify the project details, deliverables, timelines, and pricing before exporting the quotation.

The application also automatically recalculates the total whenever the pricing breakdown is modified.

Demo

Code

GitHub Repository: https://github.com/sanvinaik/QuoteCraft

The repository contains the Streamlit application, AI integration, and PDF generation functionality.

How I Built It

built QuoteCraft using Python, Streamlit, Groq, Pandas, and ReportLab.

The core of the application is GPT-OSS-20B, an open-weight language model accessed through Groq's inference API.

Here's how the workflow operates:

Input: The user enters a client's requirements and selects the preferred currency.

AI Processing: The requirements are sent to GPT-OSS-20B, which analyzes the project scope and generates structured JSON containing the quotation details.

Proposal Generation: The application parses the generated JSON and displays the project summary, deliverables, assumptions, timeline, and pricing.

Editing: Streamlit's interactive components allow users to modify the generated quotation. Pandas helps manage the editable pricing breakdown and calculate the total.

PDF Export: ReportLab converts the finalized quotation into a downloadable PDF document.

The application separates these responsibilities into different Python modules, making the AI integration, user interface, and document generation easier to maintain.

Why Does Open Innovation Matter?

One of the most interesting parts of building QuoteCraft was realizing that a practical AI application doesn't necessarily need to depend on a proprietary language model.

Using an open-weight model like GPT-OSS-20B makes the underlying model more accessible and gives developers greater flexibility in how they deploy and integrate AI.

For QuoteCraft, this means the AI component is not inherently tied to a single proprietary model provider. Although the current implementation uses Groq for hosted inference, the architecture could be adapted to run a compatible open-weight model through another provider or local infrastructure.

Open innovation also makes it easier for developers to experiment, understand the technologies they're working with, and build useful applications without developing a language model from scratch.

For a tool intended for freelancers and small businesses, having flexibility around inference providers and deployment costs is particularly valuable.

What's next?

QuoteCraft is currently a functional MVP, but there are several features I'd like to explore:

Customizable PDF templates and freelancer branding

Saved client profiles and quotation history

Milestone-based project estimates

Invoice generation and payment tracking

Support for different quotation styles and industries

Optional local model inference for greater data privacy

My goal was to build a simple tool that solves a repetitive real-world problem while exploring how open-weight AI can be integrated into practical software.

QuoteCraft is a small step toward making freelance project estimation faster and more accessible.

Prize Categories

Side hustle

CP Compass: An AI Coach That Tracks How You Solve, Not Just What You Solve

Sanvi Naik — Sun, 04 Oct 2026 09:15:32 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

The Problem

The idea for CP Compass actually started before this challenge.
It started with a 45-day competitive programming challenge in my college's CP club. We committed to solving at least one problem every day, but we didn't just want a streak. We wanted to know whether we were actually improving.

So some of us started tracking everything in spreadsheets: problem name, rating, topics, what went wrong, and what we needed to revisit. It was useful information. Maintaining it was not.

After every problem came another little chore- find the problem, copy its details, add the topics, and write another row.

At first, we did it sincerely. Then came "I'll update it later."

We kept solving. The spreadsheets didn't keep up. I was guilty of it too. One friend in particular and I kept coming back to the same problem: an Accepted submission doesn't tell the full story.

One AC might mean I saw the idea immediately and implemented it cleanly. Another might mean I spent forty minutes stuck, needed a hint, and finally got it working.

Codeforces records both as solved. But when you're trying to improve, that difference matters.

So when this challenge asked me to build something for a friend, I came back to that exact frustration.

I decided to build the tracker that the two of us would actually keep using.

Meet CP Compass

CP Compass is an AI-powered competitive programming tracker that tracks not just what you solved, but how you solved it.

Enter your Codeforces handle and your solved problems, ratings, and tags are imported automatically.

Then, for each problem, record the part Codeforces can't know:

🟢 Green — Solved independently and cleanly

🟡 Yellow — Knew the approach, but made an implementation/logical mistake

🔴 Red — Couldn't derive the core idea without help

You can also add a short reflection about what went wrong.

CP Compass combines these reflections with problem ratings and topics and passes them to an open-weight Qwen model.

The AI Coach looks for patterns in why you're struggling and turns them into personalized practice recommendations.

So instead of just knowing how many problems you solved, you start understanding what is actually holding you back.

Demo

https://cp-compass-eight.vercel.app/
Here, try out my website!

Enter a Codeforces handle → import solved problems → add a few reflections → run the AI Coach.

Code

https://github.com/sanvinaik/CP-Compass

Stack: React + Vite • FastAPI • SQLite • Codeforces API • Qwen3-14B • Hugging Face Inference Providers

How I Built It

I designed CP Compass around one simple loop:

Import → Reflect → Analyze → Improve

Import — The FastAPI backend fetches solved problems, ratings, and tags from the Codeforces API.
Reflect — The user adds a Green/Yellow/Red status and an optional note. These reflections are stored in SQLite.
Analyze — CP Compass combines the problem metadata with the user's solve quality and reflections.
Improve — This structured history is sent to Qwen3-14B, an open-weight model accessed through Hugging Face Inference Providers. The AI Coach identifies recurring weaknesses and generates personalized practice recommendations.

The frontend is built with React + Vite, the API with FastAPI, and the deployed app uses Vercel + Railway.

The AI isn't there just to add a chatbot, it's what turns a collection of individual solves into patterns the user can actually act on.

Development Process

CP Compass was built over the weekend with ChatGPT-assisted development. I used ChatGPT as a coding and debugging partner while working through implementation, frontend/backend integration, and deployment.

The product idea, feature decisions, reflection system, and overall direction came from my experience with the 45-day CP challenge, with each part tested and iterated into the final working application.

Why Does Open Innovation Matter?

CP Compass uses Qwen3-14B, an open-weight model, as its reasoning layer.

For me, the biggest advantage of using an open model is freedom to evolve the AI without tying the entire product to one proprietary model or API.

The current version uses Qwen through Hugging Face Inference Providers so that anyone can try the deployed app easily. But because the intelligence comes from an open-weight model, future versions could swap models, fine-tune one specifically for competitive programming coaching, or even move inference locally.

That matters for CP Compass because its AI has a very specific job: reason over problem difficulty + topics + solve quality + personal reflections and turn them into useful practice advice.

Open innovation means I can keep experimenting with that layer as the project grows, rather than treating the AI as a black box I can't control.

The model can change. The provider can change. The core idea doesn't have to.

Back to the Friend I Built It For

CP Compass started with a problem my friend and I experienced during that 45-day challenge, so it felt fitting that the first person I wanted to give the finished version to was them.

What began as:

"We really should update that spreadsheet..."

eventually became a tool that imports the boring parts automatically, keeps the reflection that actually matters, and uses AI to turn it into something actionable. Here's what my friend said

bro this is literally what we needed during that 45 day challenge 😭 I remember we just stopped updating the excel after a point. importing everything directly makes it so much easier. also the green/yellow/red thing is actually useful because just seeing AC tells you nothing about how you solved it. AI analysis was pretty cool too, especially seeing which topics I keep struggling with

What's Next?

This is only the first version.

I'd like to expand CP Compass with contest tracking, progress visualizations, more competitive programming platforms, and better analysis across ratings and topics.

The part I'm most interested in is making the AI Coach better at distinguishing why someone couldn't solve a problem- missing knowledge, difficulty finding the observation, implementation mistakes, or simply attempting problems above their current level.

But for now, CP Compass solves the problem that started all of this:

We can keep solving problems without maintaining another Excel sheet afterward.

Prize Categories

Build for a friend