DEV Community: Ashutosh singh

I Built SlothSort: A Local AI Agent That Organizes Your Digital Mess So You Don't Have To

Ashutosh singh — Sat, 24 Oct 2026 19:20:50 +0000

I Built SlothSort: A Local AI Agent That Organizes Your Digital Mess So You Don't Have To

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

What I Built

My Downloads folder has been a mess for years. I finally decided to make that someone else's problem. Except that someone is an AI agent running on my own computer.

You know the routine.

You download a PDF for college. A screenshot for a project. A random ZIP file. A few invoices. Some lecture notes.

Everything ends up in Downloads.

A week later, you're looking for document_final_v2_REAL_final.pdf, and suddenly you're spending 20 minutes searching through files you don't even remember downloading.

Organizing everything manually isn't particularly difficult. It's just repetitive, boring, and easy to postpone.

And that's exactly the kind of work I wanted to automate.

Introducing SlothSort 🦥

SlothSort is a local-first AI file organization agent designed to quietly clean up digital clutter while you focus on more important things.

Instead of asking you to manually rename, categorize, and move every file, SlothSort uses an open-weight language model to understand what a file contains and suggest where it belongs.

The idea is simple:

Drop files into a folder. Let AI figure out the boring part.

The workflow is designed around five capabilities:

Understand files: Read filenames, supported document contents, and metadata to determine what a file is actually about.
Automatically categorize: Group files into meaningful categories such as college notes, invoices, projects, screenshots, and personal documents.
Suggest better filenames: Turn names like scan_00482.pdf into something descriptive, such as Database_Management_Notes.pdf.
Detect possible duplicates: Identify repeated downloads and avoid unnecessary clutter.
Organize safely: Preview proposed changes before moving or renaming anything, with an undo mechanism for completed operations.

The goal isn't to create another chatbot that tells you how to organize your files.

It's to create a tool that actually handles the organization.

A Real-World Example

Imagine downloading these files:

Downloads/
├── IMG_20261020_142312.png
├── document(7).pdf
├── assignment_final_final.pdf
├── invoice_oct.pdf
├── react-project.zip
└── DBMS_unit3_notes.pdf

After analysis, SlothSort could propose:

Organized/
├── College/
│   ├── Assignments/
│   │   └── Assignment.pdf
│   └── Notes/
│       └── DBMS_Unit_3.pdf
├── Finance/
│   └── Invoices/
│       └── October_Invoice.pdf
├── Development/
│   └── React/
│       └── react-project.zip
└── Images/
    └── IMG_20261020_142312.png

No manually creating folders. No individually renaming documents. No dragging files around.

Just a reviewable organization plan.

And if the model isn't confident about a file, it should leave that file alone rather than guessing.

That's an important design decision: automation should reduce work, not create new problems.

Demo

🚧 Deployment and public demo are being prepared.

SlothSort is being developed as a local-first application, so the intended experience doesn't require uploading personal documents to a hosted AI service.

Demo: Coming soon

I'll update this section with a walkthrough showing the complete flow:

Selecting a messy folder
Running local AI analysis
Previewing suggested categories and filenames
Approving the organization plan
Reviewing the resulting folder structure

Code

GitHub repository: Coming soon

The repository will include the application source code, setup instructions, model configuration, and an example dataset for testing the organization workflow.

How I Built It

The most important architectural decision was to keep the AI inference local.

For a file organizer, sending personal documents to a remote server just to decide which folder they belong in feels unnecessary.

So I designed SlothSort around an open-weight model and a lightweight local processing pipeline.

The Planned Tech Stack

Component	Technology
AI model	Gemma 3 (open-weight)
Local inference	Ollama
Backend	Python
API layer	FastAPI
Frontend	React + Tailwind CSS
File processing	Python standard library and document parsers
Local storage	SQLite
Background processing	Local filesystem watcher

How the Pipeline Works

         User selects a folder
                  |
                  v
           File discovery
                  |
                  v
       Metadata + text extraction
                  |
                  v
       Local Gemma inference
                  |
                  v
        Structured JSON output
                  |
                  v
      Validate proposed changes
                  |
                  v
         Preview organization
                  |
             User approval
                  |
                  v
       Execute file operations
                  |
                  v
          Save undo history

1. Understanding File Contents

The first challenge is that filenames are often useless.

A file named notes.pdf could be a college assignment, meeting notes, or an instruction manual.

So the processing layer extracts useful information from supported files before passing a compact representation to the model.

The model receives a prompt containing the filename, file type, extracted text, and available categories.

It then returns a structured classification.

For example:

{
  "original_name": "document_7.pdf",
  "category": "College",
  "subcategory": "Notes",
  "suggested_name": "DBMS_Normalization_Notes.pdf",
  "confidence": 0.94,
  "reason": "Document discusses database normalization and relational schemas."
}

This example illustrates the intended output format, not a measured model result.

2. Keeping AI Away From Destructive Operations

One thing I didn't want was an AI model having unrestricted access to my filesystem.

A model should be able to recommend actions, but it shouldn't be trusted to execute arbitrary file operations.

So SlothSort separates reasoning from execution.

The model generates a proposed plan.

The application validates that plan.

Only the deterministic file-management layer can perform the approved operations.

That means checking destination paths, handling filename collisions, preventing traversal outside allowed folders, and recording changes.

The AI decides what makes sense. Regular code decides what is safe.

3. Designing for Slow and Steady Automation

This is where the Hacktoberfest theme becomes especially relevant.

SlothSort isn't meant to be an AI assistant that constantly demands attention.

The long-term workflow is designed to be:

Incremental: Process new or changed files instead of rescanning everything.
Quiet: Avoid unnecessary notifications and interruptions.
Resource-aware: Use background processing rather than competing with active tasks.
Recoverable: Maintain an operation history so file movements can be reversed.
Conservative: Leave ambiguous files untouched until the user reviews them.

The ideal experience is one where the user gradually stops thinking about file organization.

Not because the files have disappeared.

But because the repetitive maintenance is handled.

Why Does Open Innovation Matter?

This project would be fundamentally different if it depended entirely on a closed AI API.

1. Your files should remain yours

A file organizer potentially handles sensitive documents.

College records. Invoices. Contracts. Personal notes.

With a local open-weight model, document text can be processed on the user's machine instead of being sent to an external model provider.

That doesn't automatically guarantee security, but it removes an unnecessary external data transfer from the core workflow.

2. No per-file API billing

A folder might contain 20 files or 20,000.

With a paid API, repeated classification can introduce ongoing usage costs.

A locally hosted model avoids per-request inference fees, although it still consumes the user's computing resources and electricity.

For a background utility, predictable operating costs matter.

3. The model isn't permanently fixed

Using an open-weight model makes it possible to experiment with different model sizes, quantization levels, prompts, and eventually task-specific fine-tuning.

A smaller model might be sufficient for simple document categorization.

A more capable model could handle ambiguous files.

That flexibility is valuable because a utility like SlothSort needs to balance accuracy, memory usage, and processing speed.

4. Offline operation becomes possible

Once the required software and model weights are installed, the core file-classification workflow can run without an internet connection.

That's particularly useful for a desktop utility that should continue working regardless of network availability.

5. The community can improve the rules

Open innovation isn't just about model weights.

It's also about making the automation inspectable and customizable.

Different users organize files differently.

A developer might want folders grouped by programming language. A student might prefer semester and subject. A freelancer might want client and project.

A transparent rules engine combined with a configurable model gives people control over how their own files are organized.

The Lazy Payoff

I wanted to define what success would actually look like.

Not in terms of how impressive the AI sounds, but in terms of how much repetitive work it eliminates.

Consider a hypothetical batch of 100 files.

If manually inspecting, renaming, and moving each file takes an average of 30 seconds, that's:

100 files × 30 seconds = 50 minutes of manual work.

If an automated workflow could reduce the task to five minutes of reviewing suggestions, that would represent 45 minutes saved.

That's a potential 90% reduction in hands-on time.

These numbers are illustrative, not benchmark results. Actual performance will depend on model speed, file types, classification accuracy, and how many suggestions need correction.

For me, the more interesting payoff isn't even the number of minutes saved.

It's eliminating one more repetitive task from everyday life.

Because organizing files isn't something I want to become better at.

It's something I want to spend less time doing.

What's Next?

There are several directions I want to explore as SlothSort develops.

Semantic search: Instead of remembering filenames, users could search for things like "the database notes I downloaded last week."

Custom organization rules: Let users describe how they want their folders structured in natural language.

Smarter duplicate detection: Identify identical files using hashes and eventually detect documents with highly similar contents.

Learning from corrections: Use user-approved changes to improve future suggestions without silently retraining or changing behavior.

Background automation: Watch selected folders and prepare organization suggestions as new files arrive.

The goal is to make SlothSort useful without making it complicated.

Final Thoughts

We spend a surprising amount of time doing tiny repetitive tasks on our computers.

Renaming files. Creating folders. Sorting documents. Searching for downloads.

None of these tasks is particularly difficult.

But they add up.

The interesting thing about open-source AI is that it gives us the freedom to build small, personal tools that solve these problems without necessarily depending on an expensive hosted service.

Not every AI project needs to be a massive autonomous agent.

Sometimes, a useful AI application is simply one that quietly takes a boring task off your plate.

SlothSort is my attempt at making digital organization one less thing to worry about.

And that feels pretty aligned with the spirit of Slow and Steady. 🦥

Built for Hacktoberfest 2026 — Open-Source AI Challenge, Week 3: Slow and Steady.

devchallenge #hf26challenge #opensource #ai

I Built LAYR Studio — An Open-Source AI Design Platform for Creating Professional, Fully Editable Marketing Posters

Ashutosh singh — Fri, 16 Oct 2026 15:56:15 +0000

I Built an AI Design Studio That Helps Small Businesses Create Professional Marketing Posters

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

What I Built

The problem: Great design is expensive. Bad design is expensive too.

Imagine running a small restaurant, clothing store, café, or local business.

You need promotional posters for weekend sales, new products, festivals, and special offers. Hiring a designer for every campaign isn't always affordable, and learning professional design software takes time.

AI image generators can create attractive graphics, but there's a problem: the result is often a flattened image that is difficult to edit.

What happens when the price changes? When you need to replace a product photo? When the same design needs to work as an Instagram post and a printed flyer?

You shouldn't have to generate everything again.

That's the problem I set out to solve.

Introducing layR

An AI-powered design platform that helps small businesses generate professional promotional posters while keeping the individual design elements editable.

The idea is simple:

Describe your promotion → Generate a design → Customize the elements → Export and publish.

The product is designed around three principles:

Accessibility: Small businesses should be able to create high-quality marketing materials without advanced design skills.
Creative control: AI should accelerate the design process, not take away the ability to make changes.
Affordability: Open-source AI can help make design generation economically practical for small businesses.

Who Would Pay for It?

My target customers are small businesses that regularly need promotional content but don't have dedicated design teams.

Potential customers include local restaurants, cafés, retailers, event organizers, and independent entrepreneurs.

The proposed business model is a freemium design service with paid generation credits or monthly subscriptions.

The goal isn't to replace professional designers. It's to make better design accessible to people who otherwise might not be able to afford it.

Demo

Development Status: In Progress

The project is currently under active development, with work focused on building and refining the core AI-powered design generation pipeline.

Our goal is to deliver a functional platform that allows small businesses to generate professional marketing posters while retaining control over editable design elements.

The planned demonstration will cover the complete design workflow:

Enter a promotional brief.
Generate a poster using open-source AI.
Modify text, layout, or individual graphic elements.
Export the finished design.

A public demonstration will be available once the application is ready for testing.

Code

The project is currently in development.

The codebase is being organized around a modular architecture that separates AI generation, design composition, editing, and export functionality.

The planned repository documentation will include application setup instructions, architecture details, and information about the open-source AI components.

How I Built It

The technical goal is to build a design-generation pipeline rather than simply wrap an image-generation API.

A typical image generator produces one final picture. This project explores separating the design process into multiple stages.

1. Understanding the design brief

The first stage interprets the user's request and identifies the important content: headline, promotional details, visual style, audience, and intended format.

2. Generating visual assets

The planned pipeline uses an open-weight image-generation model to produce visual components that can be incorporated into the poster.

Model: [Insert actual model name and version]

Inference environment: [Specify actual inference environment]

3. Composing the design

A layout pipeline combines generated visual elements with editable typography, positioning, and structured design information.

This separation is important because text and layout should not be permanently baked into a single AI-generated image.

4. Refinement and export

The intended workflow allows users to refine the output and export it into supported formats or continue editing through an external design workflow.

Technology Stack:

Frontend: [Insert framework]
Backend: [Insert runtime and framework]
AI inference: [Insert model and inference engine]
Storage: [Insert database or object storage]
Export pipeline: [Insert export technology]

The architecture is designed to support modular AI generation, reusable design components, and future improvements to the creative workflow.

Why Does Open Innovation Matter?

For this project, open-source AI is more than a technology preference. It's connected directly to whether the product can become a sustainable small business.

1. More control over the creative pipeline

Open-weight models allow developers to experiment with model selection, inference settings, and custom workflows.

Instead of treating generation as a black box, the system can be designed around the specific requirements of editable marketing graphics.

2. Better control over costs

A small-business design tool needs predictable economics.

Self-hosted open-weight models can offer opportunities to optimize inference costs as usage grows, although infrastructure and maintenance costs still matter.

This flexibility is important when exploring affordable pricing for customers.

3. Less dependence on a single provider

A modular AI pipeline can make it easier to evaluate different models and replace components as better open models become available.

The product doesn't have to depend permanently on one vendor's model availability, pricing, or capabilities.

4. Opportunities for specialized workflows

General-purpose AI models aren't always optimized for promotional posters.

An open approach makes it possible to experiment with domain-specific improvements, design constraints, structured outputs, and evaluation methods.

The larger idea is that open innovation makes it easier for independent developers to build specialized products instead of relying entirely on closed platforms.

My Agent Session

AI-assisted development is part of the planned workflow for accelerating implementation, evaluating architectural choices, and refining the generation pipeline.

Development sessions and technical decisions will be documented as the implementation progresses.

Prize Categories

The following categories are being considered, depending on the technologies used in the completed implementation:

Best Use of Gemma — for integrating Google's open-weight model into the application.
Best Use of Render — for deploying the application or AI runtime using Render.
Best Use of GitHub Copilot — for eligible AI-assisted development workflows.
Best Use of Sentry Agent Tracing — for implementing and demonstrating agent tracing.

Only categories supported by the actual implementation will be included in the final submission.

Final Thoughts

This project started with a simple question:

What if small businesses could create professional marketing designs without sacrificing affordability or creative control?

AI can generate impressive images. But turning those images into useful, editable, repeatable business assets is a different challenge.

That's the opportunity I'm exploring.

The long-term vision is a design platform where AI handles repetitive creative work while people retain control over the final result.

Because the best AI tools shouldn't just generate something beautiful.

They should generate something people can actually use.

devchallenge #hf26challenge #opensource #ai

WhatIF — An AI Counterfactual Machine

Ashutosh singh — Sun, 04 Oct 2026 17:46:32 +0000

WhatIF — An AI Counterfactual Machine

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

What I Built

WhatIF is an AI-powered counterfactual machine built around one simple question:

What if things had happened differently?

Instead of being another AI chatbot, WhatIF lets you create alternate scenarios and explore how a single change could affect everything that comes after it.

For example:

What if I had chosen a different college?
What if I had started learning programming three years earlier?
What if I had accepted that opportunity?
What if I had moved to another city?
What if a historical event never happened?
What if I made the opposite decision?

WhatIF takes a starting scenario and generates a counterfactual chain, exploring possible consequences, assumptions, branching outcomes, and alternate timelines.

I built it for a friend who constantly asks “what if?” about decisions, technology, games, and life.

I didn't want to build another productivity app or another ChatGPT wrapper.

I wanted to build something that feels more like a sandbox for imagination and reasoning.

Demo

🌐 Live Demo: https://what-if-cyan-phi.vercel.app/

Code

💻 GitHub Repository: https://github.com/ashudotbuilds/whatIF

The project is open source so others can experiment with the idea, inspect the implementation, and build their own variations.

How I Built It

WhatIF is built around open-weight AI and uses Gemma as its AI engine.

The core idea is to give the model a structured counterfactual scenario instead of treating it like a normal conversational chatbot.

The application takes the user's:

What-if scenario
Starting conditions
Important variables
Constraints
Desired depth of exploration

and turns them into a structured alternate-world analysis.

The AI then explores a chain like:

Scenario → Assumptions → Immediate Effects → Secondary Effects → Long-Term Consequences → Alternative Outcomes

The frontend was intentionally kept simple so that users can immediately understand what to do.

The experience is essentially:

Ask a WhatIF → Explore the alternate reality → Follow the consequences

I deliberately avoided building a complicated AI dashboard. The goal was to make the experience feel more like an interactive thought experiment.

Why Does Open Innovation Matter?

Open innovation matters because it gives developers the ability to experiment with the intelligence layer of their applications instead of simply building another interface around a closed API.

Using an open-weight model like Gemma makes it possible to:

Experiment with different model configurations
Understand how the model behaves
Modify prompts and AI workflows
Build specialized AI experiences
Potentially run models locally
Reduce dependence on a single provider
Share the architecture and experiments with other developers

For WhatIF, this is especially important because counterfactual reasoning is the core of the product.

The AI isn't simply generating a normal response.

It is being used as an engine for exploring alternate possibilities.

Open models make this kind of experimentation more accessible to developers who want to understand, modify, and extend what they build.

My Agent Session

I built WhatIF using an AI coding agent and an iterative agentic development workflow.

The agent helped with:

Project structure
UI implementation
Counterfactual engine logic
Prompt design
API integration
Error handling
UX improvements
Dark/light mode
Documentation

One of the biggest iterations was simplifying the UI.

The first version felt too complicated, so I redesigned it around one simple idea:

Less dashboard. More imagination.

Prize Categories

I'm entering WhatIF for the following categories:

Gemma / Google
Open Source / Open Innovation

Built for a Friend

The most important part of this project isn't the technology.

It's the question that inspired it:

What if?

Everyone has decisions they replay in their head.

Everyone has moments where they wonder what could have happened if they had chosen differently.

WhatIF turns that curiosity into something you can actually explore.

Instead of asking AI:

"Tell me something."

You ask:

"What if?"

And then you see where that alternate reality takes you.

Built during Hacktoberfest Weekend 2026 with open-source AI, an AI coding agent, and a lot of counterfactual thinking.