DEV Community: Koushitha Seemakurthi

REQUIEM: The Ghost Archive — Bringing Abandoned Open-Source Projects Back to Life with AI

Koushitha Seemakurthi — Wed, 28 Oct 2026 14:32:59 +0000

REQUIEM — The Ghost Archive 👻

Every abandoned project leaves a ghost. What if AI could help us uncover its unfinished story?

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

What I Built

REQUIEM — The Ghost Archive is a digital archaeology prototype designed to investigate abandoned open-source projects, uncover their original intentions, connect scattered evidence, and help developers understand what could be revived.

Open-source repositories are more than collections of files. They contain ideas, experiments, unfinished features, architectural decisions, and the work of people who once believed in a project.

When a project becomes inactive, its story often becomes difficult to reconstruct.

REQUIEM explores how AI can help us recover that story.

Instead of building another generic AI chatbot or code generator, I wanted to explore a different question:

Can AI help us understand what a project was trying to become, not just what its code does today?

How It Works

REQUIEM is designed around a digital archaeology workflow:

1. Project Autopsy

Investigate a project's source files, documentation, and available repository history to understand its purpose and architecture.

2. The Evidence Vault

Organize findings into understandable evidence cards. The goal is to connect claims to source files and distinguish verified observations from AI interpretations.

3. The Ghost Timeline

Reconstruct a project's development story from available commits, branches, issues, and other historical evidence.

4. The Unfinished Dreams Map

Explore relationships between intended features, source files, dependencies, tests, and incomplete work.

5. The Revival Blueprint

Turn discoveries into practical next steps, helping developers identify areas that could be documented, tested, repaired, or continued.

The prototype also includes a cinematic Archive Chamber, a sample investigation, model configuration controls, and a dossier export option.

Why “Ghost in the Machine”?

The theme inspired me to think of abandoned code as a digital ghost.

A repository can still exist long after its original purpose has been forgotten. The evidence remains, but the intent behind it may be scattered across old commits, incomplete implementations, outdated documentation, and unresolved issues.

REQUIEM treats those remnants as clues.

The visual experience reflects that idea through a dark, atmospheric archive, a spectral digital archivist, violet storm lighting, floating code, and a long-scrolling investigative journey.

The aesthetic is intentional: the project should feel like entering a forgotten digital world rather than opening another ordinary dashboard.

But the real goal goes beyond the visuals. The interface is meant to make software archaeology understandable and engaging.

How I Built It

I built REQUIEM as a web application with a TypeScript-based frontend and a deployment workflow using GitHub and Vercel.

The project is structured around:

A cinematic landing page and interactive investigation workspace.
Evidence cards and a sample archaeological case.
Repository-oriented investigation concepts.
Model configuration and backend integration points for open-weight AI.
A dossier export workflow.
Privacy, safety, and source-licensing considerations.

The intended AI workflow uses an open-weight model such as Gemma to help interpret repository evidence and reconstruct possible project intent.

A key design principle is that AI-generated interpretations should not be presented as proven facts. Findings should be traceable to available evidence, with uncertainty made clear.

Note: The sample case is intended to make the prototype explorable without requiring visitors to configure an AI endpoint first. Sample or precomputed results should be distinguished from analyses performed live by a model.

Why Does Open Innovation Matter?

Open-source software makes it possible for people to study, modify, improve, and build upon work created by others.

But when maintainers move on, valuable ideas can become difficult to recover. Understanding an old repository may require significant time, technical knowledge, and patience.

Open-weight AI offers an interesting opportunity here.

Depending on the model and deployment setup, developers can have greater flexibility in choosing inference providers, inspecting model behaviour, adapting workflows, and running models in environments they control.

For a tool like REQUIEM, this matters because the underlying repository may contain sensitive or unpublished material. Developers should be able to understand where their code is processed and choose an appropriate inference setup.

Open-weight models are not automatically private or completely open-source, but they provide options that can be valuable when building transparent, adaptable developer tools.

My goal is to explore how open AI can help preserve and revive open-source knowledge rather than simply generate more code.

Safety, Trust, and Limitations

A project archaeology tool should not blindly trust either source files or AI output.

REQUIEM's design priorities include:

Treating repository content as untrusted input.
Never executing uploaded source code as part of an investigation.
Distinguishing direct evidence from inferred intent.
Respecting repository licences and attribution requirements.
Avoiding unsupported claims about vulnerabilities or project history.
Making model configuration and inference limitations visible.

This is a prototype, and not every proposed capability should be treated as production-ready or independently verified. The quality of its conclusions depends on the evidence available and the reliability of the configured model.

Try REQUIEM

Live Demo: https://requiem-the-ghost-archive.vercel.app/

GitHub Repository: https://github.com/veryVanshika801/REQUIEM-The-Ghost-Archive

I would love feedback on the usefulness of this idea, the investigation workflow, the evidence-first approach, and how open-weight AI could make digital archaeology more practical.

The Bigger Vision

Imagine discovering an abandoned repository that once attempted something ambitious.

Instead of giving up because the documentation is incomplete, you could investigate its history, understand its architecture, uncover unfinished ideas, and identify a realistic path forward.

That is the vision behind REQUIEM.

The code may have stopped evolving. Its ideas do not have to disappear with it.

Sometimes, bringing a project back to life begins by listening to what it left behind.

Thanks for reading!

SlothDesk AI -Work Smarter.move Slower.Get There.

Koushitha Seemakurthi — Fri, 23 Oct 2026 05:52:48 +0000

What I Built

SlothDesk AI is a sloth-inspired AI productivity assistant designed to make everyday tasks feel less overwhelming.

Sometimes, the hardest part of being productive is simply knowing where to start. I wanted to create an application that helps users organize their thoughts, break down tasks, and approach their workload at a more comfortable pace.

SlothDesk AI combines AI-assisted productivity workflows with a calm, friendly interface inspired by the idea of slowing down and taking one manageable step at a time.

Key Features

Lazy Task Organizer: Helps organize tasks into a more manageable plan.
Low-Energy Mode: Supports lighter planning for days when users want to reduce their workload.
Make It Smaller: Helps break larger tasks into smaller, actionable steps.
Note-to-Action: Helps turn unstructured notes into actionable items.
Slow Planner: Supports calmer, more manageable planning.
Sloth Garden: Brings a playful sense of progress to the experience.
Productivity Dashboard: Brings the main productivity workflow together.
Sloth-Inspired Design: Creates a cozy, approachable experience instead of a stressful productivity interface.

The core idea is simple: productivity doesn't always mean doing more. Sometimes, it means making the next step easier.

Live Demo

Try SlothDesk AI: https://slothdeskai.ai.studio

Explore the source code: https://github.com/veryVanshika801/SlothDeskAI

The application is available through its Google AI Studio live link, so you can explore the prototype directly without needing a separate Vercel deployment.

How I Built It

I used Google AI Studio to build and iterate on the SlothDesk AI prototype and GitHub to maintain the project's source code.

My focus was on combining an approachable visual identity with AI-assisted productivity workflows. The design uses a sloth-inspired theme to make task organization feel friendly and less intimidating.

The project brings together task-planning concepts, note organization, task breakdown, and a playful progress experience in one application.

The exact AI model, provider, and implementation details should be verified against the source code before making specific claims about the underlying model or its architecture.

Why Does Open Innovation Matter?

Open innovation gives developers the opportunity to experiment, learn, and build on ideas that can evolve through community feedback.

AI-powered productivity tools also raise important questions about transparency, model choice, accessibility, and responsible use. I want SlothDesk AI to continue evolving in a way that makes its functionality understandable and its AI integration transparent.

My goal is to build an approachable productivity experience while continuing to improve its reliability and usefulness.

The Lazy Payoff

The intended benefit of SlothDesk AI is to reduce the friction of getting started.

Instead of facing a long, overwhelming to-do list, users can work toward smaller actions. Instead of leaving their thoughts scattered across notes, they can work toward turning those thoughts into useful tasks.

You don't always need to work harder. Sometimes, you need to make the work smaller.

I haven't measured a specific amount of time saved yet. Testing the app with real users and gathering feedback will help me understand which features make the biggest difference.

What's Next?

I plan to keep improving SlothDesk AI with a focus on:

Helping users get unstuck when they feel overwhelmed.
Energy-based task planning.
Gentle focus sessions.
Weekly reflections and progress tracking.
More reliable AI generations and clearer error handling.
Functional, accessible controls across devices.
Better task persistence and a smoother user experience.

These improvements will help make SlothDesk AI more useful while preserving its calm, sloth-inspired personality.

Feedback Welcome

I'd love to hear which features you find most useful, what could be improved, and how SlothDesk AI could make everyday productivity feel easier.

🦥Live Demo: https://slothdeskai.ai.studio

💻GitHub Repository: https://github.com/veryVanshika801/SlothDeskAI

Slow down. Make the next step easier.

ScopeCraft: Cinematic Proposals for Freelancers, Powered by Open-Weight AI

Koushitha Seemakurthi — Sun, 18 Oct 2026 16:38:42 +0000

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

What I Built

ScopeCraft is a cinematic, editorial-style web studio that turns rough client briefs into structured, persuasive project proposals using open-weight language models. It also protects freelancers from the problems that usually come after the proposal is signed.

The problem: Freelancers lose money in two places. First, vague briefs hide risks: unclear hosting, missing assets, open-ended deadlines and fuzzy budgets. Second, once the project starts, "just one small change" requests quietly expand the scope for free.

Who would pay for it: Solo developers, designers, brand consultants and small agencies who send proposals regularly. One avoided scope-creep dispute or one better-won project more than covers the cost of a tool like this.

Core features:

Smart Brief Gap Detector: Scans an intake brief for commercial and operational risks, such as hosting ambiguity, unspecified copy and photography dependencies, missing turnaround times and unclear budgets. A one-click clause injection strengthens the brief before it goes to the client.
Scope-Creep Sentinel: Compares a new client request against the contracted proposal and classifies it as Within Scope, Boundary / Grey Area or Out of Scope. It estimates the schedule impact and change-order fee, cites the relevant proposal sections and exclusions, and drafts a polite, boundary-protecting email reply that can be copied in one click.
Living Project Scope Map: An interactive traceability matrix linking Client Need → Deliverable → Milestone → Acceptance Test → Measurable Outcome. It updates as proposal sections are edited and tracks verification status (Defined, In Review, Verified).
Professional PDF Export: Generates client-ready, multi-page PDFs with jsPDF across nine sections (Executive Summary through Next Steps), with an ivory, charcoal and forest-green design and dynamic page numbering.

The app includes three demo projects so the full workflow can be explored right away: a website redesign for an outfitter, a brand identity for a venture fund, and an e-commerce store for an artisan ceramics studio.

Demo

Live app: https://scopecraft-cinematic-ai-freelancer-proposal-studi.ai.studio

The app works out of the box in a clearly labeled demo mode that needs no API key. Adding a free open-weight inference key switches it to live model output.

Code

https://github.com/veryVanshika801/ScopeCraft-

How I Built It

Open-weight AI: ScopeCraft is designed around open-weight foundation models such as Meta Llama 3.3 70B, Mistral NeMo and Qwen 2.5. The inference provider is configurable through environment variables:

Groq Cloud (recommended, free tier) with llama-3.3-70b-versatile
Hugging Face Serverless with meta-llama/Llama-3.3-70B-Instruct
Together AI with meta-llama/Llama-3.3-70B-Instruct-Turbo
Custom with any OpenAI-compatible base URL

Changing providers or models takes a few lines in .env.local, with no code changes (OPEN_WEIGHT_PROVIDER, OPEN_WEIGHT_MODEL, OPEN_WEIGHT_BASE_URL).

Architecture: The frontend is built with Vite and TypeScript, with a lightweight server layer (server.ts and an api/ directory) that keeps the API key off the client. jsPDF handles the PDF export. The project is deployable to Vercel, and local setup is npm install && npm run dev.

Design: Most freelancer tools look like generic dashboards. I wanted proposals to feel like a finished documentary piece, so I used editorial typography, a warm ivory and charcoal palette and forest-green accents.

Why Does Open Innovation Matter?

Freelancer briefs contain private client details, budgets and strategy. Open-weight models changed what I could build:

No vendor lock-in: The same app runs on Groq, Hugging Face, Together or any OpenAI-compatible endpoint, so I can move wherever it's cheapest, fastest or most private.
Cost that suits a side hustle: A free-tier open-weight setup means a freelancer can use the tool without a heavy subscription or a pricing change breaking it.
Control over data: Because the models are open, the same app can be pointed at a self-hosted endpoint for clients who need that.
Transparency and room to improve: Open weights can be inspected, tuned and extended, and an open-source repo lets other freelancers fork it, adapt the prompts to their niche and contribute back.

A closed API would have tied the product's cost, behavior and privacy to someone else's decisions. Open innovation let me build a tool that freelancers can own and rely on.

TrailNote: A Project to Help People Spend More Time Outdoors#devchallenge#hf26challenge#openweights#touchgrass

Koushitha Seemakurthi — Sun, 11 Oct 2026 16:47:53 +0000

TrailNote: Bringing Birdwatching and Digital Field Journaling Together

TrailNote is a web application designed to make birdwatching more interactive by combining bird-sound analysis, a digital field journal, and a searchable bird species guide. The goal is simple: help people explore nature, record their observations, and spend more time outdoors.

What I Built

I built TrailNote, a birdwatching web application that brings several useful tools together in one place.

The application includes:

Bird Sound Analysis: Captures audio through the device microphone, visualizes sound, and uses frequency-based heuristics to suggest possible bird species.
Field Journal: Lets users record sightings, add notes, and save observation details.
Life List: Provides a searchable bird species catalog and helps users track their recorded sightings.
Sample Bird Calls: Includes synthesized bird-call presets for exploring and testing audio features.
Location Support: Uses browser geolocation when available to associate observations with coordinates.
Data Export: Allows users to export their records in CSV and JSON formats.
Pocket Standby: Includes a screen intended to encourage users to put their phones away and focus on their surroundings.

TrailNote stores journal data locally in the browser, helping users maintain their records without requiring every observation to be sent to a remote server.

The project is a prototype, and its sound identification feature is based on frequency analysis and heuristic scoring. Its suggestions should be treated as experimental rather than scientifically verified bird identifications.

Demo

Try the live prototype:

https://trail-note.vercel.app/

Explore the interface and available features to see how TrailNote brings birdwatching tools and field journaling together.

Code

The source code is available on GitHub:

https://github.com/hampp108/TrailNote

The repository contains the application code, interface components, audio-processing logic, and project configuration.

*How I Built It
*
TrailNote is built using modern web technologies.

Technologies used:

React: Builds the user interface and reusable components.
TypeScript: Adds type checking and helps organize application logic.
Vite: Supports local development and production builds.
Web Audio API:Processes audio input and creates sound visualizations.
IndexedDB: Stores field-journal records locally in the browser.
Geolocation API:Requests location coordinates when the user grants permission.
Progressive Web App tooling: Provides configuration for installation and offline-related functionality.

The application combines these components into a single experience. Users can explore bird species, analyse audio, maintain observation records, and export their data.

The current sound-analysis implementation uses frequency-based rules and scoring rather than a verified trained AI model. Developing a reliable bird-identification model would be a possible future improvement.

Why Does Open Innovation Matter?

Open innovation matters because useful technology should be understandable, adaptable, and accessible to more people.

TrailNote explores how browser-based audio processing and local data storage can support a practical nature-focused application without requiring every interaction to depend on a remote service.

Local storage gives users more direct control over their observation records. Browser-based audio processing also provides a foundation for experimenting with sound analysis while keeping the application architecture relatively lightweight.

The project is still evolving. Future improvements could include integrating a properly trained, open-weight bird-audio model, evaluating identification accuracy against real recordings, improving offline reliability, and documenting the implementation so other developers can learn from it.

Building TrailNote has helped me explore how web technologies can support real-world activities instead of keeping users focused on their screens.

What I Learned

Working on TrailNote gave me practical experience with React, TypeScript, browser audio APIs, local persistence, geolocation, and deploying a web application.

It also highlighted an important lesson: displaying a prediction is not the same as proving that a model is accurate. Reliable bird identification requires appropriate training data, testing, and evaluation.

My next step is to improve the application's reliability and make its features more useful for people who enjoy birdwatching and exploring the outdoors.

What's Next?

Some areas I would like to improve are:

Integrating and evaluating a suitable open-source bird-audio model.
Improving sound-identification accuracy using real-world recordings.
Testing offline behaviour on different devices.
Improving the field journal and observation workflow.
Making the application easier to use outdoors, with fewer unnecessary screen interactions.

TrailNote is a starting point for exploring how technology can support a closer connection with nature.

Live Demo: https://trail-note.vercel.app/

**GitHub: **https://github.com/hampp108/TrailNote