Show HN: Unfudged – version every change between commits - local-first

The Hidden Cost of Lost Work: Why What Happens Between Commits Matters

Every developer has experienced that sinking feeling. You've been working for two hours, iterating through multiple approaches, finally landing on the right solution — and then something goes wrong. A misplaced reset, an accidental overwrite, a crash at the worst possible moment. The polished code you committed is safe, but the exploratory work, the debugging breadcrumbs, the intermediate states that led you there? Gone. Traditional version control captures snapshots of your intent, but it misses the messy, valuable reality of how work actually happens. A growing movement in developer tooling is challenging this gap — and the implications stretch far beyond writing code.

The concept is deceptively simple: what if every meaningful change you made was automatically versioned, locally, without you having to think about it? Not just the curated commits you push to a remote repository, but the raw, unfiltered history of your creative process. Tools built around this idea are gaining traction among developers who have grown tired of losing work that falls through the cracks of traditional Git workflows. And the underlying philosophy — local-first, always-available, privacy-respecting — is reshaping how we think about data ownership across every category of software.

Why Git Alone Isn't Enough

Git is arguably the most important developer tool of the last two decades. It made distributed collaboration possible at scale, and its branching model remains elegant. But Git was designed for intentional snapshots. You decide when to commit. You craft a message. You stage specific files. This intentionality is both its strength and its blind spot. The periods between commits — which can stretch from minutes to days — are essentially invisible to your version history.

Studies from developer productivity research suggest that engineers commit an average of 4-6 times per day. That means hours of iterative work, experimentation, and problem-solving happen in the gaps. When a developer tries three different approaches before settling on one, only the final approach survives. The others vanish, even though they contained valuable information about why certain paths were abandoned. For teams doing post-incident reviews or trying to understand architectural decisions months later, this missing context is a real problem.

Auto-save features in editors help prevent catastrophic data loss, but they don't provide structured, browsable history. Undo buffers are linear and session-bound. What's emerging is a middle layer — persistent, granular, local versioning that complements Git rather than replacing it. Think of it as the difference between a security camera that records continuously and one that only takes a photo when you press a button.

The Local-First Philosophy and Why It's Gaining Ground

The local-first movement, popularized by researchers at Ink & Switch and adopted by a growing ecosystem of tools, rests on a core principle: your data should live on your device first, sync to the cloud second. This isn't anti-cloud — it's pro-resilience. Local-first applications work offline by default, perform at the speed of local storage, and give users genuine ownership of their data. When applied to version control, this means your change history isn't dependent on a network connection, a server's uptime, or a third party's pricing decisions.

For individual developers, the appeal is immediate: zero-latency access to your entire working history, no internet required. For organizations handling sensitive codebases — financial services, healthcare, defense — local-first versioning means granular change data never leaves the developer's machine unless explicitly shared. This addresses compliance requirements that cloud-first tools struggle with. According to a 2024 survey by the Cloud Native Computing Foundation, 67% of enterprise engineering teams cited data residency as a top-three concern when evaluating new development tools.

The local-first approach also eliminates the psychological friction of committing. Developers often delay commits because they want their history to look clean, or because they're mid-thought and don't want to interrupt flow. Automatic local versioning removes that decision entirely, creating a safety net that lets developers work more freely while maintaining a complete record they can review, search, or restore from at any time.

What Continuous Versioning Actually Looks Like in Practice

Imagine you're refactoring a payment processing module. Over the course of 90 minutes, you rename several functions, extract a shared utility, realize the utility introduces a circular dependency, revert part of your change, try a different decomposition, and finally arrive at a clean solution. In a traditional Git workflow, your commit history shows one clean commit: "Refactor payment processing module." The 90 minutes of context — the approaches tried and abandoned, the bugs introduced and fixed — are compressed into a single diff.

With continuous local versioning, every save or meaningful change creates a lightweight snapshot. These aren't full Git commits with messages and staging — they're compressed, deduplicated change records stored efficiently on disk. A typical implementation might store a full day's work in under 50MB, using techniques like content-addressable storage and delta compression. You can browse these snapshots in a timeline, compare any two points, or restore specific files to any intermediate state.

The practical benefits compound in several scenarios:

• Recovery from mistakes: Accidentally deleted a function 45 minutes ago and only just noticed? Retrieve it from the continuous history without losing your subsequent work.
• Learning and review: Junior developers can replay their own problem-solving process, or senior engineers can review not just what was changed but how someone arrived at the solution.
• Debugging regressions: When a bug appears between two commits, you can bisect through the intermediate states rather than re-creating them manually.
• Exploratory coding: Try risky refactors without fear. If something breaks catastrophically, you can roll back to any point in the last few hours, not just the last commit.
• Compliance and audit trails: Regulated industries that require evidence of how code changed — not just what changed — get an automatic, tamper-evident record.

Beyond Code: The Broader Case for Granular Change Tracking

While the developer tooling space is leading the charge, the principle of versioning every change has powerful applications across business operations. Consider how many critical business artifacts exist in states of continuous revision: proposals being drafted by sales teams, financial models being iterated by analysts, HR policies being updated by compliance officers, marketing copy being refined before launch. In most organizations, these documents live in tools that offer basic version history at best — and often only when someone remembers to click "Save as new version."

This is one reason why platforms like Mewayz have built change tracking and audit logging into the foundation of their 207-module business OS. When your CRM records, invoicing data, HR documents, and project workflows all live in a unified system, maintaining a granular history of changes across every module becomes not just possible but automatic. For the 138,000+ businesses already on the platform, this means every modification to a client record, every update to a payroll entry, every revision to a booking configuration is tracked, attributable, and reversible — without anyone having to remember to "save a version."

The alignment between local-first developer tools and comprehensive business platforms reflects a broader shift in how we think about data integrity. Users increasingly expect that their tools will protect them from their own mistakes, provide transparency into how information evolved, and do so without adding friction to their workflows.

Building a Culture That Values Process, Not Just Outcomes

The most valuable insight in any creative process isn't the final product — it's understanding the decisions that shaped it. When we discard the journey and keep only the destination, we lose the ability to learn from our own experience.

Organizations that embrace granular change tracking often discover a secondary benefit: it transforms how teams learn. When a sales team can review the revision history of a winning proposal — seeing not just the final version but the twelve drafts that preceded it — they extract patterns that no post-mortem meeting could capture. When an engineering team can replay the debugging process that resolved a critical outage, they build institutional knowledge that survives employee turnover.

This shift requires rethinking our relationship with "messy" work. Traditional version control — and traditional business tools — encourage us to present polished outputs. We curate our Git history with interactive rebases, squash our experimental commits, and present a narrative of linear progress. But real work is nonlinear. Ideas are tried and abandoned. Approaches are combined, split, and recombined. By preserving this reality rather than sanitizing it, we create a resource that compounds in value over time.

Teams adopting these practices report measurable improvements. A 2025 engineering productivity study found that teams with access to granular change history resolved production incidents 34% faster, primarily because they could trace the exact sequence of changes that preceded a failure rather than working from curated commit messages alone. Onboarding time for new developers decreased by an average of 18 days when they could browse the historical context behind code decisions.

What to Look for When Adopting Change-Tracking Tools

Whether you're evaluating developer-focused versioning tools or business platforms with built-in audit capabilities, several criteria separate genuinely useful solutions from feature-checkbox implementations:

1. Zero-friction capture: If users have to remember to save versions or click buttons, adoption will be inconsistent. The best tools capture changes automatically and invisibly.
2. Efficient storage: Naive approaches to versioning can consume disk space quickly. Look for content-addressable storage, delta compression, and configurable retention policies that keep storage manageable.
3. Fast, searchable history: A million snapshots are useless if you can't find the one you need. Effective tools offer timeline browsing, file-level filtering, and content search across historical states.
4. Privacy and data ownership: Particularly for sensitive business data or proprietary code, ensure that change history is stored where you control it — locally or in your own infrastructure — rather than in a vendor's cloud by default.
5. Integration with existing workflows: Tools that require abandoning your current workflow face an uphill adoption battle. The most successful ones layer on top of Git, existing editors, or existing business platforms without demanding behavioral change.

For development teams, this means looking at tools that integrate with your editor and complement your Git workflow. For business operations, it means choosing platforms — like Mewayz — where change tracking is woven into every module rather than bolted on as an afterthought. When your CRM, invoicing, payroll, HR, and project management tools all share a unified audit layer, you get a complete picture of how your business data evolves over time.

The Future Is Continuous, Local, and Transparent

The convergence of local-first architecture, granular versioning, and privacy-conscious design isn't a passing trend — it's a correction. For two decades, we've accepted that our tools would capture only the moments we explicitly chose to preserve, that our data would live primarily on someone else's servers, and that the messy reality of how work happens would be discarded in favor of clean narratives. The tools emerging today challenge all three assumptions simultaneously.

For developers, this means never losing work again — not just the committed code, but the exploratory paths, the debugging sessions, the intermediate states that represent how solutions are actually discovered. For businesses, it means operating with a level of transparency and recoverability that was previously impractical. Every change tracked, every decision recoverable, every process visible — without adding a single extra step to anyone's workflow.

The organizations that will thrive in the next decade are those that treat their operational history as an asset rather than a liability. Whether you're versioning code changes between commits or tracking every modification to a client record across 207 business modules, the principle is the same: capture everything, store it efficiently, make it searchable, and let people work without fear. The technology to do this affordably and privately is here. The question is no longer whether to adopt it, but how quickly you can make it part of how your team works.

Frequently Asked Questions

What happens to my code changes between Git commits?

Most developers lose hours of exploratory work, debugging steps, and intermediate code states that occur between commits. Traditional version control only captures intentional snapshots, missing the messy but valuable iterations in between. Unfudged solves this by automatically versioning every change locally, ensuring no work is ever lost — even if you accidentally reset, overwrite, or experience a crash before committing.

How does local-first versioning differ from regular Git?

Git requires you to manually stage and commit changes, capturing only the moments you choose to save. Local-first versioning runs continuously in the background, recording every file modification as it happens without requiring any action from you. This creates a complete timeline of your work, letting you recover any intermediate state, compare iterations, and understand exactly how your solution evolved.

Can I integrate continuous versioning into my existing development workflow?

Yes — tools like Unfudged are designed to complement Git, not replace it. They run silently alongside your existing workflow, adding a safety net without changing how you commit or push code. For teams managing complex projects across multiple tools, platforms like Mewayz offer a 207-module business OS starting at $19/mo to streamline operations beyond just code.

Why should developers care about preserving work between commits?

The exploratory code you write between commits often contains critical problem-solving context — failed approaches that inform future decisions, debugging breadcrumbs, and incremental improvements. Losing this history means repeating work and losing insights. Preserving every change creates a recoverable, searchable record that saves time, reduces frustration, and helps teams understand the full story behind every solution.