DEV Community: Nikhil

👻 Ghost in the Machine: What If AI Could Bring Forgotten Stories Back to Life?

Nikhil — Tue, 27 Oct 2026 20:01:47 +0000

Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine 👻

Every machine has a history. Every file has a story. And sometimes, the things we forget are the things worth preserving the most.

We live in a world that creates memories faster than we can keep them.

Thousands of photographs sit forgotten in old folders. Messages disappear into endless conversations. Family stories survive in someone's voice, passed from one generation to another, until one day there is nobody left to tell them.

And somewhere in the digital world, abandoned projects, forgotten websites, and pieces of internet history slowly fade away.

We build technology to remember things for us.

Yet somehow, we still lose so much.

This Halloween, I wanted to explore a different question:

What if artificial intelligence could help us bring forgotten things back to life?

Welcome to my vision for the Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine. 🕯️

👻 What Does It Mean to Be a Ghost in the Machine?

The phrase sounds like something from a horror movie.

A computer behaving strangely. A terminal whispering messages. Something invisible hiding inside a system that we thought we understood.

But there's another way to look at it.

A ghost could be something that once existed but has been forgotten.

A voice preserved in an old recording. A story buried in a folder. A program written decades ago that nobody remembers how to run. A digital artifact that survives long after its creator has moved on.

These things aren't necessarily supernatural.

They're traces of the past, waiting for someone to discover them again.

And AI gives us a new way to interact with those traces.

It can help organize scattered information, transcribe old recordings, summarize forgotten documentation, and make archives easier to explore.

Perhaps the most interesting ghost in the machine isn't something haunting our computers. It's something we've left behind inside them.

🕯️ Between Halloween and Día de los Muertos

This challenge arrives at a particularly interesting time.

Halloween invites us to explore the mysterious, the eerie, and the unknown.

Día de los Muertos offers a different perspective: remembering loved ones, honoring their lives, and celebrating the stories that continue to connect generations.

One theme plays with the fear of what might be hiding in the darkness.

The other reminds us why some things deserve to remain with us, even after time has passed.

Both invite us to think about the relationship between memory and absence.

Technology usually focuses on what comes next: newer models, faster systems, and the next big innovation.

But what about everything that came before?

The knowledge we collected. The people we learned from. The software we built. The stories we promised ourselves we would never forget.

What if we used the newest technology to protect the things time might otherwise erase?

That is the direction I find most interesting about this week's theme.

🧠 Why Open-Source AI?

Preserving memories and exploring digital history introduces a challenge that goes beyond generating intelligent responses.

Some information is deeply personal.

Family recordings, old photographs, private journals, personal correspondence, and stories about people we love aren't ordinary datasets. They deserve careful handling.

And the tools we use to preserve them should not become the only places where those memories can exist.

This is where open-source AI becomes particularly meaningful.

🔐 Private by design — With a suitable local model and workflow, personal recordings, documents, and photographs can be processed without uploading them to a third-party AI service.
💻 Independent of constant connectivity — Models and supporting tools can be downloaded in advance, allowing suitable workflows to run offline.
🧩 Built to be adapted — Open models and tools can be customized for transcription, archival search, summarization, or other specialized tasks.
🕰️ Less dependence on a single platform — A thoughtfully designed archive can use portable files and replaceable components instead of relying entirely on one provider's service.
🌱 Preservation beyond the present — Open formats, documented workflows, and accessible source code can make it easier for others to maintain a project in the future.

Open-source AI does not automatically guarantee privacy or permanent preservation. Local systems still need security, backups, and careful design, while model compatibility can change over time.

But the principle matters.

If the purpose of a tool is to preserve something meaningful, we should think carefully about who controls it, where it lives, and whether it will remain accessible.

🖥️ When the Machine Starts Remembering

Imagine opening a forgotten folder on an old computer.

Inside are hundreds of files: photographs without descriptions, recordings with unclear filenames, documents scattered across directories, and notes written years ago.

Normally, making sense of everything would require hours of manual work.

Now imagine a local AI assistant that helps you explore the archive.

It identifies the contents of files, transcribes supported audio recordings, groups related material, and creates searchable summaries.

Instead of replacing the original memories, it helps you find them.

Or imagine opening an abandoned software project.

The original developer is gone. The documentation is incomplete. The dependencies are outdated.

An AI-powered archival assistant could help reconstruct the project's structure, explain the source code, and document how it worked.

Different applications, but the same underlying idea:

AI doesn't need to invent the past. Sometimes, it just needs to help us understand what is already there.

These are directions worth exploring, not features I want to claim without implementation and testing.

The challenge is to choose one focused problem and build a solution that works beyond the imagination stage.

🚀 The Vision: Give Forgotten Things a Second Life

For this challenge, I want to explore the intersection of open-source AI, digital memory, and preservation.

The goal is to build something that fits the spirit of Ghost in the Machine while solving a real problem.

Something that can take information we already have and make it easier to understand, recover, or preserve.

The project should follow a few principles:

1. Respect the original

AI-generated summaries and interpretations should never silently replace the original files or recordings.

2. Keep meaningful data under control

Local processing should be preferred when privacy matters and the chosen hardware can handle the workload.

3. Make the system understandable

Users should be able to inspect what the tool has processed and distinguish original material from AI-generated interpretations.

4. Preserve access, not just output

Portable formats, clear documentation, and replaceable components matter if the goal is to keep something accessible over time.

5. Build for a real use case

The result should be more than an interesting Halloween experiment. It should help someone accomplish something they genuinely care about.

Because the best way to honor the past is not simply to create an impressive demonstration.

It's to make preservation useful.

🌍 Innovation Isn't Only About What Comes Next

There's a tendency to measure technological progress by how much we can create.

More data. More content. More automation. More powerful models.

But progress can also mean losing less.

Helping a family preserve stories that would otherwise remain on old tapes.

Making an obscure piece of software understandable to a new generation of developers.

Recovering knowledge from documentation that has been neglected for years.

Making personal archives searchable without handing their contents to an external service.

These aren't all the same problem, and AI won't solve every part of them.

Preservation still depends on people, context, accuracy, and responsible stewardship.

But AI can make certain parts of the process less difficult.

And open-source tools give us an opportunity to build those capabilities in ways that can be inspected, adapted, and maintained by the people who use them.

Sometimes, the future of technology should include making sure the past doesn't disappear.

🤝 Building in the Open

This is part of my journey through the Hacktoberfest Open-Source AI Challenge.

In Week 1, TerraQuest explored how technology could encourage real-world adventure.

In Week 3, the Slow and Steady theme invited us to rethink how technology could reduce repetitive work and give people more time.

Now, Week 4 asks a different question:

Can we use open-source AI to bring forgotten things back into our lives?

The project concept and implementation will develop through experimentation. I'll document the decisions, technical challenges, limitations, and results as the idea takes shape.

I'd also love to hear your perspective.

Do you have an old photograph, a family recording, a forgotten project, or a piece of digital history you wish were easier to preserve?

What would you build if you could give something forgotten a second life?

Sometimes, the most meaningful technology doesn't create something entirely new.

Sometimes, it helps us rediscover what was already there.

This post introduces my vision for the Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine. The project concept, implementation, and results will be documented as development progresses.

Not everything that disappears is gone. Some things are just waiting to be remembered. 👻🕯️

🦥 Slow & Steady: What If Technology Could Give Us More Time to Do Nothing?

Nikhil — Sun, 25 Oct 2026 14:32:04 +0000

Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady 🦥

What if the smartest thing technology could do was give us fewer things to do?

We live in a world that constantly asks us to do more.

Reply to more messages. Manage more files. Keep up with more information. Remember more things. Be productive every minute of the day.

Somehow, even the tools designed to save us time have become another thing demanding our attention.

We have powerful computers in our pockets, intelligent systems at our fingertips, and AI that can accomplish things that seemed impossible just a few years ago.

Yet we still spend time doing the same small, repetitive tasks every single day.

And that made me think:

What if we stopped using AI to help us do more and started using it to help us do less?

Meet the idea behind my approach to Hacktoberfest 2026 — Week 3: Slow and Steady. 🌿

🦥 The Art of Doing Less

Sloths have an interesting philosophy.

They move slowly, conserve their energy, and don't seem particularly interested in rushing through life.

Meanwhile, we have somehow turned being busy into a badge of honor.

We celebrate packed schedules, constant notifications, and the ability to multitask, even when half of those tasks don't deserve our attention in the first place.

But not everything needs our immediate attention.

Not every message needs to be read the moment it arrives. Not every file needs to be organized manually. Not every routine task deserves another hour of our day.

Sometimes, the best solution isn't to become faster at doing something.

It's to stop having to do it yourself.

That's the idea I want to explore this week: using open-source AI to build something that quietly handles the tedious parts of everyday life, leaving people with more time and mental space for what actually matters.

💡 What If AI Became the Assistant We Barely Had to Think About?

Imagine waking up and finding that yesterday's important messages have already been summarized.

Your downloads folder is organized without you spending Sunday afternoon sorting through hundreds of files.

Your fridge inventory has been turned into a practical grocery list.

Or your day ends with a calming, personalized story generated on your own device, without needing an internet connection.

Different problems, but one underlying principle:

Technology should reduce the work required to live our lives, not create more work around itself.

I don't want to build an assistant that constantly asks questions, sends notifications, and demands attention.

I want to explore the opposite: software that understands a narrow task, handles it reliably, and stays out of the way.

Something useful enough that you notice the time it saves, rather than the technology powering it.

🧠 Why Open-Source AI?

A genuinely helpful assistant needs more than intelligence.

It needs to be affordable, adaptable, and trustworthy enough to handle the information we give it.

That's where open-source AI becomes particularly interesting.

Imagine running an AI-powered automation tool directly on your own computer.

Your files stay on your machine. Your personal information doesn't automatically need to travel to a third-party server. And the core intelligence behind the tool isn't necessarily tied to one company's API, pricing structure, or model.

With suitable open-weight models and open-source tools, that becomes a practical possibility for many tasks.

Here's what makes this approach worth exploring:

🔐 Privacy by design — Personal files and sensitive information can be processed locally when the chosen model and workflow support it.
💻 Less dependence on the cloud — Some tasks can work offline after the necessary models and dependencies have been downloaded.
💰 More predictable running costs — Local inference can avoid per-request API charges, although hardware, electricity, and maintenance still have costs.
🧩 Freedom to experiment — Models can be swapped, workflows customized, and behavior adapted to a specific task.
🌱 Technology that works for you — Instead of building around a closed service's limitations, you can design the experience around the actual problem.

Of course, open models aren't automatically the best choice for every task. They can be slower on modest hardware, make mistakes, and require careful testing.

But for small, repetitive workflows, a compact model running locally might be more than enough.

The goal isn't to use the biggest AI model available. It's to use the smallest, most practical system that gets the job done well.

🛠️ The Philosophy: Set It Up Once. Let It Work.

For this challenge, I want to explore a simple principle:

Configure once → Automate quietly → Review when needed → Get your time back.

The best version of this experience would feel almost invisible.

You wouldn't need to open an AI chatbot every time you wanted something done.

You wouldn't need to repeatedly explain the same task.

And you wouldn't need to manage a complicated workflow just to avoid a simple inconvenience.

Instead, the tool would have a clear responsibility, predictable behavior, and an easy way to review its work.

For tasks involving personal data or changes to important files, it should also have sensible safeguards. Automation should save effort without taking away control.

Because convenience is only useful when you can trust the result.

🌍 Small Automations, Bigger Impact

We often imagine AI transforming the world through giant breakthroughs.

But what if part of that transformation happens in much smaller ways?

A student gets an extra hour to study because their notes are organized automatically.

A freelancer spends less time sorting documents and more time working with clients.

A developer stops wasting time on repetitive file management.

Someone who struggles to switch off at night gets a peaceful, offline wind-down experience.

None of these needs to be revolutionary on its own.

But when a tool saves a few minutes every day, those minutes begin to add up.

And unlike many digital experiences designed to keep us engaged for longer, these tools would have a different measure of success.

The less time you need to spend using the tool, the better it may be doing its job.

🚀 What I Want to Build

This week's challenge is an opportunity to turn that philosophy into a practical project.

Rather than adding AI to an application simply because it sounds impressive, I want to focus on a specific everyday task that people repeatedly postpone, avoid, or waste time completing.

The project should be small enough to build and test properly, yet useful enough that someone would genuinely want to keep using it.

My priorities are straightforward:

Practical usefulness: Solve a real inconvenience instead of creating a problem for AI to solve.
Open-source at the core: Make the model or open-source AI framework essential to the workflow.
Minimal friction: Make the tool easy to set up and simple to use.
Privacy and control: Prefer local processing when it offers a meaningful advantage.
Reliable automation: Include appropriate checks, clear results, and human approval where needed.

The important part is making the technology work quietly in the background, without turning the solution into another demanding application.

🌿 A Different Definition of Productivity

We have spent years building technology that helps us move faster.

Faster communication. Faster computing. Faster access to information. Faster ways to finish more tasks.

But speed isn't always the answer.

Sometimes, the real benefit of technology is being able to close your laptop earlier, spend time with friends, enjoy a walk, learn something new, or simply rest without feeling that you should be doing something else.

That's the bigger idea behind this challenge.

AI shouldn't just help us become more productive. It should help us reclaim the time that productivity is supposed to give us.

And open-source AI makes that vision especially interesting because it gives independent developers the freedom to build these experiences without necessarily depending on expensive, closed, always-online services.

🤝 Building in the Open

This is part of my ongoing journey through the Hacktoberfest Open-Source AI Challenge.

In Week 1, I explored TerraQuest, a project built around making everyday outdoor exploration feel like an adventure.

For Week 3, I want to explore another side of technology: making everyday digital life feel a little less demanding.

The project will take shape through experimentation, implementation, and feedback. I'll share the technical decisions, what works, what doesn't, and how open-source AI contributes to the final result.

I'd also love to hear from others:

What's one repetitive task in your daily life that you would happily never do manually again?

Maybe it's organizing files, managing messages, planning meals, or something much more specific.

Sometimes, the most useful project ideas begin with a task we've all been putting off.

This post introduces my vision for the Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady. The project concept and implementation will be documented as development progresses.

Move slowly. Automate thoughtfully. Spend your time living. 🦥🌿

🚀 Side Hustle: What If Open-Source AI Could Turn Small Ideas Into Real Opportunities?

Nikhil — Fri, 16 Oct 2026 19:35:37 +0000

Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle 💡

What if the next useful AI-powered business didn't need a massive team, expensive infrastructure, or millions in funding?

Every day, people spend hours doing work that could be simpler.

A freelancer organizing invoices after finishing a project. A small business owner managing repetitive tasks instead of focusing on customers. An independent creator trying to turn their skills into something sustainable.

These aren't necessarily problems that need another complicated platform.

Sometimes, they just need a small, thoughtful solution.

And that raises an interesting question:

What if open-source AI made it possible for anyone to build that solution — and turn it into something people would actually pay for?

That's the idea I want to explore for the Hacktoberfest DEV Challenge — Week 2: Side Hustle.

💡 The Idea Behind the Challenge

Last week, I explored how technology could encourage people to spend more time in the real world through TerraQuest.

This week, the challenge introduces a different perspective.

Can we build something genuinely useful with open-source AI — useful enough that someone might pay for it?

Not another AI chatbot.

Not another dashboard with a long list of features.

And not something that uses AI simply because it's trending.

I want to explore how AI can solve a specific, repetitive, frustrating problem for someone who experiences it regularly.

The kind of problem where a person looks at a tool and thinks:

"I wish I had this months ago."

That reaction would mean more to me than adding another impressive-sounding feature.

🌍 Small Problems. Real People. Meaningful Solutions.

We often associate innovation with massive technological breakthroughs.

But some of the most valuable software solves surprisingly ordinary problems.

A tool that saves a freelancer several hours every week.

A system that helps a small shop owner organize information without complicated software.

An assistant that automates one tedious part of running a business.

Individually, these improvements might seem small.

But for the person dealing with that problem every day, they can make a meaningful difference.

That's what makes the side-hustle theme interesting.

The goal isn't to build the biggest product. It's to find a problem worth solving.

🧠 Why Open-Source AI?

AI is becoming increasingly powerful, but building with it often introduces new dependencies.

API costs. Usage limits. Data privacy concerns. Vendor lock-in. Limited control over model behavior.

For a small independent product, those constraints can become significant.

Open-source AI offers another direction.

Imagine building a tool where:

🔓 Developers have control — Models and components can be inspected, modified, and replaced.

🔐 Privacy is a design choice — Sensitive information can potentially be processed locally instead of being sent to external services.

💻 Local inference is possible — Some workloads can run directly on consumer hardware.

💰 Costs can remain manageable — The product doesn't necessarily depend on paying for every API request.

🧩 Specialization becomes practical — Models and workflows can be adapted to solve narrow, domain-specific problems.

Of course, open-source AI isn't automatically free, faster, or better.

Running models requires computing resources. Smaller models have limitations. Local inference introduces its own engineering challenges.

But having the freedom to choose, experiment, and optimize is incredibly valuable.

Open innovation matters because it gives independent developers more control over the technology their products depend on.

🛠️ From an Idea to Something Useful

For this challenge, I want to approach development with a simple philosophy:

Problem → Prototype → Feedback → Improvement → Value

Find a real problem

Start with an actual inconvenience someone experiences, rather than searching for a reason to use AI.

Build the smallest useful solution

Focus on one workflow and make it work well before expanding the scope.

Make open-source AI essential

The AI component should perform meaningful work, not exist as a decorative feature.

Put it in front of someone

A working prototype is only the beginning. Real feedback can reveal whether the solution is actually useful.

Explore whether the value is worth paying for

Would someone use it again? Would it save enough time or effort to justify a small payment?

These are the questions I want the project to answer.

🚀 The Vision: Build Small, Think Beyond

The most interesting part of this challenge isn't necessarily the possibility of earning money.

It's the possibility of creating something independently that delivers genuine value.

A developer with a laptop, an open-weight model, and a good understanding of a specific problem can experiment with ideas that previously might have required much larger resources.

Not every idea will become a business.

Not every prototype will find users.

And not every problem needs AI.

But the ability to build, test, learn, and improve without depending entirely on closed platforms opens up new possibilities.

Maybe the next meaningful side hustle doesn't begin with a business plan.

Maybe it begins with someone saying, "There has to be an easier way to do this."

If possible, I'd also like to get the prototype into the hands of a real user and understand whether it solves a problem they genuinely care about.

Because ultimately, a useful product should be judged by the problem it solves, not just the technology it uses.

🤝 Building in the Open

One of the reasons I enjoy these challenges is the opportunity to experiment publicly.

Sharing unfinished ideas, technical decisions, failed approaches, and incremental progress makes the development process more valuable.

It also creates opportunities for feedback and collaboration.

If you're a freelancer, independent creator, small business owner, or developer, I'd love to hear your perspective.

What's one repetitive task you wish a small, intelligent tool could take off your hands?

Maybe that's where the next idea begins.

This is an early vision for the Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle. The project concept, implementation, and results will be documented as development progresses.

The ambition is simple: Build something small. Solve something real. Make it valuable. 🚀

🌿 TerraQuest: Turn Everyday Walks Into Real-World Adventures

Nikhil — Sun, 11 Oct 2026 17:44:54 +0000

What if going outside felt less like a task and more like starting a quest?

We spend hours exploring digital worlds, completing missions, earning XP, and unlocking achievements. But when it comes to exploring the real world, stepping outside can sometimes feel like the hardest part.

I wanted to explore a different idea:

What if the real world became our adventure map?

Meet TerraQuest — an open-source project in development that aims to turn everyday outdoor exploration into a quest-driven experience through gamification, personal progress tracking, and responsible AI experimentation.

Built for the Hacktoberfest DEV Challenge — Week 1: Touch Grass 🌱

✨ What Is TerraQuest?

TerraQuest is built around one simple idea: make real-world exploration feel like an adventure.

Instead of simply telling people to go outside, the goal is to give them small, achievable reasons to explore their surroundings.

The experience is designed around several core ideas:

🌍 Real-World Quests — Discover outdoor activities and turn ordinary walks into achievable missions.
🎯 Quest Objectives — Break an adventure into clear objectives that users can work through.
⚡ XP & Progression — Build a sense of progression as quests are completed.
📓 Adventure Journal — Keep a personal record of discoveries and outdoor experiences.
🏆 Personal Achievements — Work toward milestones and celebrate consistency.
🤖 Open-Source AI — Explore how open-weight models could make outdoor adventures more personalized and engaging.

The bigger goal isn't to build another social media app that keeps people staring at a screen.

It's to create a digital companion that encourages people to put the phone away and experience the world around them.

🚀 Explore TerraQuest

🌐 Live Demo

Explore TerraQuest →

💻 Source Code

View TerraQuest on GitHub →

TerraQuest is being built as a responsive web application with a nature-inspired visual identity. Its current foundation includes quest discovery, quest detail pages, account authentication, and the initial structure for personal progress and journaling.

The project is evolving, so the live demo and repository are the best places to explore the current implementation.

🧭 How It Works

The intended experience follows a simple loop:

Discover → Explore → Complete → Reflect → Progress

Discover: Browse available quests and find an outdoor activity that interests you.
Explore: Head outside and work through the quest's objectives.
Complete: Mark objectives as you finish them.
Reflect: Record your experiences and discoveries in your personal journal.
Progress: Build a record of completed adventures and milestones over time.

The idea is to make each step small enough to feel achievable while giving users a reason to keep exploring.

This experience is being developed incrementally, with the goal of making outdoor exploration feel rewarding without making the application itself the destination.

🛠️ How I Built It

I chose a modern web stack to make TerraQuest accessible through a browser without requiring users to install a native mobile application.

Current technology stack:

Next.js + React — Application structure and interactive user interfaces.
TypeScript — Type safety and maintainability.
Tailwind CSS — Responsive styling and a consistent visual system.
Better Auth — Account registration and authentication.
MongoDB Atlas — Cloud database foundation for authentication and future user-specific data.
Vercel — Deployment and hosting.

🎨 Design Philosophy

I wanted TerraQuest to feel different from the typical gamified application.

The interface follows a nature-inspired, editorial direction with warm neutral surfaces, forest-green accents, readable typography, and a restrained visual hierarchy.

Rather than filling every screen with badges, gradients, and animations, the focus is on clarity and making the next action easy to understand.

🧠 The AI Vision

Open-source AI is an important part of the direction I want to take TerraQuest.

The goal is to explore practical uses for open-weight models, such as helping users discover suitable quest ideas based on their interests and making outdoor activities more approachable.

I don't want to add a generic chatbot simply to label the project as AI-powered. The AI component should solve a meaningful problem, produce useful results, and fit naturally into the outdoor experience.

The model integration and its evaluation need to be completed before these AI capabilities can be presented as working features.

I want to build this part carefully, with attention to usefulness, responsible implementation, and the practical limitations of running AI in a real application.

🔐 Public Discovery, Personal Progress

TerraQuest is being designed around a distinction between discovering adventures and maintaining a personal adventure history.

Visitors should be able to explore available quests before creating an account. Signing in is intended for account-specific experiences, such as personal progress and a private adventure journal.

As the project grows, the focus will remain on useful outdoor discovery first. Community features should be introduced only when they genuinely improve the experience.

🌱 Why This Project Matters

Technology gives us incredible ways to learn, create, and explore. But it can also keep us indoors for hours without us realizing it.

TerraQuest explores a small alternative: what if we used software to encourage more real-world activity instead of making screen time the destination?

I also wanted to build something that could grow in the open — a project where developers can experiment with quest systems, accessibility, responsible AI integration, and privacy-conscious outdoor experiences.

The vision is simple:

Let technology inspire the adventure. Let the real world be the experience.

🤝 Built in the Open

TerraQuest is an evolving open-source project, and there is plenty of room to improve it.

Potential areas for future contributions include:

Quest design and categorization
Accessibility and mobile usability
Progression and achievement systems
Responsible AI-powered personalization
Privacy-conscious outdoor discovery

If the idea interests you, explore the repository and follow the project as it develops.

🌿 Live Demo: terraquest-ai.vercel.app

💻 GitHub Repository: github.com/NocStaRex/TerraQuest

This project is being developed for the Hacktoberfest DEV Challenge — Week 1: Touch Grass. I'll continue updating this post as the implementation evolves.

Thanks for reading. Now go find your next adventure. 🌿

hey dev community

Nikhil — Wed, 30 Sep 2026 18:47:58 +0000

hola devs