DEV Community: Architap18

Phantom Tales — Ghost in the Machine👻

Architap18 — Tue, 27 Oct 2026 18:43:52 +0000

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

What I Built

Phantom Tales is an AI-powered horror story generator that turns simple ideas into spooky stories. Users choose a location, a main character, and a fear level — Mild, Moderate, or High — and let AI bring their nightmares to life.

I interpreted Ghost in the Machine as giving a machine the ability to tell eerie, imaginative stories.

Demo

🔗 Live Demo: https://phantomtales.vercel.app/

Code

💻 GitHub Repository: https://github.com/Architap18/phantom_tales

How I Built It

I built Phantom Tales using React and Vite for the frontend, Node.js and Express for the backend, and the Groq API to generate original horror stories. The application is deployed on Vercel.

Why Does Open Innovation Matter?

Open innovation makes AI experimentation more accessible and helps developers learn, build, and share creative applications. Projects like Phantom Tales demonstrate how accessible AI tools can turn a small idea into an interactive experience.

The Spirit of It 👻

What if a simple prompt could become a nightmare? Enter a location, choose your character, and discover what the machine imagines in the darkness.

LazyDesk

Architap18 — Fri, 23 Oct 2026 09:25:29 +0000

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

What I Built

I built LazyDesk 🦥, a task declutterer built around a simple idea: sometimes, figuring out what to do next takes more energy than actually doing it.

You paste in a messy to-do list, and LazyDesk organizes it into categories, assigns priorities and effort estimates, highlights the top three tasks, and creates a manageable daily plan.

It also has Lazy Mode, which limits the daily plan to three tasks. The goal isn't to get everything done at once; it's to make starting easier.

Demo

lazydesk-lilac.vercel.app

Code

Architap18 / lazyDesk

LazyDesk — an AI-powered task organizer that turns messy to-do lists into prioritized tasks, categories, and a manageable daily plan.

LazyDesk 🦥

Do less. Make progress.

LazyDesk turns messy to-do lists into organized, manageable daily plans, helping reduce decision fatigue and focus on what matters.

✨ Features

Turn free-form task lists into organized tasks
Categorize tasks and assign priorities
Estimate effort and highlight the Top 3 tasks
Generate a manageable daily plan
Lazy Mode — focus on just 3 tasks
Copy plans and track task completion
Demo mode when no API key is configured

🛠 Tech Stack

Frontend: HTML, CSS, JavaScript
Backend: Node.js, Express
AI: Optional Groq API with a configurable model
Fallback: Rule-based task organization

🚀 Getting Started

git clone YOUR_GITHUB_REPOSITORY_URL
cd lazy-desk
npm install
cp .env.example .env
npm run dev

Open http://localhost:3000.

Add your GROQ_API_KEY to .env if using the optional AI integration. Never commit your .env file.

🌍 Why Open Innovation?

LazyDesk keeps its AI integration configurable, making it easier to experiment with compatible model providers…

View on GitHub

How I Built It

LazyDesk uses HTML, CSS, and vanilla JavaScript for the frontend, with Node.js and Express on the backend.

Task organization currently uses rule-based logic, with an optional Groq API integration for improving the summary. The model is configurable through environment variables, and the app falls back to demo mode when the AI service isn't available.

Why Does Open Innovation Matter?

I wanted the AI layer to be replaceable rather than tightly tied to one provider. Using a configurable model endpoint makes it easier to experiment with different models and understand how they affect the experience.

Open innovation also makes it easier for developers to inspect the implementation, adapt it to their own workflows, and build on top of it.

The Lazy Payoff

The small win I'm aiming for is fewer decisions before getting started.

Instead of staring at a long list and trying to figure out what deserves attention, you get a starting point and a shorter plan. Lazy Mode takes that idea a step further: three tasks are enough for a productive day to begin.

Built for Slow and Steady — because progress doesn't have to mean doing everything at once.

hacktoberfest #week3

IssuePilot AI — Your AI-Powered Guide to Open-Source Contributions 🤖

Architap18 — Thu, 15 Oct 2026 17:45:57 +0000

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

What I Built

IssuePilot AI is a beginner-friendly tool that helps aspiring open-source contributors understand GitHub issues before they start coding.

Getting started with open source can feel overwhelming. Issues often contain technical descriptions, unfamiliar terminology, long discussions, and requirements that beginners may struggle to understand.

IssuePilot AI aims to make this process easier. Users paste a public GitHub issue URL, and the application fetches the issue details, including its description, labels, and comments. It then uses AI to generate a beginner-friendly breakdown of the issue.

The goal is to help beginners understand:

What the issue is about.
What problem needs to be solved.
Which parts of the issue deserve attention.
How to approach the issue as a potential contributor.

Who would pay for it?

The initial target audience is students, coding bootcamp learners, and aspiring open-source contributors. In the future, this could evolve into a freemium product for developer communities, coding academies, and organizations that want to help newcomers contribute to open-source projects.

Demo

🚀 Live application: https://issue-pilot-ai-six.vercel.app

The frontend is deployed on Vercel, and the backend is hosted on Render.

Code

💻 GitHub repository: https://github.com/Architap18/IssuePilot-AI

The project is organized into two main parts:

Frontend: React and Vite, with a dark interface designed to make issue exploration straightforward.
Backend: Node.js and Express, responsible for fetching GitHub issue data and handling AI analysis requests.

How I Built It

I built IssuePilot AI using React, Vite, Node.js, and Express.

The application follows a simple workflow:

A user submits a public GitHub issue URL.
The Express backend retrieves the issue information using the GitHub REST API.
The issue data is passed to an AI analysis endpoint.
The AI generates a beginner-friendly explanation, estimates the issue's difficulty, and suggests investigation steps.
The frontend displays the issue information and AI-generated analysis.

For AI, I use GPT-OSS 20B (openai/gpt-oss-20b) through the Groq API. The model provides the AI analysis, while Groq handles inference.

The project is deployed using Vercel for the frontend and Render for the backend. Environment variables keep server-side credentials separate from the frontend code.

Why Does Open Innovation Matter?

Open innovation matters because it makes AI development more accessible to individual developers and students.

I wanted to build something useful without training a model from scratch or requiring expensive infrastructure. Using an open-weight model gave me access to a model that I could integrate into a practical application, while Groq provided a convenient way to run inference.

Open-source tools such as React, Express, and Vite also made it possible to build and deploy the complete application with a relatively simple development setup.

For me, this project demonstrates how existing open technologies can be combined to address a real barrier to entry: helping beginners understand open-source projects and find a starting point for contributing.

What I Learned

Building IssuePilot AI helped me work through several parts of a full-stack AI application:

Connecting a React frontend to a Node.js backend.
Retrieving and processing data from the GitHub API.
Integrating an AI inference API.
Managing environment variables and protecting API credentials.
Deploying the frontend and backend separately.
Configuring cross-origin requests between deployed services.
Updating model configurations when an API model becomes unavailable.

This project is an early step toward making open-source contribution more approachable for beginners, and I plan to keep improving it as I learn more.

devchallenge #hf26challenge