Dev Janitor: The Secret Weapon Developers Are Using to Reclaim Their Machines

Your laptop is dying, and you don't even know it.

That node_modules folder from a project you abandoned six months ago? 23,000 files, 4.2 GB gone forever. Those AI coding assistants you experimented with last quarter? They left chat histories, debug logs, and cache directories scattered across every corner of your filesystem like digital tumbleweeds. Your PATH variable has grown so bloated that shell startup takes three agonizing seconds. And somewhere, somehow, an old API key is sitting in a config file that you committed once and forgot about.

Sound familiar? You're not alone. The modern developer's machine has become a graveyard of abandoned experiments, orphaned dependencies, and invisible security risks. We've all been there—promising ourselves we'll "clean it up this weekend" while our SSDs gasp for free space and our environments drift further into chaos.

But what if cleanup wasn't a weekend project? What if it was as effortless as checking your email?

Enter Dev Janitor—the cross-platform desktop application that's making seasoned developers whisper to each other in Slack DMs. Built by cocojojo5213 and available right now on GitHub, this isn't another terminal script you'll forget exists. It's a visual, intelligent control center for everything that's wrong with your development environment. And it's about to become the most-used tool in your productivity arsenal.

What Is Dev Janitor?

Dev Janitor is a cross-platform desktop application engineered specifically for the messy reality of modern software development. Unlike generic system cleaners that blindly nuke "temporary files" and pray they don't break anything, Dev Janitor speaks fluent developer. It understands the ecosystems you actually work in—Node.js, Python, Rust, Go—and targets the specific artifacts that accumulate through real coding workflows.

The project emerged from a pain point every developer recognizes but few solve systematically: environment entropy. As we switch between projects, experiment with new tools, and integrate AI assistants into our workflows, our machines accumulate invisible technical debt. Dev Janitor transforms this chaotic cleanup process from a dreaded chore into a streamlined, visual experience.

Built on a Tauri 2 + React 19 + Rust stack, the application delivers native performance with a modern web-based interface. Tauri's lightweight architecture means you're not downloading another Electron behemoth that consumes 800MB of RAM just to show a file list. Rust handles the heavy lifting of filesystem operations and system inspection, while React 19 provides a responsive, interactive UI that makes complex cleanup decisions feel intuitive.

What makes Dev Janitor genuinely trending now is its prescient focus on AI tool management. The 2024-2025 explosion of AI coding assistants—Codex, Claude Code, Cursor, Gemini CLI, Aider, Continue, Kiro, iFlow, OpenCode—has created an entirely new category of digital debris. These tools generate chat histories, cache responses, store debug information, and create configuration files at unprecedented scale. Most developers have no visibility into this accumulation until their machines slow to a crawl. Dev Janitor is the first mainstream tool to systematically address this emerging problem.

The MIT license and active CI/CD pipeline (visible through the project's badge system) signal a mature, maintainable project rather than a weekend hack. With releases available for Windows (.msi, portable), macOS (.dmg), and Linux (AppImage, .deb, .rpm), it meets developers wherever they work.

Key Features That Separate Dev Janitor From Generic Cleaners

Dev Janitor's feature architecture reveals deep understanding of actual development workflows. This isn't surface-level functionality—it's domain-specific intelligence built through recognition of how modern developers actually work.

Intelligent Artifact Detection

The cleanup engine scans project directories with contextual awareness that generic tools lack. It recognizes node_modules directories and understands they're safe to delete because they can be reconstructed via npm install. It identifies Rust target directories, Python __pycache__ folders, Go build artifacts, and log files with appropriate confidence levels. The system distinguishes between reconstructible artifacts (safe to remove) and irreplaceable configuration (preserve at all costs).

AI-Native Cleanup Intelligence

Here's where Dev Janitor gets genuinely innovative. The tool detects ephemeral leftovers from AI coding tools with surgical precision. It recognizes when .codex/config.toml or .claude/settings.json represent active project configuration versus abandoned cache data. It surfaces AI chat histories, response caches, and debug files on a per-project basis, letting you review before purging. This granular control prevents the catastrophic scenario where you accidentally delete conversation context you actually needed.

Unified Developer Tool Management

Instead of checking node --version, python --version, rustc --version, go version across separate terminal sessions, Dev Janitor presents a unified dashboard of your entire toolchain. It inspects installed tools across Node, Python, Rust, Go, and related ecosystems, displays current versions, and identifies update opportunities for global packages. The AI CLI tool integration is particularly valuable—managing Codex, Claude Code, Cursor, Gemini CLI, Aider, Continue, Kiro, iFlow, and OpenCode from a single interface eliminates context-switching friction.

Security-First Environment Scanning

The security module addresses risks that most developers systematically ignore. It flags risky local tool configurations—database ports listening on 0.0.0.0 instead of localhost, services with default credentials, known vulnerable setup patterns. The API key detection scans common configuration files for exposed secrets, potentially preventing costly credential leaks. Most impressively, the MCP server configuration inspector identifies patterns that could lead to credential exposure or Server-Side Request Forgery (SSRF) vulnerabilities—a genuinely sophisticated security feature that demonstrates deep understanding of modern AI-assisted development risks.

System Utility Integration

The process inspection tools solve everyday debugging frustrations. Finding which process occupies port 3000 becomes a single click rather than a lsof | grep adventure. Long-running development processes get visualized for easy identification of runaway tasks. PATH and shell configuration analysis—including persisted Windows system/user PATH entries—surfaces the configuration drift that causes "works on my machine" mysteries.

Real-World Scenarios Where Dev Janitor Transforms Your Workflow

Scenario 1: The AI Experiment Cleanup Crisis

You've spent two weeks evaluating Claude Code, Cursor, and Gemini CLI for your team. Each tool created configuration directories, chat logs, and cache files across multiple projects. Your ~/.config directory has ballooned by 12GB. Dev Janitor's per-project AI cleanup lets you preserve valuable conversation context from your chosen tool while purging experimental debris from the others. No more hunting through hidden directories wondering what's safe to delete.

Scenario 2: The Onboarding Environment Audit

New team member, fresh machine, three days of "why doesn't this build work on my laptop?" Dev Janitor's security scan and PATH inspection reveal that their Node version manager conflicts with system Node, their Python PATH prioritizes an old Anaconda installation, and a .env file from a previous project leaked an AWS key into their shell history. What would have taken hours of pairwise debugging becomes a five-minute automated diagnosis.

Scenario 3: The CI/CD Local Replication Nightmare

Your builds pass in CI but fail locally. After hours of frustration, Dev Janitor's tool management view reveals you're running Rust 1.72 while CI uses 1.78, your global eslint installation overrides the project's pinned version, and a forgotten .cargo/config.toml from an old project injects registry mirrors that don't exist anymore. The environment drift detection surfaces what cargo build --verbose never would.

Scenario 4: The Pre-Demo Disk Space Emergency

Presentation in 30 minutes, and your laptop warns of critically low disk space. Dev Janitor's cache cleanup identifies 8GB of old npm package caches, 3GB of abandoned target directories from Rust experiments, and 2GB of Docker build artifacts you forgot existed. One review, one confirmation, 13GB reclaimed without touching a single active project file.

Step-by-Step Installation & Setup Guide

Getting Dev Janitor running takes under two minutes regardless of your platform. The project maintains comprehensive release artifacts through its GitHub Actions pipeline.

Windows Installation

Visit the Releases page and download either:

• .msi installer for standard installation with Start Menu integration
• *_portable.zip for USB drive or Dropbox-synced usage across machines

Run the installer with standard user privileges—no elevation required for basic operation, though some security scans benefit from administrator access for complete system inspection.

macOS Installation

Download the .dmg from Releases. Due to Apple's Gatekeeper, first launch requires Right Click > Open rather than double-clicking. The application is notarized through standard Tauri signing processes. For permanent Gatekeeper bypass if you frequently update:

# Optional: Remove quarantine attribute after verifying release integrity
xattr -d com.apple.quarantine /Applications/Dev\ Janitor.app

Linux Installation

Three distribution-native formats available on Releases:

AppImage (universal, no root required):

chmod +x dev-janitor_*.AppImage
./dev-janitor_*.AppImage

Debian/Ubuntu (.deb):

sudo dpkg -i dev-janitor_*.deb
sudo apt-get install -f  # Resolve any dependency issues

Fedora/RHEL (.rpm):

sudo rpm -i dev-janitor_*.rpm

Development Setup (For Contributors)

Want to extend Dev Janitor or verify the build yourself? The development environment requires modern toolchain versions:

# Clone the repository
git clone https://github.com/cocojojo5213/Dev-Janitor.git
cd Dev-Janitor

# Enable pnpm through corepack
corepack enable pnpm

# Install dependencies
pnpm install

# Launch development build with hot reload
pnpm tauri dev

Prerequisites:

• Node.js 24 LTS or newer
• pnpm 10.30.3 or newer (managed via corepack)
• Rust 1.94.0 or newer

Validation before contribution:

# Lint TypeScript/React code
pnpm lint

# Build production bundle
pnpm build

# Run Rust unit tests
cargo test

The Tauri 2 architecture means the frontend (React 19) and backend (Rust) communicate through typed commands, with Rust handling all filesystem and system-level operations for security and performance.

Real Code Examples From the Repository

Dev Janitor's implementation reveals sophisticated patterns worth studying. Here are actual code structures and commands from the repository, annotated for understanding:

Development Environment Bootstrap

The project's setup follows modern JavaScript/Rust hybrid patterns. The core development command chain from the README:

# Standard GitHub clone pattern
git clone https://github.com/cocojojo5213/Dev-Janitor.git
cd Dev-Janitor

# corepack enables package manager versioning without global installs
# This ensures every contributor uses identical pnpm 10.30.3+
corepack enable pnpm

# Installs both Node dependencies and triggers Rust cargo fetch
pnpm install

# Launches Vite dev server + Tauri application window
# Hot reload works for both React frontend and Rust backend changes
pnpm tauri dev

This architecture separates concerns elegantly: React 19 manages UI state and rendering, while Rust handles all privileged operations. The pnpm tauri dev command actually spins up two processes—a Vite development server for the frontend, and the Tauri runtime that embeds a WebView and exposes Rust commands to JavaScript.

Quality Assurance Pipeline

The validation commands demonstrate mature engineering practices:

# ESLint + Prettier for TypeScript/React code quality
pnpm lint

# Production build verification—catches bundling errors dev mode misses
pnpm build

# Rust's built-in test runner for backend logic
# Tests filesystem operations, command parsing, security detection patterns
cargo test

The separation of pnpm build from cargo test reflects the dual nature of Tauri applications. The build command compiles the React frontend through Vite and bundles Rust binaries, while cargo test validates pure Rust logic independently. This matters because security detection patterns—like the MCP configuration inspector—live in Rust where they can access the filesystem safely, and their test coverage ensures detection accuracy.

Cross-Platform Release Distribution

While not explicit shell commands, the release artifact structure reveals thoughtful distribution strategy:

# Windows targets
*.msi              # Standard installer with registry integration
*_portable.zip     # Extract-and-run, no installation footprint

# macOS targets  
*.dmg              # Disk image with Applications folder symlink

# Linux targets
*.AppImage         # Single executable, works on any Linux distribution
*.deb              # Debian/Ubuntu native package management
*.rpm              # Fedora/RHEL/CentOS native package management

This six-format release strategy maximizes accessibility. The portable Windows build particularly serves developers with restricted installation privileges or those maintaining consistent tooling across multiple machines via cloud storage. The AppImage format solves Linux distribution fragmentation without requiring Flatpak or Snap complexity.

CI/CD Badge Integration

The README's badge system reflects automated quality assurance:

[![Build Status](https://github.com/cocojojo5213/dev-janitor/workflows/CI/badge.svg)](https://github.com/cocojojo5213/dev-janitor/actions)
[![Release](https://img.shields.io/github/v/release/cocojojo5213/dev-janitor)](https://github.com/cocojojo5213/dev-janitor/releases)
[![Downloads](https://img.shields.io/github/downloads/cocojojo5213/dev-janitor/total)](https://github.com/cocojojo5213/dev-janitor/releases)
[![License: MIT](https://img.shields.io/badge/License-MIT-2ea44f.svg)](LICENSE)

These badges aren't decorative—they're real-time quality signals. The CI badge links to GitHub Actions workflows that validate every commit. The release badge surfaces the latest version automatically. The downloads counter provides social proof of adoption. For developers evaluating tool maturity, this transparency builds trust faster than any marketing copy.

Advanced Usage & Best Practices

Schedule Regular Cleanups: Don't wait for disk space emergencies. Weekly Dev Janitor runs prevent accumulation and surface environment drift before it causes build failures.

Review Before Bulk Deletion: The per-project AI cleanup preview is your safety net. That 500MB .codex directory might contain conversation context that documents architectural decisions. The tool surfaces; you decide.

Security Scan Before Commits: Run the security module before pushing to shared repositories. Catching an exposed API key in ~/.npmrc before it reaches CI is infinitely preferable to post-incident rotation.

PATH Audit After Tool Installations: Every new version manager (nvm, pyenv, rustup) modifies shell configuration. Dev Janitor's PATH visualization reveals conflicts that cause mysterious "command not found" errors months later.

Portable Mode for Consistent Teams: The Windows portable build synchronized through shared cloud storage ensures every team member runs identical Dev Janitor versions, eliminating "works on my machine" for the tool itself.

Dev Janitor vs. Alternatives: Why This Tool Wins

The comparison reveals Dev Janitor's unique positioning: developer-native intelligence that generic system cleaners cannot replicate, combined with visual usability that manual scripting lacks. The Tauri architecture's efficiency advantage over Electron-based alternatives is substantial for a tool meant to run alongside resource-intensive development environments.

Frequently Asked Questions

Is Dev Janitor safe to use on production machines?

Yes. The cleanup operations preview all deletions before execution. The tool specifically preserves active configuration files (like .codex/config.toml) and only targets reconstructible artifacts or explicit cache data. However, as with any cleanup tool, review the preview before confirming bulk operations.

Does Dev Janitor require administrator/root privileges?

Standard operation works with user privileges. Security scans benefit from elevated access for complete system inspection, particularly for port binding analysis and system-wide PATH entries. The application gracefully degrades when elevation is unavailable.

How does AI tool detection avoid false positives?

The detection engine distinguishes between active configuration (preserved) and ephemeral data (flagged for cleanup) through pattern recognition of file paths, names, and content signatures. Per-project review interfaces let you override any detection before action.

Can I contribute new tool ecosystem support?

Absolutely. The Tauri 2 + React 19 + Rust architecture is designed for extension. Follow the CONTRIBUTING.md guidelines, ensure pnpm lint and cargo test pass, and submit focused pull requests.

What makes this different from writing my own shell scripts?

Three factors: visual confidence (see before you delete), discoverability (find problems you didn't know existed), and maintenance (someone else updates detection patterns as tools evolve). Your scripts won't learn about new AI tools automatically.

Is there telemetry or data collection?

The MIT-licensed source code is fully auditable. Review the Rust backend and React frontend for complete transparency. No network calls transmit your filesystem data or scan results externally.

How often are AI tool definitions updated?

The active CI/CD pipeline and responsive maintainer (cocojojo5213) suggest regular updates. The open source model means community contributions for new tools (the next AI CLI sensation) can be merged quickly.

Conclusion: Reclaim Your Machine, Reclaim Your Focus

Development environment entropy isn't a character flaw—it's an inevitable consequence of working with powerful, evolving tools. The difference between developers who struggle and developers who flow isn't willpower; it's systematic maintenance infrastructure.

Dev Janitor transforms cleanup from procrastinated chore to two-minute ritual. Its AI-native intelligence addresses problems that didn't exist two years ago. Its security scanning prevents mistakes that could cost your job. Its visual interface eliminates the cognitive load of remembering what's safe to delete.

I've evaluated dozens of developer productivity tools. Most solve problems that don't exist, or create new problems worse than the original. Dev Janitor is genuinely different because it emerges from authentic pain—visible in every design decision, from per-project AI cleanup to MCP security inspection.

Your machine is accumulating debris right now. Every day you wait, the cleanup grows more daunting. But in the next five minutes, you could have Dev Janitor running, surfacing recoverable space, exposed secrets, and environment conflicts you'd never find manually.

Download Dev Janitor today from GitHub. Your future self—facing that urgent demo with a full disk—will thank you.

Built with Tauri 2, React 19, and Rust. Licensed under MIT. Maintained by cocojojo5213. Questions? cocojojo5213@gmail.com