DEV Community: kshitiz Tiwari

👻 PhantomAI: A Ghost in the Machine, Powered by Open-Source AI

kshitiz Tiwari — Tue, 27 Oct 2026 07:46:29 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

What I Built

👻 PhantomAI — What If Your AI Could Remember?

PhantomAI is my exploration of the idea that an AI assistant should be more than a machine that answers questions. It should be able to maintain context, connect ideas, and make interactions feel continuous.

Most AI conversations are temporary. You discuss an idea, close the tab, and return later to find yourself explaining everything again.

I wanted to explore a different experience.

PhantomAI takes inspiration from the Ghost in the Machine theme: the idea of something seemingly intangible existing within a technical system. In this project, that idea represents the traces of previous interactions that can influence what happens next.

The goal is to explore how AI can create a more connected experience through memory, context, and intelligent interactions.

Rather than trying to make AI appear conscious, PhantomAI explores a more practical question:

What happens when an AI system can remember the things that matter?

Demo

🚀 Try PhantomAI: https://phantom-ai-5fug.vercel.app/

Explore the application and experience the project firsthand.

Code

💻 GitHub Repository: https://github.com/kshitiz374/PhantomAI

The project is open source, and you can explore the implementation, understand the design decisions, and contribute to its development.

If you're interested in AI systems, persistent context, and building beyond traditional chat interfaces, I'd love for you to check it out.

How I Built It

I approached PhantomAI as an experiment in building an AI-powered application around the Ghost in the Machine concept.

The project brings together the application interface, AI-powered interactions, and the underlying logic needed to deliver its intended experience.

My focus was on creating something people could actually interact with rather than stopping at an idea or a prototype description.

The broader engineering goal is to explore how open AI technologies can give developers greater control over how intelligent applications are designed and extended.

Explore the implementation: PhantomAI on GitHub

Why Does Open Innovation Matter?

Open innovation matters because AI should be something developers can experiment with, understand, and improve—not just consume through closed APIs.

For a project like PhantomAI, openness creates several opportunities:

Freedom to experiment: Developers can explore different approaches and improve the implementation.
Transparency: An open repository makes it easier to inspect the code and understand how the application works.
Flexibility: Open architectures can make it easier to replace components and experiment with different AI technologies.
Community-driven improvement: Other developers can suggest ideas, identify limitations, and contribute improvements.
Accessibility: Students and independent developers can learn by building real applications and sharing their work.

Open innovation is not simply about making source code available. It's about giving people the freedom to understand a system, challenge its limitations, and build something better.

That's what makes this challenge exciting: the opportunity to experiment with AI in ways that go beyond conventional applications.

My Agent Session

I used the development process to explore the implementation and refine the project.

DevRelay Agent Session: [Add your saved session link if available]

This section is optional. Remove it if you don't have a session to share.

The Spirit of It

Imagine returning to an AI conversation after several days.

You ask a question connected to something you discussed earlier, and the system has enough context to continue where you left off.

That small moment changes the experience. Instead of starting over, you continue.

The machine doesn't need to be conscious for that interaction to feel different. The continuity comes from the system's design and the information it can access.

That is what makes the Ghost in the Machine theme interesting to me.

We're building systems that can preserve information, connect experiences, and influence future interactions. As these systems become more capable, questions about memory, control, and trust become increasingly important.

With PhantomAI, I wanted to explore that intersection between AI engineering and the experience of interacting with an intelligent system.

Maybe the most interesting thing about a machine isn't just what it can generate, but what it can carry forward.

Prize Categories

[Add the eligible partner categories based on the official challenge requirements.]

Final Thoughts

PhantomAI is my contribution to exploring what's possible with AI beyond the usual question-and-answer experience.

Building it has been an opportunity to think about how we design intelligent applications and why open innovation matters when experimenting with new ideas.

The project is available to explore, and I'd love to hear your feedback, suggestions, and ideas for what it could become next.

👻 Explore the project: GitHub Repository

🚀 Try the demo: https://phantom-ai-5fug.vercel.app/

Hacktoberfest #OpenSource #AI #MachineLearning #DevRelay

SlothOS: An Open-Source AI Companion That Helps You Do Less, Without Falling Behind

kshitiz Tiwari — Tue, 20 Oct 2026 13:42:37 +0000

What I Built

Meet SlothOS — a project inspired by a simple idea: technology should reduce the effort required to get things done, not give us more things to manage.

We often spend more time organizing tasks, switching between tools, and figuring out what to do next than actually doing the work. I wanted to explore a different approach: an AI-powered experience that makes everyday workflows feel simpler and less overwhelming.

SlothOS is my attempt to turn that idea into a practical project. Instead of adding more complexity to daily life, it aims to make technology feel more approachable, efficient, and effortless.

The philosophy is simple: work smarter, automate the boring parts, and save your energy for what matters.

Demo

Try SlothOS here:

🌐 Live Demo: https://slothos.vercel.app/

Code

🔗 GitHub Repository: https://github.com/kshitiz374/slothOS

Explore the code, inspect the implementation, and contribute ideas or improvements.

How I Built It

I approached SlothOS with a focus on building a usable product rather than just creating an AI-powered demo.

My development process involved designing the user experience, implementing the application, and preparing a live deployment so people can try it directly in their browsers.

For the AI component, my goal is to keep open-source AI at the center of the project. Open-weight models and open-source tooling offer a path toward AI experiences that developers can inspect, customize, and adapt to their own needs.

The project is an opportunity to explore how AI can make everyday interactions simpler while keeping flexibility and developer control in mind.

Why Does Open Innovation Matter?

AI should not be limited to developers who can afford expensive API calls or depend entirely on proprietary platforms.

Open innovation makes it possible to experiment, learn from existing work, adapt models to specific needs, and build on shared tools rather than starting from scratch.

For a project like SlothOS, that flexibility matters. The long-term vision is to make useful AI assistance more accessible, adaptable, and less dependent on a single provider.

Open-source AI also gives developers more opportunities to understand the technology behind their products and shape how it works.

The goal isn't to add AI everywhere. It's to use AI where it genuinely removes friction.

My Agent Session

I developed SlothOS as a hands-on building experience, iterating on the implementation and working toward a usable product.

If you have a saved DevRelay agent session, embed it here using the challenge's supported agent_session tag, or link to the session directly.

The Lazy Payoff

The best automation is the kind you barely notice.

SlothOS is built around the idea that even small reductions in friction can add up. Fewer unnecessary steps, a simpler experience, and less effort spent managing technology can make everyday tasks feel easier.

Rather than claiming unmeasured productivity gains, I want to keep improving the project and evaluate its real-world usefulness through actual usage and feedback.

My measure of success is straightforward: does it help someone accomplish something with less effort?

Prize Categories

I'll select the partner prize categories that match SlothOS's actual implementation and the challenge's eligibility criteria.

Building SlothOS reminded me that innovation doesn't always have to mean doing more.

Sometimes, the better solution is to make doing less work just as effective.

Stay curious. Build in the open. Embrace the sloth. 🦥

Hacktoberfest #OpenSource #AI #BuildInPublic

Pivot AI: Building a Practical AI Side Hustle with Open-Source Innovation

kshitiz Tiwari — Tue, 13 Oct 2026 18:42:25 +0000

What I Built

I built Pivot AI, an AI-powered project designed to turn an idea into a practical, useful solution.

The goal was to build something beyond a basic AI wrapper: a product that solves a real problem, delivers value to its users, and has the potential to grow into a sustainable side hustle.

I wanted to explore how open-source AI can make it easier for independent developers to build, experiment with, and improve useful AI-powered products.

Demo

🚀 Try Pivot AI: https://pivot-ai-pi.vercel.app/

Code

💻 GitHub Repository: https://github.com/kshitiz374/Pivot-AI

How I Built It

I developed Pivot AI as a web-based application and deployed it so people can explore the product directly.

My focus was on building a usable product, not just demonstrating an AI model. The project provides a foundation for experimenting with AI-powered workflows and developing features around real user needs.

For this challenge, I’m focusing on the role open-source AI can play in making the application more flexible, customizable, and accessible to independent developers.

Why Does Open Innovation Matter?

Open innovation gives developers more control over how AI-powered products are built and improved.

For a project like Pivot AI, that opens up several possibilities:

Flexibility: Experiment with different open-weight models and AI tools instead of depending entirely on a single provider.

Transparency: Learn from open implementations and adapt them to the project's specific needs.

Accessibility: Reduce barriers to experimentation for independent developers and small teams.

Ownership: Explore self-hosted or local inference where appropriate, with greater control over data processing and deployment.

I believe open-source AI should be more than a technology mentioned in a project's README. It should provide meaningful benefits to the product and its users.

My goal is to keep exploring how open technologies can make Pivot AI more useful, adaptable, and sustainable.

My Agent Session

[Add your saved DevRelay agent session here if available. Otherwise, remove this section.]

My First User

[Optional: Include real feedback from someone who tried Pivot AI, what problem it helped them solve, and whether they paid for it. Remove this section if you don't have a genuine user story yet.]

Prize Categories

[Add the eligible partner prize categories you are entering, based on the official challenge rules. Remove this section if none apply.]

Building Pivot AI has been an opportunity to explore how AI can become a practical product rather than just another demo.

I'm excited to keep improving it, learn from feedback, and explore what's possible when developers have the freedom to build with open technologies.

Give Pivot AI a try and let me know what you think! 🚀

🌿 TrailMate AI — Explore More, Scroll Less

kshitiz Tiwari — Sun, 11 Oct 2026 12:57:01 +0000

What if we built AI that encouraged us to put our phones down instead of keeping us glued to them?

That's the idea behind TrailMate AI — an outdoor companion built to help people turn free time into real-world adventures.

What I Built

TrailMate AI is designed for students, busy people, and anyone who wants to spend more time outside but needs a little inspiration to get started.

The idea is simple: choose an activity, get an outdoor mission, explore your surroundings, and return with something interesting to share.

Instead of endless scrolling, TrailMate encourages activities like nature walks, discovering different leaves, observing birds, exploring green spaces, and taking mindful outdoor breaks.

The goal isn't to make people spend more time using an app. It's to make going outside easier and more rewarding.

The philosophy behind TrailMate AI: use technology to reconnect with the world beyond the screen. 🌱

Demo

🌐 Live Demo: https://trailmate-ai-nine.vercel.app/

Try the application and explore how TrailMate turns the idea of spending time outdoors into an actionable experience.

Code

💻 GitHub Repository: https://github.com/kshitiz374/trailmate-ai

The source code is available on GitHub. I'd love to hear feedback, suggestions, and ideas for making TrailMate more useful for people who want to explore the outdoors.

How I Built It

I approached TrailMate AI with one key principle: AI should support the outdoor experience, not become another reason to stay on a screen.

The project brings together a web-based interface, an outdoor activity workflow, and an AI-focused architecture.

My main focus was to make the experience simple: users should be able to prepare for an adventure quickly, understand what to do, and then put their phones away.

I also wanted the project to be extensible, so open AI models and future nature-focused capabilities could be explored without rebuilding the entire application.

Why Does Open Innovation Matter?

Open innovation matters because it gives developers more control over the technology they build with.

For a project like TrailMate AI, that means the opportunity to experiment with open-weight models, adapt AI behavior, reduce dependence on paid inference APIs, and explore privacy-conscious ways of processing user data.

It also makes the project easier for other developers to learn from, modify, and extend.

Rather than treating AI as a closed service that the application simply calls, I want to explore how open AI can become a flexible part of a product designed around real human needs.

There's also something meaningful about the idea itself: technology doesn't always need to demand more of our attention. Sometimes, its best contribution is helping us step away.

Open innovation makes it possible to experiment, build on shared knowledge, and create technology that serves people beyond the screen.

My Agent Session

I used AI-assisted development as part of the building process.

[Add your DevRelay agent session link here, if available.]

Prize Categories

Touch Grass

[Add any additional partner categories that apply to your actual implementation and eligibility.]

What's Next?

I'd love to explore more ways to connect AI with the natural world, from nature discovery and outdoor challenges to more personalized activities for different environments.

But the most important next step is getting TrailMate into people's hands, testing it outdoors, and learning what genuinely encourages them to spend more time outside.

If you try it, I'd love to hear about your experience!

Less scrolling. More exploring. More life outside. 🌿

Hacktoberfest #OpenSourceAI #TouchGrass #AI #BuildInPublic

CodeBuddy — An AI Coding Mentor That Learns From Your Mistakes

kshitiz Tiwari — Sat, 03 Oct 2026 14:55:04 +0000

What I Built

I built CodeBuddy, a local-first AI coding mentor for a friend who is learning programming and DSA.

My friend often gets stuck while debugging code and usually has to ask someone else for help. The problem isn't always finding the correct solution — it's understanding why the code is wrong and how to avoid making the same mistake again.

CodeBuddy lets them paste their code, select the programming language, and provide an error or describe the expected behavior. Instead of immediately giving them the answer, it guides them through the problem using progressive hints and explanations.

It can:

🔍 Identify and explain the problem
💡 Provide hints before revealing the solution
📚 Explain the underlying programming concept
🛠️ Suggest a possible fix
🧠 Remember previous mistakes
🔄 Identify recurring mistakes over time

I built it specifically for my friend because I wanted to turn the kind of debugging help I was repeatedly giving them into a tool they could use themselves.

The goal isn't to replace learning with AI. It's to use AI to make the learner better at solving problems independently.

Demo

🌐 Live Demo: https://code-buddy-eight-psi.vercel.app/

The demo shows the core CodeBuddy workflow:

Code → Diagnosis → Hint → Concept Explanation → Fix → Lesson → Mistake Memory

Code

💻 GitHub Repository: https://github.com/kshitiz374/CodeBuddy

How I Built It

CodeBuddy is built as a local-first AI application, with an open-weight AI model running locally through Ollama.

The main idea is to make the AI model an actual part of the learning workflow rather than simply putting a chatbot interface on top of an AI API.

Tech Stack
Next.js + TypeScript + Tailwind CSS — frontend
FastAPI + Python — backend
SQLite — local learning history and mistake memory
Ollama — local AI inference
Open-weight AI model — code analysis and learning guidance
How It Works

The workflow is:

Code + Error
↓
Local AI Analysis
↓
Problem Diagnosis
↓
Progressive Hint
↓
Concept Explanation
↓
Possible Fix
↓
Lesson to Remember
↓
Mistake Memory

My friend enters their code, programming language, and error or expected behavior. CodeBuddy sends this context to the locally running AI model.

The model analyzes the problem and produces a structured response containing the diagnosis, hints, explanation, possible fix, and lesson.

I also built a Mistake Memory feature that stores previous debugging sessions locally. This allows CodeBuddy to recognize recurring mistakes and make future guidance more relevant.

For example, if a learner repeatedly makes mistakes involving pointers, CodeBuddy can use their previous learning history to help them recognize that pattern.

The AI isn't just an add-on chatbot — the open-weight local model is at the core of the debugging and learning experience.

Why Does Open Innovation Matter?

Open innovation matters to CodeBuddy because the project is built around learning, local use, and user control.

My friend shares source code, programming mistakes, and learning history with CodeBuddy. With a local open-weight model, the core AI processing can happen on the user's own machine rather than requiring every interaction to be sent to a closed cloud AI API.

It also gives me more control over how the AI behaves. I can experiment with different open-weight models, modify the prompts and mentoring approach, and potentially customize the system for programming education without being locked into a single AI provider.

Another important aspect is offline capability. After the required model and software are installed, the core AI experience can run without an internet connection, and there is no per-request API charge.

A closed API could provide similar coding assistance, but using an open approach made it possible to build CodeBuddy around local inference, model flexibility, customization, and offline use.

My Agent Session

Prize Categories

Built for a Friend ❤️

CodeBuddy started with a simple problem:

“My friend keeps getting stuck on the same coding mistakes.”

Instead of just fixing the code for them, I wanted to build something that could help them understand why they were stuck.

That's what CodeBuddy is about:

Less “Here's your answer.”
More “Here's how you can figure it out.”