DEV Community: Ashish kumar

👻 Ghost in the Machine: Bringing Open-Source AI to Life

Ashish kumar — Thu, 29 Oct 2026 07:57:47 +0000

My submission for the Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine.

What I Built

What happens when AI starts feeling less like a tool and more like a presence inside a machine?

For this challenge, I explored the idea of building an AI-powered project that brings the theme “Ghost in the Machine” to life. The goal was to experiment with open-source AI and create something that demonstrates how intelligent systems can interact with users, understand context, and produce meaningful results.

🔧 Project Name: [Your Project Name]

✨ Key Features:

AI-powered interactions and intelligent responses.
Integration with open-source AI technologies.
A practical, user-friendly experience.
An exploration of what becomes possible when AI is built with open tools and community-driven innovation.

The most exciting part of this challenge was exploring how open-source AI can turn an idea into something people can actually use, experiment with, and improve.

Demo

🚀 Live Demo: [Add your deployed project URL]

🎥 Video Demo: [Add your demo video link, if available]

Code

💻 GitHub Repository: https://github.com/ashishkx710

The source code and project implementation are available on my GitHub profile. Feel free to explore the code, share feedback, and contribute ideas.

If you find the project interesting, a ⭐ on GitHub would be greatly appreciated!

How I Built It

I approached this project with a focus on combining software development with open-source AI capabilities.

Technologies used:

Frontend: [React / Next.js / Other]
Backend: [Node.js / Python / Other]
AI Model: [Name of the open-weight model]
AI Framework: [Ollama / Hugging Face Transformers / Other]
Database: [MySQL / MongoDB / Other, if applicable]

The development process involved designing the core functionality, integrating the AI component, connecting the application layers, and testing the overall experience.

My goal was not just to make an AI-powered application, but to understand how the underlying technology works and how it can be adapted to solve real problems.

Why Does Open Innovation Matter?

Open innovation makes AI development more accessible, transparent, and collaborative.

When developers can explore open-weight models, inspect implementations, customize workflows, and share improvements, they gain more control over what they build.

Unlike relying entirely on a closed API, open-source AI can offer opportunities to:

Experiment with models and deployment strategies.
Customize AI behavior for specific use cases.
Learn from the implementation rather than treating AI as a black box.
Build on community contributions and share improvements with other developers.

For me, the real value of open innovation is the freedom to experiment, learn, and create without treating the underlying technology as a mystery.

My Agent Session

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

This section can include the agent session that helped build or improve the project, giving others a look at the development process and the decisions behind the implementation.

The Spirit of It 👻

The idea behind Ghost in the Machine is a reminder that technology can sometimes feel mysterious when we only see its outputs and never examine what happens behind the scenes.

Working with AI gives us an opportunity to look beyond that mystery: to experiment, understand the system, and build something of our own.

This challenge was an opportunity to turn curiosity into code and explore how open-source AI can make that process more transparent and collaborative.

Prize Categories

Categories entered: [Add the applicable partner prize categories from the official challenge page.]

Final Thoughts

Hacktoberfest is about more than writing code. It is about learning in public, sharing ideas, and contributing to an ecosystem where developers can build on one another's work.

This challenge pushed me to explore the possibilities of open-source AI and think about what it means to build intelligent systems in the open.

Thanks to the organizers, maintainers, and open-source community for creating opportunities like this!

Let's keep building, experimenting, and contributing. 🚀

Hacktoberfest #OpenSourceAI #AI #MachineLearning #OpenSource #DEVCommunity

Open-Source AI Challenge Week 4: Ghost in the Machine](htt👻 Ghost in the Machine: Bringing Open-Source AI to Life

Ashish kumar — Thu, 29 Oct 2026 07:12:29 +0000

*This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine](htt👻 Ghost in the Machine: Bringing Open-Source AI to Life

My submission for the Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine.

What I Built

What happens when AI starts feeling less like a tool and more like a presence inside a machine?

🔧 Project Name: codeskill

✨ Key Features:

AI-powered interactions and intelligent responses.
Integration with open-source AI technologies.
A practical, user-friendly experience.
An exploration of what becomes possible when AI is built with open tools and community-driven innovation.

The most exciting part of this challenge was exploring how open-source AI can turn an idea into something people can actually use, experiment with, and improve.

Demo

🚀 Live Demo: ashish.softwear

Code

💻 GitHub Repository: https://github.com/ashishkr710

The source code and project implementation are available on my GitHub profile. Feel free to explore the code, share feedback, and contribute ideas.

If you find the project interesting, a ⭐ on GitHub would be greatly appreciated!

How I Built It

I approached this project with a focus on combining software development with open-source AI capabilities.

Technologies used:

Frontend: [React / Next.js / Other]
Backend: [Node.js / Python / Other]
AI Model: [Name of the open-weight model]
AI Framework: [Ollama / Hugging Face Transformers / Other]
Database: [MySQL / MongoDB / Other, if applicable]

The development process involved designing the core functionality, integrating the AI component, connecting the application layers, and testing the overall experience.

My goal was not just to make an AI-powered application, but to understand how the underlying technology works and how it can be adapted to solve real problems.

Why Does Open Innovation Matter?

Open innovation makes AI development more accessible, transparent, and collaborative.

When developers can explore open-weight models, inspect implementations, customize workflows, and share improvements, they gain more control over what they build.

Unlike relying entirely on a closed API, open-source AI can offer opportunities to:

Experiment with models and deployment strategies.
Customize AI behavior for specific use cases.
Learn from the implementation rather than treating AI as a black box.
Build on community contributions and share improvements with other developers.

For me, the real value of open innovation is the freedom to experiment, learn, and create without treating the underlying technology as a mystery.

My Agent Session

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

This section can include the agent session that helped build or improve the project, giving others a look at the development process and the decisions behind the implementation.

The Spirit of It 👻

The idea behind Ghost in the Machine is a reminder that technology can sometimes feel mysterious when we only see its outputs and never examine what happens behind the scenes.

Working with AI gives us an opportunity to look beyond that mystery: to experiment, understand the system, and build something of our own.

This challenge was an opportunity to turn curiosity into code and explore how open-source AI can make that process more transparent and collaborative.

Prize Categories

Categories entered: [Add the applicable partner prize categories from the official challenge page.]

Final Thoughts

Hacktoberfest is about more than writing code. It is about learning in public, sharing ideas, and contributing to an ecosystem where developers can build on one another's work.

This challenge pushed me to explore the possibilities of open-source AI and think about what it means to build intelligent systems in the open.

Thanks to the organizers, maintainers, and open-source community for creating opportunities like this!

Let's keep building, experimenting, and contributing. 🚀

Hacktoberfest #OpenSourceAI #AI #MachineLearning #OpenSource #DEVCommunityps://dev.to/challenges/hacktoberfest-week4-2026-10-26)*

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

The Spirit of It

Prize Categories

CodeDrill: Master Java Collections and DSA Through Deliberate Practice 🧠💻

Ashish kumar — Tue, 20 Oct 2026 17:15:13 +0000

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

What I Built

Meet CodeDrill — a deep learning and practice platform designed to help developers go beyond memorizing Java Collections and Data Structures & Algorithms (DSA).

Learning DSA isn't just about solving a problem once. It's about understanding why a solution works, knowing what's happening under the hood, and remembering those concepts when they matter most — during interviews, debugging sessions, and real-world development.

That's the problem I'm building CodeDrill to solve.

CodeDrill focuses on two important areas:

Java Collections internals: Understand memory models, HashMap bucketing, concurrency safety, iterator contracts, and the behavior of core collection classes.
DSA practice: Build problem-solving skills through structured questions, difficulty progression, and deliberate practice.
Spaced repetition: Use an SM-2-based revision strategy to help learners revisit concepts instead of forgetting them after a single study session.
Progress and mastery tracking: Turn learning progress and weak topics into actionable revision priorities.
Interactive coding: Integrate a browser-based coding experience with Monaco and a sandboxed Java execution architecture.

The philosophy is simple: don't just solve more problems; build knowledge that sticks.

CodeDrill is for students preparing for technical interviews, developers strengthening their Java fundamentals, and anyone tired of repeatedly learning the same concepts from scratch.

The long-term goal is to make consistent, focused practice easier — so developers can spend less time figuring out what to study next and more time actually learning.

Demo

🚧 A live demo or video walkthrough can be added here once available.

GitHub Repository: ashishkr710/CodeDrill

The repository includes the project specifications, architecture documentation, API contracts, data models, development roadmap, and separate frontend and backend applications.

Code

🔗 Explore the source code: CodeDrill on GitHub

The project follows a modular, two-application architecture:

Frontend: React 19, TypeScript, Vite, Tailwind CSS, Zustand, and Monaco Editor.
Backend: Node.js, Express, TypeScript, and MongoDB.
Supporting infrastructure: Docker Compose, Redis, and Judge0 Community Edition for isolated code execution.
Learning engine: Spaced repetition, mastery tracking, and weak-topic remediation.

One of my core architectural decisions is that untrusted code must never execute inside the API process. Code execution is delegated to a separate sandboxing service rather than allowing submitted code to run directly in the backend.

I've also documented the system before implementation through dedicated specifications for architecture, security, data models, API behavior, testing, and development milestones.

The intention is to build something maintainable, testable, and open to contributions — not just another collection of coding questions.

How I Built It

I approached CodeDrill as an engineering project first: define the learning experience, document the architecture, establish security boundaries, and then organize the implementation into manageable milestones.

1. Designed the learning workflow

I structured the platform around the idea that learning should be continuous rather than a one-time activity.

The revision system uses an SM-2-based spaced repetition approach to help determine when a learner should revisit a concept. Mastery tracking and weak-topic remediation are designed to make practice more focused.

2. Chose a modern TypeScript stack

I chose TypeScript across the frontend and backend to keep contracts consistent and catch errors early. The project emphasizes strict typing and avoiding any.

React and Monaco provide the foundation for the coding experience, while Express and MongoDB support the API and learning data.

3. Treated code execution as a security boundary

Running arbitrary Java code introduces real security risks. That's why the architecture separates code execution from the main API and uses Judge0 Community Edition as the execution service.

The intended deployment uses container isolation and resource restrictions rather than trusting submitted code.

4. Used documentation as an implementation tool

Before moving through implementation milestones, I organized the technical decisions into dedicated documents, including:

Product requirements and architecture decisions
Database schemas and API specifications
Backend security and frontend design
Code execution and testing strategies
Content planning and progress algorithms
Development milestones and engineering conventions

This makes it easier to reason about individual features, validate design decisions, and give future contributors a clear starting point.

5. Kept the AI direction open

For a platform like CodeDrill, open-source AI offers interesting possibilities: explaining tricky collection internals, generating alternative approaches to algorithm problems, creating hints that preserve active recall, and helping learners understand why a solution fails.

These are potential extensions of the platform, rather than features I'm claiming are already implemented. The goal is to explore AI in a way that supports learning instead of simply handing users the answers.

Why Does Open Innovation Matter?

I want CodeDrill to be more than a personal learning tool. I want its architecture and learning resources to be understandable, extensible, and open to community contributions.

Open innovation matters here for three reasons.

1. Learning tools should be adaptable.

Different learners struggle with different concepts. An open architecture makes it easier for contributors to add questions, improve explanations, expand topic taxonomies, and experiment with alternative learning workflows.

2. AI shouldn't have to be a black box.

Open-weight models and self-hosted inference can give developers greater control over model selection, deployment, privacy, and experimentation. They also make it possible to explore AI-assisted learning without making every feature dependent on a single proprietary provider.

For a learning platform, that flexibility could be valuable when experimenting with hints, explanations, and personalized revision.

3. Security and trust matter as much as intelligence.

An AI-powered coding platform still needs clear security boundaries, reliable evaluation, and predictable behavior. Open development makes architectural decisions easier to inspect and discuss, while a sandboxed execution service helps isolate untrusted code.

For me, open innovation means making it easier for others to inspect, improve, challenge, and build upon the work.

My Agent Session

I haven't linked a shareable agent session yet.

Once available, this section can include a DevRelay session showing how an AI coding agent helped with architecture exploration, implementation, testing, or documentation.

The Lazy Payoff

The real payoff I'm aiming for is reducing the mental overhead of learning consistently.

Instead of repeatedly asking:

What should I revise today?
Which Java Collection behavior do I keep forgetting?
Which DSA topics need more practice?
When should I revisit a concept I learned last week?

CodeDrill is designed to make revision and progress tracking more systematic.

Spaced repetition helps organize when to revisit material, while weak-topic remediation helps identify what deserves attention.

The idea is to replace some of the friction of planning a study session with a more structured workflow.

I haven't measured actual time savings yet, so I won't claim a specific number. For now, the goal is to make deliberate practice easier to sustain over weeks and months.

Because the best learning system isn't the one that helps you study intensely for one day. It's the one that helps you keep showing up.

Prize Categories

I'll select the applicable partner categories based on the open-source AI tools and agent workflows actually used in the project.

Update this section before publishing with the exact eligible categories from the challenge page.

Building CodeDrill has been an opportunity to combine Java fundamentals, learning science, secure code execution, and full-stack engineering into one project.

I'm excited about the possibility of making technical learning more structured, transparent, and community-driven.

If you're interested in Java Collections internals, DSA, spaced repetition, or developer learning tools, check out the repository and join me in building it.

⭐ Explore CodeDrill: https://github.com/ashishkr710/CodeDrill.git

Let's make learning a habit, not a sprint.

Hacktoberfest #OpenSource #AI #Java #DSA #TypeScript #DevTools

Hacktoberfest Weekend Challenge: Build for a Friend

Ashish kumar — Mon, 12 Oct 2026 17:37:52 +0000

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

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

[Boost]

Ashish kumar — Sat, 10 Oct 2026 14:11:50 +0000

Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass Submission 🌿

Ashish kumar

Oct 10

TrailBurn — Touch Grass, Burn Calories: An Offline-First, Open-Weight AI Outdoor Fitness Advisor

#devchallenge #hf26challenge

5 min read

TrailBurn — Touch Grass, Burn Calories: An Offline-First, Open-Weight AI Outdoor Fitness Advisor

Ashish kumar — Sat, 10 Oct 2026 13:50:19 +0000

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

🌿 TrailBurn — Touch Grass, Burn Calories: An Offline-First, Open-Weight AI Outdoor Fitness Advisor

What I Built

Most modern fitness apps do the exact opposite of what outdoor exercise should be: they keep you staring at a glowing screen, scrutinizing live heart rate graphs, tapping through ads, or following indoor video workouts.

I built TrailBurn around a simple guiding principle: the screen should be the shortest part of the experience.

TrailBurn is an open-source outdoor exercise advisor powered by local open-weight AI that answers a straightforward question:

"I want to burn 400 calories today outside — what can I do, and how long will it take?"

Who Is It For?

Outdoor enthusiasts, hikers, and trail runners who want scientifically accurate calorie goals without needing an internet connection on remote trails.
Privacy-conscious individuals who refuse to upload their body weight, workout habits, and health metrics to closed proprietary cloud servers.
Everyday people looking to touch grass — whether through trail hiking, kayaking, park calisthenics, brisk walking, or even heavy yard work and gardening.

What Does It Do?

Goal-Driven Calorie Calculator: You select your target calorie burn (from 50 kcal up to 2,000+ kcal) and body weight.
Accurate Exercise Duration Solver: Using peer-reviewed MET (Metabolic Equivalent of Task) data from the Ainsworth Compendium of Physical Activities, TrailBurn calculates the exact duration needed across 25+ outdoor activities spanning 5 outdoor environments:
- 🥾 Trails: Easy walks, moderate ascents, steep scrambles, trail runs
- 🌳 Parks: Brisk walking, jogging, outdoor calisthenics, frisbee, yoga, pickup soccer
- 🌊 Water: Leisure swimming, lap workouts, kayaking, paddleboarding, surfing
- 🏙️ Urban Outdoors: Casual biking, high-tempo cycling, roller skating, jump rope, public stair repeats
- 🌻 Garden & Yard: Light gardening, heavy soil work, push mowing, firewood chopping, leaf raking
Local AI Coach: Connects directly to Ollama running local open-weight models (like Llama 3.2, Mistral, Phi-3, or Gemma 2) to stream personalized outdoor workout plans, weather prep tips, hydration guidelines, and warm-ups without a single byte of telemetry leaving your machine.

Demo

GitHub Repository: https://github.com/ashishkr710/TrailBurn
Local Dev Preview: Run locally in seconds via npm run dev at http://localhost:5173/

How It Works in Action

Set your profile: Weight (e.g. 75 kg / 165 lbs), fitness level (Beginner, Intermediate, Advanced), and target calories (e.g. 450 kcal).
Select your outdoor scenery: Choose from all terrains or filter down to Trails, Parks, Water, Urban, or Gardening.
Get instant durations: See immediately that 450 kcal equals:
- ~48 minutes of trail running
- ~1 hour 15 minutes of moderate hiking
- ~1 hour 45 minutes of brisk park walking
- ~1 hour 2 minutes of stand-up paddleboarding
- ~1 hour 30 minutes of heavy garden digging
Chat with your AI Coach: Ask "I'm hiking an unfamiliar trail in the late afternoon. What's a smart pacing and safety plan for burning 500 kcal?" and receive a real-time streaming answer from your local open-weight LLM.
Shut your laptop, head outside, and touch grass!

Code

The complete source code is open source under the MIT License on GitHub:

ashishkr710 / TrailBurn

TrailBurn

View on GitHub

Key Architecture Highlights

src/exercises.js: Contains the full MET database for 25+ activities with beginner, intermediate, and advanced intensity factors, plus pure mathematical formulas solving for duration: $$\text{Duration (hours)} = \frac{\text{Target Calories}}{\text{MET} \times \text{Weight (kg)}}$$
src/ai.js: Client-side gateway connecting directly to local Ollama instances (http://localhost:11434/api/chat). Features automatic model detection, streaming SSE chunk parsing, fallback handling, and structured prompt engineering.
src/style.css: Custom forest-inspired dark aesthetic, fluid glassmorphism, responsive grid layout, and ambient spore/particle canvas animation written in pure Vanilla CSS without heavy UI library dependencies.

How I Built It

The Open-Source AI Stack

Local Open-Weight Models:
- Llama 3.2 (Meta): Tested with both the 1B and 3B parameter open-weight models for rapid, low-latency mobile/laptop inference.
- Mistral 7B & Gemma 2: Supported seamlessly through Ollama's model swap interface for higher-depth outdoor planning.
Local Inference Engine:
- Ollama: Serves open-weight GGUF models directly via a local REST API (/api/tags for model detection and /api/chat with stream: true).
Frontend & Math Foundation:
- Vite + Vanilla JavaScript: Zero bloat, instant startup time, offline cacheability.
- Compendium of Physical Activities: Ainsworth et al. (2011) exercise physiology data embedded directly in the client bundle.

Why Does Open Innovation Matter?

The theme of this week's challenge is Touch Grass with open-source AI at its core. Here is why an open innovation approach is strictly superior to closed proprietary APIs for this project:

1. Zero Cellular Reception on the Trail

When you pack your gear and go outside — deep into a state park, climbing an alpine ridge, or paddling across a mountain lake — cellular reception drops to zero.

A proprietary model behind an API (like OpenAI or Claude Cloud) fails immediately with Connection Refused or Network Unavailable.
Because TrailBurn is built with open-weight models and local inference via Ollama, the AI coach and calculation engine function 100% offline. You can carry your laptop or edge device into a camper van or off-grid cabin with zero signal and still get complete workout planning.

2. Radical Health Privacy (No Corporate Cloud Telemetry)

Your body weight, body composition, fitness level, and workout habits are sensitive personal health metrics.

Closed API services log prompts, retain chat histories, and often train future models on user queries.
With open-source AI, no personal data ever leaves your computer. There are no cookies, no tracking pixels, no telemetry, and no third-party data broker pipelines.

3. Model Autonomy & Swappability

Closed APIs change under your feet: models get deprecated, system prompts get throttled, and pricing changes at will. With open weights:

On a lightweight, battery-efficient ultrabook, you can spin up llama3.2:1b or phi3:mini to conserve wattage on the trail.
On a workstation at home, you can run mistral:7b or llama3.1:8b for detailed multi-day hiking expeditions.
You have complete control over system prompts, temperature, and top-p sampling.

4. Zero Token Inequity & Cost Barriers

Health and physical wellness should not require a monthly software subscription. Closed APIs impose paywalls and token metering. Open-weight models democratize access to personalized, evidence-backed fitness guidance for anyone with a computer at $0 cost.

My Agent Session

This application was developed pair-programming with Google Antigravity / Gemini CLI. The session covered:

Ideating an offline-first fitness concept adhering to the Touch Grass challenge requirements.
Extracting and codifying MET values from exercise physiology research into pure JavaScript functions.
Architecting an asynchronous streaming Ollama gateway that auto-probes local models.
Refining the dark forest glassmorphic UI with smooth slider interactions and responsive layouts.

(Agent session transcript generated with DevRelay / Antigravity IDE).

Prize Categories

Touch Grass Week 1 Main Challenge: Building with open-weight models that get people off the screen and into the real world.
Open-Source Innovation Track: Local inference, privacy-first architecture, and offline trail readiness.