DEV Community: Ikshita Rajput

CodeSnap AI: Let AI Handle the Tedious Parts of Learning to Code

Ikshita Rajput — Sun, 25 Oct 2026 23:39:45 +0000

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

CodeSnap AI: Let AI Handle the Tedious Parts of Learning to Code 🦥

What I Built

Learning to code through YouTube tutorials is great, but collecting code snippets from videos can be surprisingly tedious. You pause the video, try to capture the code, copy it manually, fix OCR errors, figure out what it does, and organize it somewhere for later.

I wanted to make that process easier.

CodeSnap AI is an AI-powered extension of my CodeSnap Chrome extension that helps learners capture, understand, and organize code from programming tutorials.

The goal is simple: capture code once and let AI handle the repetitive work.

Instead of manually organizing every snippet, users can:

Extract code from tutorial screenshots using OCR.
Use a local open-weight AI model to help correct OCR mistakes.
Generate concise explanations of code snippets.
Organize snippets by programming language and topic.
Create revision notes from saved code.

The idea is to spend less time managing learning materials and more time actually learning.

Demo

Demo video: [Add your demo video link here]

Live demo: [Add your deployed extension or project link here]

A demo would show a coding tutorial, capture a code snippet, process it locally with AI, and save an organized explanation for later revision.

Code

GitHub repository: https://github.com/ikshita22/Codesnap_v2

CodeSnap is the starting point for this project. The AI-powered features build on its existing code-capture workflow.

How I Built It

I built this project around an existing browser extension workflow, with the goal of introducing AI without making the entire experience dependent on a remote AI service.

The planned architecture combines:

Chrome extension: Provides the interface for capturing and managing code snippets.
OCR: Extracts text from code displayed in tutorial videos.
Open-weight language model: Helps correct OCR errors, explain code, and generate useful notes.
Local inference: Runs the model on the user's machine through a local inference runtime such as Ollama.
Snippet organization: Keeps captured code and its explanations accessible for later revision.

The important design choice is that the language model should do useful work rather than simply power a chatbot. It takes an existing, repetitive task and turns it into a more automated workflow.

Why Does Open Innovation Matter?

For a tool that processes learning materials and personal code snippets, running AI locally offers meaningful advantages.

1. Privacy by design

Code snippets can contain proprietary code, personal projects, or unfinished assignments. Local inference can keep that content on the user's machine instead of sending it to a third-party AI API.

2. Less dependence on external services

Once the model and required dependencies are installed, local inference can work without an internet connection. Capturing content directly from YouTube still requires connectivity unless the video is available locally.

3. Freedom to change models

Open-weight models make it possible to experiment with different models and choose one that works best for code correction, explanations, and note generation. The application does not have to be permanently tied to a single proprietary provider.

4. More control over cost

There is no per-request fee from a hosted AI API when inference runs locally. Users still need suitable hardware, storage, and electricity, and larger models may require more resources.

For this project, open innovation is about making AI more private, customizable, and accessible—not just adding another AI feature to a browser extension.

The Lazy Payoff 🦥

The payoff is fewer repetitive steps between watching a programming tutorial and having useful, organized notes.

Instead of repeatedly pausing, copying, correcting, explaining, and filing snippets by hand, learners can automate much of that process.

I haven't included a numerical time-saving claim because it should be measured through an actual comparison. A useful test would compare the time required to collect and organize several snippets manually against the time required with CodeSnap AI.

The aim is to make learning a little less tedious, one snippet at a time.

FinSight: Open-Source AI for Smarter Financial Analysis

Ikshita Rajput — Sun, 18 Oct 2026 14:23:56 +0000

FinSight: Open-Source AI for Smarter Financial Analysis

Submission for Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

FinSight is a financial anomaly detection and reporting tool designed for freelancers, accountants, and small businesses.

It combines three detection methods:

Rule-based detection: Flags duplicates and invalid entries.
Statistical analysis: Uses Z-scores to identify unusual values.
Machine learning: Uses Isolation Forest to detect unusual transaction patterns.

FinSight also provides financial dashboards, profit and loss analysis, balance sheet validation, variance analysis, and PDF reports.

The goal is to make financial analysis more accessible without expensive proprietary AI services.

Demo

FinSight uses a synthetic dataset of 1,000 transactions to demonstrate its workflow.

The dashboard visualizes financial metrics and detected anomalies, while PDF reports make the results easier to review.

Code

GitHub: FinSight

Built with Python, Pandas, scikit-learn, Streamlit, Plotly, SQLite, SQLAlchemy, and ReportLab.

How I Built It

I built FinSight using a modular Python architecture.

The pipeline combines deterministic financial checks, Z-score analysis, and Isolation Forest, an unsupervised machine learning algorithm from scikit-learn.

Streamlit powers the interactive dashboard, Plotly handles visualizations, SQLite supports local storage, and ReportLab generates PDF reports.

Why Does Open Innovation Matter?

Open-source machine learning makes FinSight more affordable and customizable.

Lower costs: Local inference avoids per-request AI API charges.
Privacy: Financial data can be processed locally instead of being sent to an external AI service.
Transparency: The detection pipeline can be inspected, tested, and improved.
Flexibility: The model and detection rules can be adapted to different business needs.

For a small business, an affordable tool that keeps financial data under its control can be more practical than an expensive cloud-based solution.

What's Next?

My next steps are to improve anomaly explanations, support more transaction formats, customize detection rules, and test FinSight with freelancers and small business owners.

The goal is to turn an open-source machine learning project into a practical tool that solves a real financial problem.

My First User

Add this section after someone has tested FinSight and provided feedback.

Prize Categories

Add the applicable partner categories before submitting.

hacktoberfest #opensource #ai #python

Laser-Guided Human Tracking: Exploring Open-Source Computer Vision | Hacktoberfest

Ikshita Rajput — Sun, 11 Oct 2026 21:44:43 +0000

What I Built

I built Laser-Guided Human Tracking, a Python-based computer vision project that explores face detection and tracking using computer vision tools.

The project uses OpenCV/CVZone and includes YOLOv8n model weights. It contains separate scripts for face detection and face tracking, providing a starting point for experimenting with real-time visual tracking.

My goal with this project was to explore how computer vision can detect and track people in a video stream and how software can interact with external hardware.

Demo

GitHub repository: https://github.com/ikshita22/laser-guided-tracker

Code

The main files are:

facedetection.py — face detection.

facetracking.py — face tracking.

yolov8n.pt — included YOLOv8n model weights.

README.md — project setup and dependencies.

How I Built It

I used Python and computer vision libraries to experiment with face detection and tracking. The repository includes CVZone, OpenCV-related dependencies, PyFirmata, and YOLOv8n weights.

The project explores how visual input can be processed to detect a person and follow their position. Its modular scripts make it possible to experiment with detection and tracking separately.

Why Does Open Innovation Matter?

Open-source computer vision tools make experimentation more accessible. Developers can inspect the implementation, modify the code, learn from existing models, and adapt the system to their own research and educational projects.

Building for a Friend: A Local LLM Sentiment Analyzer

Ikshita Rajput — Mon, 05 Oct 2026 05:23:01 +0000

What I Built

I built a local LLM sentiment analyzer for a friend who needed a simple way to go through a large amount of feedback without having to manually read and categorize everything.

The idea was pretty straightforward: upload a CSV containing text such as customer reviews, select the column containing the text, and let the application analyze it for sentiment.

The part I wanted to focus on was keeping the data local. Instead of sending potentially private reviews or feedback to an external AI API, the analysis runs on the user's own machine.

The basic flow is:

Upload CSV → Select text column → Run analysis → View results → Filter/export results

Code

The complete project is available on GitHub:

How I Built It

The application is built with Python and Streamlit.

For the AI part, I used Ollama to run an open-weight Llama 3.2 model locally. The application uses Scikit-LLM and scikit-ollama to connect the analysis pipeline to the local Ollama server.

The basic architecture is:

CSV
↓
Streamlit
↓
Scikit-LLM
↓
scikit-ollama
↓
Ollama
↓
Llama 3.2
↓
Sentiment / Classification Results

The default model is llama3.2:3b, and the application also supports the smaller llama3.2:1b model.

Besides sentiment analysis, I added things that make the tool more useful in practice, such as custom classification labels, optional explanations, filtering, data-quality checks, analysis history using SQLite, and exporting the results.

Why Does Open Innovation Matter?

This was probably the most important reason I wanted to build this using a local model.

When dealing with someone's reviews, feedback, or other text data, sending everything to a third-party AI API isn't always ideal. With Ollama, the model can run locally, so the data doesn't need to leave the user's computer just to get an AI-generated result.

It also means there isn't an API bill for every analysis and the application doesn't depend on a single closed AI provider.

Another thing I liked about using an open approach is that the model isn't locked into the application. I can change the model that Ollama runs without having to redesign the whole project.

For this project, open AI wasn't just something I added to satisfy the challenge. Running the model locally is what makes the privacy aspect of the project possible in the first place.