DEV Community: Tripurala Spandana

LaterLess: Let Your Local AI Handle the Busywork

Tripurala Spandana — Sat, 24 Oct 2026 08:25:41 +0000

What I Built

I built LaterLess — Let Your Local AI Handle the Busywork.

I wanted to build something practical with AI that could help with everyday tasks. Organizing files manually can be annoying, especially when there are lots of files with unclear names.

LaterLess uses AI to suggest suitable categories and cleaner filenames. I can review the suggestions, select the changes I want, and apply them. It also has an undo feature to reverse the last organization operation.

I tested it using sample files and successfully tried the complete process, from scanning files to organizing a selected file and undoing the changes.

My goal is simple: spend less time organizing files and more time doing other things!

Demo

LaterLess currently runs locally on my computer.

I'll share a short video demo showing how it scans files, generates AI suggestions, organizes selected files, and undoes the changes.

Code

GitHub Repository:

25A35A0530 / LaterLess

LaterLess — Let Your Local AI Handle the Busywork

LaterLess is a local AI-powered file organizer that helps reduce the time spent organizing files manually. It uses an open-source AI model through Ollama to suggest meaningful file categories and cleaner filenames, allowing users to review and approve changes before applying them.

Built for the Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady.

✨ Features

AI-powered suggestions: Uses a locally running AI model to suggest file categories and cleaner filenames.
File scanning: Scans files in the selected sample folder.
Preview before applying: Lets users review suggestions before making changes.
Selective organization: Allows users to choose which suggested changes to apply.
Automatic organization: Moves approved files into category folders and renames them.
Undo support: Provides an option to reverse the last organization operation.
Local AI processing: Uses Ollama to run the AI model locally.
Simple web interface: Provides an…

View on GitHub

How I Built It

I built LaterLess using Python for the backend and HTML, CSS, and JavaScript for the web interface.

For the AI, I used Ollama with the Qwen2.5-Coder 3B model, which runs locally on my computer.

The application scans sample files, asks the AI for category and filename suggestions, and lets me choose which changes to apply. Once approved, the application moves and renames the selected files. The undo feature helps restore the previous state.

Building this project helped me understand how to connect a local AI model to a working application instead of just using AI to generate answers.

Why Does Open Innovation Matter?

As a student, open-source tools give me the opportunity to experiment, learn, and build projects without depending entirely on paid AI services.

Using Ollama and an open-weight model allowed me to explore local AI inference and connect it to my own application. I could test the idea on my computer and learn by making improvements along the way.

I also like that other developers can explore the code, suggest improvements, and build on the idea.

TutorKitAI: Building a Local AI Teaching Assistant with Ollama

Tripurala Spandana — Fri, 16 Oct 2026 13:47:26 +0000

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

What I Built

I built TutorKitAI, a small AI-powered teaching assistant that helps create study materials without having to write everything from scratch.

I got the idea from a simple question: what if a tutor could enter a topic, choose a grade and language, and get a useful starting point for a lesson or worksheet in a few seconds?

That is what I wanted to try with this project.

TutorKitAI can generate:

Lesson plans for different subjects and grades
Worksheets with practice questions and answer keys
Quizzes for checking understanding
Revision notes for exam preparation
Simple explanations of difficult topics

I also added language options for English, Telugu, and Simple English. I wanted to include Telugu because learning materials should be useful to students who are more comfortable learning in their own language.

The idea is to make preparation a little easier for tutors, teachers, and people who teach part-time. Instead of starting with a blank page, they can generate a draft and adapt it for their students.

For the side-hustle angle, I can see this being useful for independent tutors and small tuition centres that need to prepare learning materials regularly. It could eventually become a paid tool, but right now I'm focusing on getting the core features working properly.

Demo

Project: TutorKitAI

GitHub repository:

The project runs locally on my computer. I haven't deployed a public live demo yet, so the repository is the best place to explore the code.

Code

25A35A0530 / TutorKitAI

TutorKit AI ✳

A local AI-powered teaching assistant that helps tutors create educational materials using Ollama.

TutorKit AI helps tutors prepare lesson plans, worksheets, quizzes, revision notes, and simple explanations through an easy-to-use web interface. It runs locally on your computer using an Ollama model, allowing you to generate educational content without depending on a hosted AI API.

✨ Features

Lesson Plan Generator — Create structured lesson plans with objectives, teaching steps, activities, assessment, and homework.
Worksheet Generator — Generate practice questions with a separate answer key.
Quiz Generator — Create multiple-choice questions with answer keys and explanations.
Revision Notes — Generate topic summaries, definitions, examples, and practice questions.
Simple Explanations — Break down topics into short, student-friendly explanations.
Multilingual Output — Generate content in English, Telugu, and Simple English.
Difficulty Selection — Choose Easy, Medium, or Hard.
Grade Selection — Tailor content to the selected grade or learner level.
…

View on GitHub

The repository contains the frontend, Python server, and README with setup instructions.

How I Built It

I wanted to keep the project simple enough to understand and run on my own computer, so I went with a lightweight stack.

Here's what I used:

Python for the backend server
HTML, CSS, and JavaScript for the interface
Ollama to run the AI model locally
Qwen2.5-Coder 3B as the model for generating educational content
Local storage to keep saved materials in the browser

The frontend sends a request to the Python server, which communicates with Ollama's local API. The generated content is then displayed in the interface, where users can copy it, download it, or save it to their library.

One thing I liked about this setup is that I didn't need to build the whole project around a paid AI API. The model runs locally, which made experimenting with prompts much easier.

Testing was an important part of the process. I tried different topics and content types, including a lesson plan on the water cycle, fraction worksheets, and simple explanations in Telugu.

The Telugu output also reminded me that getting a response from an AI model isn't the same as getting a good response. I had to pay attention to repetition, clarity, and whether the generated content actually followed the prompt. There is still room to improve the quality, especially for educational content in different languages.

I also tested basic features such as copying, downloading, and saving generated materials. I want the app to be useful beyond the moment when the AI finishes generating text.

Why Does Open Innovation Matter?

For me, open innovation made it possible to experiment without making API costs the first obstacle.

Using an open-weight model through Ollama meant I could run the model on my own machine, test different prompts, and build the surrounding application myself. I could work on the frontend and backend while keeping control over how the AI was used.

It also made the project easier to experiment with at my own pace. I didn't need to depend on a hosted AI service for every test.

Of course, running a model locally has its own limitations. Output quality depends on the model, and smaller models may struggle with complex instructions or some languages. Local inference also depends on the computer's available resources.

But that trade-off was worth exploring for this project. I got to learn how an AI-powered application works from the interface to the model response, instead of only connecting to an external API and treating the model as a black box.

My Agent Session

I haven't published a DevRelay agent session for this project yet, so I'm leaving this section out rather than linking to something that isn't available.

Prize Categories

Side Hustle — TutorKitAI explores how a local AI tool could help independent tutors and small tuition centres spend less time preparing learning materials.

MemoryWalk — AI That Encourages You to Touch Grass

Tripurala Spandana — Sat, 10 Oct 2026 13:52:34 +0000

What If AI Helped Us Notice the World Around Us? 🌿

We use our phones to learn, work, communicate, and even relax. But sometimes, we get so used to looking at a screen that we stop noticing what's happening around us.

The sound of birds outside. The wind moving through the trees. A small plant we've walked past a hundred times without really looking at it.

I started thinking about this while working on the Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass.

Instead of building another AI tool that asks people to spend more time on their devices, I wanted to try something different.

That's how MemoryWalk started.

What I Built

MemoryWalk is a small web application powered by locally running AI. It gives you an observation mission to complete in the real world, encourages you to put your phone away, and lets you reflect on what you noticed when you return.

The idea is simple: AI gives you something to notice. Then you put the phone away.

Here's how it works:

Choose how much time you have and what you want to focus on.
Get an AI-generated observation mission.
Put your phone away and explore your surroundings.
Return and answer a few reflection questions.
Receive AI-generated feedback, a score, and a personal takeaway.
Save the experience in your Memory Garden.

For example, a mission might ask you to become a sound detective for ten minutes. Instead of listening to music or scrolling, you pay attention to birds, passing vehicles, the wind, and sounds you usually ignore.

Another mission might ask you to observe the colors and patterns of plants around you.

These are ordinary things, but the goal is to experience them more intentionally.

Demo

The best way to understand MemoryWalk is to see the experience from beginning to end.

The demo should show the home screen, generating a mission, completing the reflection flow, and saving a memory in the Memory Garden.

🎥 Demo video:

💻 GitHub repository:

25A35A0530 / MemoryWalk

🌿 MemoryWalk — Look Up. Look Around.

AI gives you something to notice. Then you put the phone away.

MemoryWalk is a local-AI-powered experience designed to help people step away from their screens and pay attention to the world around them.

Choose how much time you have and what you want to notice. MemoryWalk generates a small observation mission using a locally running AI model. Put your phone away, go outside, observe the real world, and return to reflect on what you experienced. Turn that moment into a personal memory in your Memory Garden.

✨ What It Does

Personalized observation missions: Generate a mission based on your available time and chosen focus.
Explore the real world: Observe nature, listen to your surroundings, discover tiny details, or let curiosity choose.
Phone-down experience: Encourages you to leave the screen behind while completing your mission.
AI-powered reflection: Return and respond to reflection questions…

View on GitHub

You can also run the project locally using the instructions below.

How I Built It

I kept the stack simple because I wanted to focus on the experience rather than setting up a complicated infrastructure.

The project uses:

HTML, CSS, and JavaScript for the frontend.
Python for the local web server and backend endpoints.
Ollama to run the AI model locally.
qwen2.5-coder:3b for generating observation missions, reflection questions, and feedback.

The browser communicates with the Python backend, which sends prompts to Ollama. The generated responses are then displayed in the application.

The basic architecture looks like this:

Browser → Python backend → Ollama → Local language model

One thing I wanted to explore was whether AI could be useful without becoming the main activity itself. In MemoryWalk, the AI starts the experience, but the important part happens away from the screen.

Building this also gave me an opportunity to work through the practical details of connecting a frontend to a local model, handling generated responses, and making the interface feel like a complete experience rather than just a chat window.

Why Does Open Innovation Matter?

For this project, open innovation matters because it gives developers room to experiment with AI in different ways.

Using Ollama with a locally runnable model allowed me to build and test MemoryWalk on my own computer without relying on a paid hosted-model API.

There are a few things I appreciate about this approach:

1. More control over experimentation

I can change prompts, test different missions, and explore other compatible models without redesigning the whole application.

2. A local-first approach

The model runs on my own machine, which makes local experimentation possible without sending every prompt to a hosted AI service. The application still needs to be assessed for its complete data handling and privacy behavior, but local inference gives me more control over where model processing happens.

3. Lower barriers for individual developers

You don't necessarily need a complex cloud setup to start experimenting with language models. A local runtime and a compatible model can be enough to build a useful prototype.

4. AI doesn't always need to keep us online

This is the part that connects most closely to the challenge. AI is often used to generate more content for us to consume. I wanted to experiment with using it as a starting point for something offline: observing, listening, reflecting, and remembering.

Open tools made it easier for me to explore that idea with the resources I had available.

What I Learned

One of my biggest takeaways was that the AI model is only one part of the experience.

The flow around it matters just as much. A generated mission needs to be clear enough to follow, the reflection should feel natural, and the application should encourage users to leave the screen instead of giving them another reason to stay.

I also learned to pay attention to the small implementation details that make a project usable, from connecting frontend files correctly to testing the full mission and reflection flow.

MemoryWalk is still a small project, and there is room to improve it. I'd like to explore more mission types, improve the Memory Garden, and make the experience even better on mobile devices.

But I like the idea behind it: technology can help us pay attention to life outside technology.

My Agent Session

I used AI assistance during development to help work through implementation questions, debug issues, and improve the interface. I tested the application locally as I built it and made adjustments when things didn't work as expected.

The project uses Ollama and qwen2.5-coder:3b for its local AI functionality.

What's Next?

I'd like to keep improving MemoryWalk and see how people use it.

What would you want your first mission to be: noticing nature, listening to the sounds around you, or finding tiny details you've never paid attention to before?

I'd love to hear your ideas in the comments.

Sometimes, the most interesting thing an AI can do is give us a reason to look away from it.

Look up. Look around. Keep the moments that matter. 🌿

I Built My Friend a Local AI Coding Buddy

Tripurala Spandana — Sun, 04 Oct 2026 11:20:44 +0000

CodeBuddy: A Local AI Coding Companion I Built for a Friend 🤖

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

What I Built

I built CodeBuddy, a small AI coding companion for a friend who is learning programming.

When you're learning to code, getting stuck is probably one of the most frustrating parts. Sometimes it's a syntax error, sometimes you understand the concept but don't know how to approach a problem, and sometimes you just need someone to explain it in a simpler way.

I wanted to build something that could help with those situations without making the learning process more complicated.

CodeBuddy currently has four main options:

Ask a Coding Question — ask about a programming concept and get an explanation.
Debug My Code — share code that isn't working and get help understanding the problem.
Give Me a Hint — get a small push in the right direction instead of immediately seeing the complete solution.
Practice Question — get programming questions to practice with.

The last one was important to me because I don't want an AI assistant to only give answers. If someone is learning, sometimes a hint or a practice problem is more useful than a complete solution.

I kept the application intentionally simple. My goal wasn't to build another huge coding platform. I wanted to build something my friend could open when they are stuck and immediately know how to use.

The AI behind CodeBuddy runs locally using Ollama with the Qwen2.5-Coder:3b model.

Demo

Here is the CodeBuddy demo:

In this demo, I show the main CodeBuddy features, including asking a coding question, debugging code, getting a hint, and generating a practice question.

The demo also shows that CodeBuddy is running locally on my computer using Ollama and Qwen2.5-Coder:3b.

Code

The complete project is available on GitHub:

25A35A0530 / CodeBuddy

CodeBuddy 🤖

A local AI coding practice assistant powered by open-source AI.

CodeBuddy is a beginner-friendly coding assistant built for learners who want help with programming questions, debugging, hints, and practice — while keeping their interactions local on their own computer.

It uses Ollama to run the open-source Qwen2.5-Coder model locally.

✨ Features

💡 Ask a Coding Question — Get simple explanations of programming concepts.
🐛 Debug My Code — Understand errors and find possible fixes.
🧩 Give Me a Hint — Get guidance without immediately seeing the full solution.
📝 Practice Question — Generate programming questions for practice.
🔒 Local AI — Questions and code are processed locally through Ollama.
🌐 Simple Web Interface — Clean and beginner-friendly UI.

🏗️ How It Works

User
  ↓
CodeBuddy Web Interface
  ↓
Python Local Server
  ↓
Ollama
  ↓
Qwen2.5-Coder
  ↓
AI Response
  ↓
CodeBuddy Interface

The application uses:

HTML for the interface
…

View on GitHub

The project is intentionally small and has only a few main files:

CodeBuddy/
├── index.html
├── style.css
├── server.py
└── README.md

I wanted to keep it simple enough that I could understand every part of it rather than depending on a large number of frameworks or services.

How I Built It

I started with the part I was most curious about: running a coding model locally.

I installed Ollama and downloaded Qwen2.5-Coder:3b. Before building the interface, I tested the model directly and tried a few programming questions to see how it responded.

Once I knew that part was working, I connected it to Python.

For the backend, I decided to keep things lightweight and use Python's built-in HTTP server functionality instead of adding another framework.

Then I worked on the browser side using HTML, CSS and JavaScript.

At first, I was mainly focused on getting the basic interaction working. I wanted to be able to type a question in the browser, send it to Python, have the local model process it, and display the answer back in the page.

After that was working, I spent more time on the interface and on making the different learning options easy to use.

The final setup uses:

HTML, CSS and JavaScript for the frontend
Python for the local server
Ollama for running the AI model
Qwen2.5-Coder:3b for coding-related responses

One thing I liked about this setup was that I didn't need to build a large backend just to make a small AI learning tool.

The application communicates with Ollama on the same computer, so after the model has been downloaded, the normal AI interaction can run locally.

Why Does Open Innovation Matter?

This is probably the part of the project that made me think the most.

I've used AI through online APIs before, so using a model locally was a different experience for me.

For CodeBuddy, I didn't really need a large cloud infrastructure. I wanted a coding assistant that could run on a personal computer and help with programming questions.

Running the model locally gives me more control over that setup.

For example, the user's coding questions don't have to be sent to a remote AI service just to get a response. That can be useful when someone is experimenting with their own code and wants to keep their work local.

There is also no separate API request cost for every question once the model has been installed.

Another thing I liked is the flexibility. Because I'm using Ollama, I can experiment with different compatible local models later without rebuilding the entire application around a particular hosted API.

There are trade-offs, of course.

Local AI needs the computer to have enough resources to run the model, and the initial model download requires an internet connection. A local model may also not perform the same way as a much larger cloud model.

But for CodeBuddy, I think the trade-off makes sense.

My friend doesn't need a huge AI system just to ask:

"Why isn't this Python code working?"

A local coding model is enough for what I wanted to build.

That's what open innovation made possible for this project: I could experiment with AI locally, choose how it fits into my application, and build a small tool without making a cloud AI API the center of the project.

My Agent Session

I did not use DevRelay for this project, so I am leaving this optional section out.

Prize Categories

I am not entering a partner-specific prize category for this project.

Building CodeBuddy also taught me something outside of the technical side.

When I started, it would have been easy to keep adding features just because they sounded interesting. But because I was building this for one person, I kept coming back to a much simpler question:

Would this actually help my friend when they are learning programming?

That helped me keep the project focused.

I also learned that I don't always need a complicated stack to build something useful. A small Python server, a simple frontend, Ollama, and a local coding model were enough to turn the idea into a working application.

CodeBuddy isn't meant to be the ultimate AI coding assistant.

It's just something I built for a friend who is learning.

And that's exactly what I liked about this challenge.

I started with a person, found a problem, and then chose the technology that could help solve it.

🤖 Built for a friend. Built to learn.

Intro

Tripurala Spandana — Thu, 01 Oct 2026 14:03:44 +0000

I am new to the community, happy to be the part of dev.