DEV Community: jelly cri

TaskVault: Stop Wasting Compute on Work You've Already Done

jelly cri — Sun, 08 Feb 2026 19:23:51 +0000

Every day, engineering teams burn thousands of dollars recomputing results they've already calculated. ML engineers retrain models with identical datasets. CI/CD pipelines rebuild unchanged code. Data pipelines retransform the same data. ETL jobs reprocess identical batches.

What if your infrastructure could just... remember?

That's exactly what TaskVault does. It's an open-source, content-aware caching layer that fingerprints your task inputs and serves cached results instantly when the same work is requested again.

🎯 The Problem We're Solving

Let's be honest: most compute waste isn't dramatic. It's death by a thousand reruns.

ML Teams: Accidentally retraining models with the same hyperparameters and datasets → wasted GPU hours at $2-5/hour
Build Systems: Rebuilding unchanged code because someone touched a timestamp → CI/CD sprawl
Data Engineers: Re-transforming identical CSV files because cache invalidation is "too complex" → unnecessary ETL overhead
DevOps: Rerunning identical test suites that haven't changed → bloated test execution times

Industry estimates put global compute waste from redundant work in the billions annually. TaskVault turns that waste into saved time, money, and infrastructure capacity.

✨ How It Works

TaskVault uses content-addressable storage with cryptographic hashing (Blake3 by default) to create a unique fingerprint for any input:

# First run: do the actual work
python train_model.py --dataset data.csv > model.pkl

# Cache the result
taskvault cache save train_model data.csv model.pkl
# ✓ Cached train_model (hash: a3f2b1c8..., size: 5.2 MB)

Later, when you run the same task with the same input:

# Same dataset, same parameters
taskvault cache get train_model data.csv model_restored.pkl
# ✓ Cache hit! Result restored in 12ms
# Your expensive computation: SKIPPED

The magic? TaskVault analyzes the actual content, not just filenames or parameters. Rename data.csv to dataset.csv? TaskVault knows it's the same file. Change one byte? New hash, fresh computation.

🚀 Key Features

🔐 Content-Aware Hashing

Uses Blake3 (3+ GB/s throughput) for cryptographically-secure fingerprinting. Same content = same hash, always. Different content = different hash, guaranteed.

📦 Format Agnostic

Cache anything: JSON, binary files, ML model checkpoints, images, video frames, database dumps. If it's deterministic, TaskVault can cache it.

🌐 Distributed-Ready

Start simple with SQLite for single-node deployments. Scale seamlessly to PostgreSQL + S3/GCS for distributed teams. Kubernetes-native with gRPC synchronization.

⏱️ Smart Eviction Policies

Configurable TTL (time-to-live) and LRU (least-recently-used) cleanup. Never run out of disk space. Never serve stale results.

🔌 Zero-Downtime Integration

Three integration paths, pick what works:

CLI wrapper: Wrap any command with taskvault exec
Environment hooks: Set TASKVAULT_ENABLE=true and we handle the rest
Programmatic SDK: Go library for deep integration

📊 Full Audit Trail

Every cache hit, miss, and error logged with timestamps and metadata. Debug cache behavior. Measure savings. Prove ROI.

💡 Real-World Use Cases

ML/AI Pipelines

# Cache expensive preprocessing
taskvault exec --name preprocess -- python clean_data.py raw.csv clean.csv

# Cache model training runs
taskvault exec --name train -- python train.py --epochs 100

Result: Stop retraining models when only logging code changed. Save 70-90% of GPU costs during experimentation.

CI/CD Optimization

# GitHub Actions example
- name: Run tests with cache
  run: |
    taskvault exec --name test-suite -- npm test

Result: Skip test reruns for unchanged code. Cut CI/CD costs by 40-60%.

Data Engineering

# Cache ETL transformations
taskvault exec --name transform-daily -- spark-submit transform.py input.parquet

Result: Reprocess only what changed. Handle reruns gracefully. Reduce pipeline execution time by 50-80%.

🏗️ Architecture Highlights

TaskVault is built with production-grade engineering in Go:

SOLID principles: Clean separation of concerns, testable, maintainable
Concurrent-safe: Goroutines and proper locking for multi-threaded workloads
Resilient: Corruption detection, atomic writes, graceful degradation
Observable: Structured logging, metrics, audit trails

┌─────────────────────┐
│  CLI / SDK Layer    │  (User-facing API)
├─────────────────────┤
│  Cache Manager      │  (Policies, eviction)
├─────────────────────┤
│  Hash Engine        │  (Blake3/SHA256)
├─────────────────────┤
│  Storage Layer      │  (SQLite + blobs)
├─────────────────────┤
│  Persistence        │  (Local disk → Cloud)
└─────────────────────┘

Full source: github.com/Usero0/taskvault

📈 Measuring Impact

TaskVault includes built-in analytics:

taskvault cache stats

Output:

TaskVault Cache Statistics
==========================
Entries:        1,247
Total Size:     7.43 GB
Hit Rate:       73.2%
Avg Hit Time:   8ms
Avg Miss Time:  14,230ms

Savings This Month:
  ✓ Compute time saved: 147 hours
  ✓ Estimated cost saved: $2,341 (at $0.05/min)

Track ROI. Prove value. Optimize what matters.

🛠️ Getting Started

Installation

# Clone and build (requires Go 1.21+)
git clone https://github.com/Usero0/taskvault.git
cd taskvault
go build -o taskvault ./cmd/taskvault

# Or download prebuilt binary from releases

Quick Setup

# Initialize configuration
./taskvault init

# Cache your first task
./taskvault cache save my-task input.txt output.txt

# Retrieve it later
./taskvault cache get my-task input.txt restored-output.txt

That's it. No complex configuration. No vendor lock-in. No runtime dependencies.

🌟 Why Open Source?

We believe cache invalidation shouldn't be rocket science. TaskVault is:

MIT Licensed: Use it anywhere, commercial or personal
Community-Driven: Contributions welcome, roadmap transparent
Self-Hostable: Your data never leaves your infrastructure
Free Forever: Core features always free

Enterprise features (distributed coordination, advanced security, SLA support) will be offered as optional add-ons, but the foundation remains open.

🗺️ Roadmap

v1.0 (Current):

✅ Content-aware caching
✅ CLI + Go SDK
✅ SQLite storage
✅ Blake3/SHA256 hashing
✅ TTL + LRU eviction

v1.5 (Q2 2026):

🔄 PostgreSQL backend for distributed teams
🔄 S3/GCS blob storage
🔄 gRPC remote cache server
🔄 Python SDK

v2.0 (Q3 2026):

📋 Kubernetes operator
📋 Prometheus metrics
📋 Web dashboard
📋 Multi-node coordination

See ROADMAP.md for details.

🤝 Contributing

We're looking for contributors! Whether you're:

A Go developer who loves clean architecture
A DevOps engineer with caching war stories
A technical writer who can explain complex concepts simply
A designer who can make dashboards beautiful

Check out CONTRIBUTING.md to get started.

🎬 Final Thoughts

Compute is expensive. Time is expensive. Redoing work you've already done? That's just wasteful.

TaskVault gives you a simple superpower: remember what you've computed, and never do it twice.

It won't solve all your infrastructure problems. But it might solve the ones you didn't realize were costing you thousands every month.

Give it a try. Tell us what breaks. Tell us what you'd like to see.

Try TaskVault: github.com/Usero0/taskvault

Join the Discussion: GitHub Discussions

Built with ❤️ and Go. MIT Licensed. Contributions welcome.

💬 Discussion Questions

What are your biggest sources of redundant computation? Have you tried building internal caching layers? What worked, what didn't?

Let's discuss in the comments! 👇

I Built a CLI Task Manager That Learns When to Use Machine Learning (and When Not To)

jelly cri — Wed, 28 Jan 2026 13:09:02 +0000

Most productivity tools today are either:
Rule-based (static priorities, deadlines, heuristics), or
“AI-powered” in name only, applying ML everywhere whether it makes sense or not.
I wanted to explore a third path.
So I built PriorityPilot — a CLI-first task & project manager that learns from your behavior, but only when the data actually justifies it.

The Core Idea
Machine Learning is powerful — but only after:

enough data exists
the signal is stronger than a simple baseline
the model proves it’s better than heuristics

PriorityPilot starts fully rule-based, and progressively enables ML only when it earns the right to do so.
No magic. No hype. Just measured decisions.

What PriorityPilot Does
Manage projects and tasks from the terminal
Track:

priorities
deadlines
estimated vs actual hours Learn from:
your task completion patterns
real time spent
ordering decisions you implicitly make Then it uses ML to:
predict task priority
estimate required effort
rank tasks pairwise (what should come before what) All while staying transparent about confidence and limitations.

Why a CLI?
Because:
speed matters
context switching kills focus
developers already live in the terminal

PriorityPilot supports:
Basic mode → minimal friction
Advanced mode → ML insights, confidence intervals, drift warnings
Same tool, different levels of depth.

The ML Philosophy (This Is the Important Part)
PriorityPilot is ML-first in design, but ML-last in execution.
Cold Start Is Explicit
Below ~10 samples → no ML
Pure heuristics and neutral predictions
Baseline Always Wins by Default
Ridge regression baseline
ML models must outperform it
If they don’t → they’re ignored
Drift Detection
If your behavior changes, the system notices
Models are downgraded automatically
Confidence > Predictions
Estimates include confidence intervals
Warnings appear when predictions are unreliable
This is not “AI guessing”. It’s ML behaving responsibly.
Models Used (Nothing Exotic)
Gradient Boosting → priority prediction
Random Forest → effort estimation
Logistic Regression → pairwise ranking
Ridge → baseline sanity check
Simple models. Interpretable. Good enough.

If You’re Curious
⭐ Star the repo if you like the idea
🧪 Try it and break it
💬 Feedback (especially critical) is welcome
👉 https://github.com/Usero0/PriorityPilot
Thanks for reading — and remember:
ML should earn its place, not assume it.

Building PriorityPilot: A CLI Project Manager That Learns From Your Decisions

jelly cri — Sun, 25 Jan 2026 17:47:22 +0000

Ever felt like your project management tool should learn how you actually work instead of forcing you into rigid workflows? That's why I built PriorityPilot — a command-line project manager that uses machine learning to adapt to your behavior.

🔗 GitHub Repository

The Problem

Traditional project management tools make you manually prioritize tasks, estimate timelines, and adjust plans. But here's the thing: your actions already tell the story. When you start a task, postpone another, or complete something faster than expected, you're giving signals about what matters and how long things actually take.

What if your PM tool could learn from these signals?

What PriorityPilot Does

PriorityPilot is a CLI application that:

📊 Learns your priorities from which tasks you start, complete, or postpone
⏱️ Predicts task durations with confidence intervals (e.g., "3-7 hours, 80% confidence")
🔍 Detects data drift to warn you when its predictions become unreliable
📈 Provides analytics on bottlenecks, health metrics, and project trends
🎯 Adapts to your workflow — starts neutral, gets smarter over time

All in a fast, keyboard-driven interface with zero cloud dependencies.

The Architecture

Tech Stack

Python 3.9+ for core logic
scikit-learn for ML models (Gradient Boosting, Random Forest, Ridge Regression)
SQLite for local persistence
Click (or similar) for CLI structure

Project Structure

PriorityPilot/
├── cli/              # User interface (Basic & Advanced modes)
├── services/         # Business logic & analytics
├── ml/               # ML pipeline (training, inference, features)
├── database/         # SQLite manager
├── models/           # Domain models (Task, Project, Milestone)
├── utils/            # Validation, formatting, import/export
├── ml_models/        # Persisted models (.pkl)
├── ml_training_data/ # Training samples & decision logs
└── exports/          # JSON/Markdown reports

The ML Pipeline: How It Learns

1. Signal Collection

Every user action generates training data:

# When user starts a task
signal = {
    "action": "start",
    "task_id": task.id,
    "priority_boost": +1,  # This task matters now
    "timestamp": datetime.now()
}

# When user postpones a task
signal = {
    "action": "postpone",
    "task_id": task.id,
    "priority_penalty": -1,  # This can wait
    "timestamp": datetime.now()
}

# When user completes a task
signal = {
    "action": "complete",
    "task_id": task.id,
    "actual_duration": 4.5,  # hours
    "estimated_duration": 3.0
}

These signals feed into three models:

2. Priority Model (Gradient Boosting)

Features extracted from each task:

Time until due date
Estimated complexity
Number of dependencies (blocking/blocked)
Milestone proximity
Historical completion rate
Recent activity patterns

Training approach:

Uses pairwise comparisons: "Task A was chosen over Task B"
Continuous learning as more decisions are logged
Falls back to rule-based heuristics with < 10 samples

# Simplified feature extraction
def extract_features(task):
    return {
        'days_until_due': (task.due_date - now).days,
        'estimated_hours': task.estimated_hours,
        'dependency_count': len(task.dependencies),
        'completion_rate': task.project.completion_rate,
        'milestone_weight': 1.0 if task.milestone else 0.0,
        'started_recently': 1.0 if task.started_within(7) else 0.0
    }

3. Time Estimator (Random Forest on Log-Hours)

Why log-hours? Software tasks follow a log-normal distribution — most are quick, but outliers can be 10x longer.

# Train on log-transformed durations
X_train = feature_matrix
y_train = np.log1p(actual_durations)  # log(1 + hours)

model = RandomForestRegressor(n_estimators=100)
model.fit(X_train, y_train)

# Predict with confidence intervals
predictions = model.predict(X_test)
std_dev = np.std([tree.predict(X_test) for tree in model.estimators_])

lower_bound = np.expm1(predictions - 1.96 * std_dev)
upper_bound = np.expm1(predictions + 1.96 * std_dev)

This gives estimates like: "4.2 hours (3.1–7.5h, 95% CI)"

4. Drift Detection

Machine learning models degrade over time. PriorityPilot monitors:

Feature distribution shift: Are task characteristics changing?
Prediction error trends: Is accuracy declining?
Sample staleness: Is training data outdated?

When drift exceeds thresholds, the UI warns users and suggests retraining.

Key Features

Adaptive Prioritization

The system starts with neutral heuristics (due date, dependencies) and gradually learns your preferences. If you consistently start tasks marked "Low" priority, it learns that's actually important to you.

Confidence Intervals, Not Point Estimates

Traditional estimators give you "3 hours" — but that's rarely accurate. PriorityPilot gives you:

Best estimate: 4.2 hours
80% confidence: 3.5–5.5 hours
95% confidence: 2.8–7.1 hours

This helps you plan buffers and communicate realistic timelines.

Two-Speed UI

Basic Mode: Fast task CRUD, status updates, minimal friction
Advanced Mode: Full analytics, ML insights, export/import, drift reports

Switch between them with one keystroke.

Challenges & Solutions

Challenge 1: Cold Start Problem

Problem: ML needs data, but new users have none.

Solution: Rule-based fallback prioritization (due dates, dependencies, milestone proximity) until ~10 samples collected. The UI clearly shows when ML predictions are active vs. heuristic-based.

Challenge 2: Small Sample Sizes

Problem: Personal projects might only have 20-50 tasks total.

Solution:

Pairwise learning (every choice creates training data)
Feature engineering to maximize signal
Cross-validation with small-sample corrections
Explicit warnings when confidence is low

Challenge 3: Model Interpretability

Problem: Users distrust black-box predictions.

Solution: ML insights screen shows:

Feature importance (what drives predictions)
Model metrics (R², RMSE, MAPE)
Drift scores and sample counts
Ridge baseline comparison

What I Learned

Implicit feedback is powerful: Users don't want to rate tasks — their actions are the data.
Uncertainty quantification matters: Confidence intervals are more useful than point estimates for planning.
Drift detection is non-negotiable: ML in production needs guardrails, even for personal tools.
CLI + ML is underexplored: Most ML tools are web apps, but CLIs can be fast, private, and keyboard-driven.

Try It Yourself

# Clone and setup
git clone https://github.com/Usero0/PriorityPilot.git
cd PriorityPilot
python -m venv .venv
source .venv/bin/activate  # or .venv\Scripts\activate on Windows
pip install -r requirements.txt

# Run
python app.py

Start with creating a project (option 1), add some tasks (option 6), and explore ML features after ~10-15 tasks.

Contribute

PriorityPilot is open source (MIT license). Contributions welcome!

🐛 Report issues
💡 Suggest features
🔧 Submit PRs

Have you tried adaptive ML in your personal tools? What worked and what didn't? Let's discuss in the comments! 👇

If you found this interesting, consider starring the repo or sharing with your team!

I built a C++ tool to clean development junk files on Windows

jelly cri — Tue, 20 Jan 2026 17:57:59 +0000

As developers, our machines slowly fill up with development-related junk files.

Things like:

node_modules
build artifacts
cached files
temporary folders created during development

On Windows, general-purpose cleaners often feel either too aggressive or too opaque, while manual cleanup is repetitive and error-prone.

So I decided to build a small open-source tool called Dev-FileCleaner.

❓ Why I built it

I wanted a tool focused specifically on development folders, with a clear and predictable behavior.

My goals were:

make cleanup safer and more transparent
avoid “one-click magic” that deletes things blindly
provide a simple graphical interface instead of command-line only tools
focus only on development-related directories

The idea was to give developers control, not automation without context.

🖥️ What Dev-FileCleaner does

Dev-FileCleaner is a Windows desktop application written in C++ that scans for common development junk folders and lets you clean them in a controlled way.

It focuses on directories such as:

dependency folders (for example node_modules)
build outputs
cached artifacts generated during development

Instead of running silently, the tool:

shows what it finds
lets the user review the results
performs cleanup only when explicitly requested

⚙️ Why C++

I chose C++ mainly for:

performance when scanning large directory trees
low memory overhead
direct control over filesystem operations
building a native Windows application

This project was also a good opportunity to work with filesystem APIs and desktop application development in C++.

🧠 What I’d like feedback on

This is still an evolving project, and I’d really appreciate feedback on:

the overall UX of the GUI
safety assumptions around deleting folders
features that would actually help developers
ideas for improving usability or extending the tool

🔓 Open source

The project is fully open source and available on GitHub:

👉 https://github.com/Usero0/Dev-FileCleaner

If you work on Windows and often deal with development junk folders, I’d love to hear your thoughts or suggestions.

Thanks for reading 👋

I built a Python project to explore practical password security

jelly cri — Tue, 20 Jan 2026 16:26:02 +0000

Hi everyone 👋
I’ve been working on a Python open-source tool called shieldpass that focuses on practical password security.
Instead of doing just one thing, it combines multiple features that I often needed separately, like:

generate secure passwords
build password wordlists
calculate password entropy
check whether a password has appeared in known data breaches

I built it mainly as a learning project to better understand how password strength, entropy, and breach checking actually work in practice — not just in theory.
I’m especially interested in feedback on:

security assumptions and potential weaknesses
code structure / design choices
features that would actually be useful in real-world scenarios

My GitHub: here