DEV Community: Rishabh Jain

Ghost Machine: An AI-Powered GitHub Repository Intelligence Platform

Rishabh Jain — Sun, 01 Nov 2026 04:20:53 +0000

Ghost Machine (RepoPilot) — AI-Powered GitHub Repository Intelligence

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

What I Built

I built Ghost Machine (RepoPilot), an AI-powered GitHub repository assessment and management platform.

Managing multiple GitHub repositories can become difficult. It is easy to overlook failed workflows, unresolved issues, inactive projects and maintenance problems.

RepoPilot helps developers understand the health of their repositories without manually checking every detail.

Key features include:

GitHub Integration: Connect your GitHub account and import repositories.
Repository Assessment: Evaluate repository health using available GitHub activity and workflow information.
AI-Powered Summaries: Generate understandable project overviews, identify risks and receive recommended next steps.
Project Management: Organize repositories by status, including In Progress, Needs Attention, Completed and On Hold.
Actionable Insights: Highlight failed workflows, maintenance concerns and other important signals.

I interpreted the Ghost in the Machine theme as giving developers an intelligent assistant that works behind the scenes, examining repository activity and bringing hidden problems to their attention.

Demo

Live Application: https://repopilot-9tal.onrender.com

Code

GitHub Repository: https://github.com/RISHABH12005/Ghost-Machine

The project is open source. You can explore the implementation, inspect the API routes and contribute improvements.

How I Built It

I built RepoPilot using a modern web application stack:

Next.js and React for the application and user interface.
TypeScript for type-safe development.
Tailwind CSS for responsive styling.
GitHub API and GraphQL API for repository information, contributions, issues, pull requests and workflow activity.
Ollama Cloud for AI-powered repository analysis.
Gemma 4 (31B) as the model used for generating repository summaries in the demonstrated configuration.

The application collects relevant GitHub metadata and sends it to the Ollama Cloud model for analysis. The model generates project overviews, identifies potential risks and recommends actions.

An important design decision is that repository summaries use GitHub metadata rather than sending entire source-code repositories to the model.

This makes the analysis focused on repository activity, maintenance and project health.

Why Does Open Innovation Matter?

Open innovation makes it possible for developers to experiment with open-weight AI models and build useful applications without depending entirely on closed AI APIs.

Using Ollama gave me flexibility in selecting and changing models while keeping the AI integration separate from the main application.

It also makes the architecture adaptable to different inference environments, including local model deployments and other compatible model providers.

Most importantly, open-source tools allowed me to build, modify and share a practical AI-powered developer tool while keeping the project accessible to other contributors.

The Spirit of It

A repository can look perfectly fine at first glance while hiding failed workflows, maintenance problems and important unfinished work.

I wanted to build something that could look beyond the repository's name and description, examine its activity and reveal what actually needs attention.

RepoPilot gives those hidden signals a voice.

Slow Steady

Rishabh Jain — Sun, 25 Oct 2026 19:21:49 +0000

Slow and Steady: A Document Studio for Academic Reports and Presentations

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

What I Built

I built Slow-Steady, a web-based academic document studio designed to simplify the process of preparing project reports and presentations.

Students often spend too much time formatting academic documents, organizing sections, and repeatedly checking their layouts instead of focusing on their actual project work. Slow-Steady aims to make this process more structured and convenient.

The application provides eight document options:

Summer Internship Report
Minor Project I Report
Minor Project II Report
Major Project I Report
Major Project II Report
Major Project Presentation
Major & Minor Project PPT
Summer Internship Report PPT

Users first select the document type from a dashboard. They then enter their project details in a split-screen workspace, where the editor sits beside a live preview.

The goal is simple: less repetitive formatting, clearer document preparation, and more time for meaningful project work.

Demo

Try the deployed application:

Open Slow-Steady

The application includes a document-selection dashboard, a document editor, a live preview, and editable DOCX/PPTX export functionality.

Code

The project is open source and available on GitHub:

RISHABH12005/Slow-Steady

You can explore the implementation, review the workflow, report issues, and contribute improvements.

The repository also includes automated compliance tests through GitHub Actions.

How I Built It

I built Slow-Steady as a web application using Python and FastAPI, with document-generation libraries for producing editable Word documents and PowerPoint presentations.

The main components include:

FastAPI: Handles the web application and document-generation requests.
python-docx: Generates editable Word reports.
python-pptx: Generates editable PowerPoint presentations.
HTML, CSS, and JavaScript: Provide the dashboard, responsive editor layout, and live preview interactions.
GitHub Actions: Runs automated tests to check the application and generated documents.
Render: Hosts the deployed web application.

I designed the interface around a two-step workflow: choose a document first, then work in a split-screen editor and preview.

The project focuses on reusable document structures, editable exports, and automated checks. Generated documents still need to be reviewed against the applicable academic guidelines before submission.

Why Does Open Innovation Matter?

Open innovation makes it possible for developers and students to inspect how a tool works, adapt it to their own needs, and contribute improvements rather than depending entirely on a closed service.

For Slow-Steady, an open-source approach means that contributors can improve report structures, add document profiles, strengthen formatting validation, and help make the tool more useful for different academic requirements.

It also makes the development process more transparent: users can inspect the code and automated tests instead of treating the application as a black box.

The project can grow through community contributions, shared feedback, and reusable solutions.

My Agent Session

I used AI assistance during development to refine the interface, improve the document-selection workflow, troubleshoot automated test failures, and make the preview easier to navigate.

I haven't included a public agent-session recording because I don't yet have a verified shareable session link. If I publish one through DevRelay, I'll add it here.

The Lazy Payoff

The biggest payoff is reducing repetitive setup work.

Instead of starting from a blank document every time, a student can select a document profile, enter project information, review the preview, and generate an editable file.

I haven't measured the time saved in a formal user test, so I won't claim a specific percentage or number of hours. The next step is to test the application with students, measure how long common document-preparation tasks take, and use their feedback to improve the workflow.

Slow-Steady is built around one idea: spend less time fighting document formatting and more time working on the project itself.

Prize Categories

Touch Grass 🌱: An AI-Powered Outdoor Challenge for Students

Rishabh Jain — Sun, 11 Oct 2026 20:30:29 +0000

Touch Grass 🌱 — Turning Screen Time into Outdoor Time

This is a submission for the Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass.

What I Built

Touch Grass is an AI-powered outdoor challenge platform built for students at Jaypee University of Engineering and Technology (JUET), Guna.

In a world where students spend hours in front of screens, I wanted to build something that encourages them to step outside, explore their campus, and reconnect with the world around them.

The platform turns going outdoors into a simple daily challenge. Students can:

🌿 Discover daily, campus-focused outdoor challenges.
📸 Submit photos as evidence of completing challenges.
🤖 Use AI-powered image verification to help assess submissions.
🔥 Track their daily activity streaks and completed challenges.
🏆 Earn milestones and celebrate their progress.
📊 View their activity through a personalized dashboard.

The goal is simple: make spending time outdoors more engaging through small, achievable actions and a sense of community.

Touch Grass is designed for JUET students, but the underlying idea can be adapted for other campuses and communities.

Demo

Try the live application: https://touch-grass-vert.vercel.app

Explore the source code: https://github.com/RISHABH12005/Touch-Grass

The application is built with a responsive interface so students can access their challenges and submit photos from their devices.

Code

The project is open source and available on GitHub:

Repository: https://github.com/RISHABH12005/Touch-Grass

The repository includes the application source code, database schema, API routes, AI integration, and setup instructions.

I welcome feedback, ideas, and contributions that make outdoor participation more engaging and accessible.

How I Built It

I built Touch Grass using a modern full-stack web architecture, combining web technologies, database-backed progress tracking, and open-source AI tooling.

Technology stack

Next.js App Router, React, and TypeScript: Application architecture, interactive interfaces, and server-side functionality.
Tailwind CSS: Responsive UI styling.
PostgreSQL and Prisma: Persistent storage for student records, challenges, submissions, and progress.
Ollama and vision-capable models: AI-assisted image verification for submitted challenge photos.
Vercel: Deployment of the web application.

The core workflow is straightforward:

A student registers and opens their dashboard.
The student views the available daily challenge.
They complete the activity outdoors and submit a photo.
The server uses a vision-capable AI model to help assess the submitted image.
The application records the submission and tracks progress, streaks, and milestones.

I integrated Ollama so the project can use a locally hosted model or Ollama Cloud, depending on the deployment configuration. This provides flexibility in how image verification is run.

AI verification is intended to assist the workflow, not guarantee that a photo proves someone's identity or physical location.

Why Does Open Innovation Matter?

Open innovation matters because useful technology should be something people can understand, adapt, improve, and build upon.

For Touch Grass, using open-source technologies and an adaptable AI integration makes experimentation more accessible. The project can evolve without tying its entire architecture to a single proprietary AI provider.

Ollama provides flexibility to experiment with vision-capable models locally or through its cloud service. This creates opportunities to explore different models, evaluate their results, and choose an approach that fits the application's needs and available resources.

Open source also makes collaboration possible. Other developers can inspect the implementation, suggest improvements, contribute features, and adapt the platform for their own campuses.

Most importantly, the idea itself is reusable. A university, school, or local community could build on Touch Grass to encourage outdoor activities, environmental awareness, and healthier digital habits.

I believe open innovation is not just about making code available. It is about giving more people the opportunity to learn, experiment, and turn an idea into something useful.

My Agent Session

I have not included an agent session link in this submission. If available, I may add a DevRelay session recording to document the development process and AI-assisted engineering workflow.

Prize Categories

Open-source AI is a core part of this project through its Ollama-based, vision-capable model integration.

I will select the applicable partner prize categories in accordance with the official challenge rules and the integrations that qualify.

Built with the idea that sometimes the best thing technology can do is help us spend less time on our screens and more time in the real world.

Let's touch grass. 🌱