DEV Community

Cover image for I Revived Intelliyash: A Local-First AI Builder for Low-End Machines
FOKRUL ISLAM
FOKRUL ISLAM

Posted on

I Revived Intelliyash: A Local-First AI Builder for Low-End Machines

#devchallenge #githubchallenge #githubcopilot #ai

GitHub “Finish-Up-A-Thon” Challenge Submission

This is a submission for the GitHub Finish-Up-A-Thon Challenge.

Project Links

Live Demo:

https://intelliyash.vercel.app/

GitHub Repository:

https://github.com/fokrulanthro16-eng/intelliyash

What I Built

Intelliyash is a local-first AI runtime and builder designed for people who want to use AI without depending on expensive cloud APIs, complex setup, or high-end hardware.

The core idea is simple:

From Idea to Local AI in Minutes.

Instead of asking users to understand model names, quantization, RAM limits, CLI tools, or API keys, Intelliyash aims to handle the hard parts automatically.

Users can describe what they want to build, and Intelliyash helps guide them toward a local AI assistant or app structure that can run on their own machine.

The project focuses on:

  • Local-first AI
  • No required API key
  • No cloud lock-in
  • Low-end hardware support
  • Simple UX for non-expert users
  • A polished AI product experience

Why I Revived This Project

Intelliyash started as an ambitious local AI experiment.

The original goal was to create an AI runtime that could work on low-end machines and automatically choose the right local model based on the user’s hardware.

But like many side projects, it became unfinished.

There were useful parts already inside the project, but it needed polish:

  • The user experience was not clear enough
  • The landing page needed a stronger story
  • The project needed a better submission narrative
  • Some routes needed build fixes
  • The product needed a clear before-and-after arc
  • The README and challenge story needed improvement

The GitHub Finish-Up-A-Thon Challenge was the perfect reason to come back, clean it up, and finally make it feel like a real product.

Before

Before this revival, Intelliyash was more of a technical experiment than a finished product.

It had:

  • A local AI runtime concept
  • A chat-style interface
  • Model and project sections
  • Some backend ideas
  • Early low-memory support
  • A basic structure for local AI workflows

But it lacked:

  • A polished landing page
  • Clear product positioning
  • A strong homepage message
  • A complete submission story
  • A clean “why this matters” explanation
  • A finished DEV Challenge presentation

The project existed, but the value was not immediately obvious to a new visitor.

After

After the polish work, Intelliyash now has a much clearer product experience.

The new version includes:

  • A cinematic landing page
  • Clear headline: “From Idea to Local AI in Minutes”
  • A stronger local-first AI message
  • Idea Drop Zone concept
  • Feature cards
  • Local-first architecture explanation
  • GitHub CTA
  • Working routes
  • Successful production build
  • Updated submission story
  • GitHub Copilot-assisted review and polish

Now the project communicates what it does much faster:

Intelliyash helps people go from an idea to a local AI app without needing API keys, cloud credits, or deep machine learning knowledge.

How GitHub Copilot Helped

GitHub Copilot helped me review the final project and improve the submission quality.

I used Copilot to:

  • Review the project for the GitHub Finish-Up-A-Thon Challenge
  • Improve the project story
  • Sharpen the README/submission direction
  • Create a stronger before-and-after narrative
  • Highlight key stats and product value
  • Check whether the project clearly showed a completed polish arc

One of the strongest ideas Copilot helped clarify was this:

We built Intelliyash because AI should work for everyone — not just people with API keys, cloud credits, and machine learning expertise.

Copilot also helped shape the key product message:

  • Time to first app: around 30 minutes instead of hours
  • Monthly cost: $0 instead of ongoing API costs
  • Hardware support: designed for low-end machines
  • Privacy: local-first by default
  • Vendor lock-in: zero

This helped turn the project from “just a codebase” into a stronger challenge submission with a clearer story.

The Main Problem

Most AI tools assume users already have:

  • API keys
  • Cloud credits
  • A powerful machine
  • Knowledge of models
  • Knowledge of prompts
  • Knowledge of inference tools
  • Time to configure everything manually

But many developers, students, and indie builders do not have all of that.

For many people, the problem is not imagination.

The problem is setup.

Intelliyash tries to solve that setup problem.

The goal is to make local AI feel approachable, especially for people on limited hardware.

Key Features

1. Local-First AI

Intelliyash is designed around the idea that AI should be able to run locally whenever possible.

This means:

  • Better privacy
  • Lower cost
  • Less dependency on cloud providers
  • More control for users

2. Low-End Hardware Support

The project is designed with low-memory machines in mind.

Instead of assuming everyone has a powerful GPU, Intelliyash focuses on making AI more accessible to people using lower-end devices.

3. Idea Drop Zone

The Idea Drop Zone is the main product concept.

The user writes an idea, and Intelliyash helps turn that idea into a local AI app direction.

Example:

“I want an AI assistant for my small shop that can answer customer questions.”

Intelliyash can then guide the user toward:

  • Assistant type
  • Suggested stack
  • Local-first architecture
  • Project plan
  • Possible model/runtime direction

4. No API Key Required

A major goal is to reduce dependency on paid APIs.

Cloud APIs are powerful, but they are not always accessible for everyone.

Intelliyash is built around the idea that AI should still be useful even when a user does not have cloud credits or API access.

5. Simple User Experience

I wanted the project to hide technical complexity behind a clean interface.

The user should not need to understand every model detail before getting started.

The product should feel simple:

Describe your idea.

Let Intelliyash guide the setup.

Build locally.

Tech Stack

The project uses:

  • Next.js
  • TypeScript
  • Tailwind CSS
  • Local AI runtime ideas
  • Vercel deployment
  • GitHub for source control
  • GitHub Copilot for review and polish

What I Fixed During the Finish-Up

During the revival process, I worked on:

  • Improving the landing page
  • Keeping the existing chat experience safe
  • Making the root route more product-focused
  • Preserving existing routes like /chat, /models, /projects, /playground, and /settings
  • Fixing frontend build issues
  • Cleaning up API client behavior
  • Testing the production build
  • Pushing final changes to GitHub
  • Preparing the submission story

The final build passed successfully, and the working tree was clean after the last push.

Challenges I Faced

The biggest challenge was balancing two things:

  1. Keeping the existing project functionality safe
  2. Making the project look polished enough for a public challenge submission

I did not want to destroy the existing app just to create a nice landing page.

So the goal was to improve the presentation while keeping the actual product structure alive.

Another challenge was build stability.

Some pages worked during development, but production build found issues that needed to be fixed before submission.

That was an important reminder:

A project is not really finished until it builds successfully.

What I Learned

This challenge reminded me that finishing a project is different from starting one.

Starting is exciting.

Finishing requires:

  • Cleaning
  • Testing
  • Explaining
  • Documenting
  • Fixing edge cases
  • Making the value obvious

I also learned that a strong project needs more than code.

It needs a story.

For Intelliyash, the story became:

AI should be local, affordable, private, and accessible — even on low-end machines.

What’s Next

Next, I want to continue improving Intelliyash with:

  • Better local model selection
  • More complete Idea Drop Zone generation
  • Project template export
  • Local assistant packaging
  • Better offline mode
  • More beginner-friendly setup
  • Stronger backend integration
  • More examples and demos

The long-term vision is:

A user drops an idea, and Intelliyash generates a local-first AI assistant or app that can run without cloud dependency.

Final Thoughts

I revived Intelliyash because I believe AI tools should be more accessible.

Not everyone has expensive hardware.

Not everyone has cloud credits.

Not everyone wants vendor lock-in.

But everyone should be able to build with AI.

That is what Intelliyash is trying to make possible.

This project went from an unfinished local AI experiment to a polished, challenge-ready product experience.

And now it finally feels ready to share.

Links Again

Live Demo:

https://intelliyash.vercel.app/

GitHub Repository:

https://github.com/fokrulanthro16-eng/intelliyash

Top comments (0)