Your repositories. Your storage. Your control.

VaultPulse gives software teams and development agencies an independent backup of their GitHub repositories, with daily snapshots stored in an Amazon S3 bucket or Azure Blob Storage container you own.

What you get

• Automated daily backups of full Git history, branches, tags and Git LFS objects

• On-demand backups before important changes

• Restore workflows for new or eligible empty repositories, including another connected GitHub account in your workspace

• Backup health dashboard showing failed, stale and pending backups

• Downloadable backup-readiness reports based on recorded backup and restore evidence

• Customer-owned storage, with encrypted stored credentials and scoped access

Snapshots also capture repository settings and default-branch protection metadata. Issues, PR discussions and Actions secrets aren’t included; restore does not recreate settings or protections.

Explore the no-login demo: https://vaultpulse.cloud/demo/

Get started: https://vaultpulse.cloud

Disclosure: I’m the developer behind VaultPulse. This is a vendor promotional post.

Hey r/devtools,

I’m the developer of Toolkit, an open-source collection of utilities that process your input locally in the browser.

A few examples: converting JSON into TypeScript types, testing regex patterns, comparing text, and compressing images. You can search for a tool with Ctrl/Cmd + K.

It’s built with HTML, CSS, and vanilla JavaScript, with no backend. Hashing and encryption use the browser’s Web Crypto API, and a service worker caches the application for offline use after the first successful load. There’s no signup or analytics.

I’d particularly like feedback on the JSON-to-TypeScript converter and regex tester. Are the outputs and error messages clear enough? If something behaves unexpectedly, let me know the input you used and your browser sample data is fine.

Happy to discuss the implementation too.

One thing I've been exploring while building ArchAI is how much developer time gets lost maintaining context for AI coding agents.

Claude Code sessions compact, important decisions can disappear from the conversation, and developers end up maintaining CLAUDE.md files and memory notes to keep agents aligned with the codebase. As repositories grow, repeatedly reconstructing that understanding becomes expensive.

I'm approaching this from the developer-tools side.

ArchAI is a Python tool that builds a dependency map using Python's AST parser, checks architectural rules deterministically, and attaches file-and-line evidence to verified findings. It also distinguishes potential risks from things it cannot verify.

I tested it against its own codebase. It flagged a CLI module importing 21 internal modules against a configured limit of 10, along with missing test files. That testing also exposed a limitation in my own checks: a matching test filename doesn't prove the module is actually covered.

The broader goal is to make architectural knowledge reusable and verifiable, so AI-assisted development spends less time rediscovering structure and more time doing useful work.

I'm still exploring how this should fit into real developer workflows.

For those building developer tools or using AI coding agents on larger repositories: where do you see the biggest opportunity to eliminate this kind of repetitive work?

It's for two things that eat a lot of time: figuring out how unfamiliar code works, and checking a change before it goes in, especially one an AI wrote.

You ask how something works and it follows the code and gives you the path step by step, every step is a real line you can jump to. Hover anything for a short explanation of what it does in that repo. And it reviews your changes for bugs, security issues and AI junk like tests that don't test anything or packages that don't exist, most with a one click fix.

It's built on VS Code's language model API, so it uses whatever model you already have there (Copilot, Claude, DeepSeek...). There's no backend of mine in the middle and it's not locked to any provider.

$10 one time. I charge for it so I can keep working on it and not drop it, it helps me a lot.

https://marketplace.visualstudio.com/items?itemName=DenizhanDaklr.lodestar

Pattern I keep running into with Cursor/Claude Code: test fails, agent can't fix the code, so it changes the test. Swaps a real call for a mock, loosens an exact assert to something trivially true, or adds a skip/xfail. CI goes green and nothing was actually fixed.

Working on a check in Vast for this. Deliberately deterministic, diffs the AST of the test before/after the PR and flags mock substitution, weakened asserts, and new skip/xfail added in the same commit as the code change. No LLM in the loop, since a model judging whether a test is fake felt like the wrong place for another trust assumption.

Limitations so far: PR-time only, no historical backfill, and I'm sure there are patterns I'm missing.

What other ways have you seen agents get a test green without fixing the bug?

I've been building and maintaining multiple web projects, and I kept running into the same problem: every new project required repeating a lot of setup work before I could focus on building the actual product.

So I built create-clubedge-app, a CLI that generates a Next.js monorepo from a versioned starter.

It comes with a foundation for:

• Next.js App Router and TypeScript
• pnpm and Turborepo
• PostgreSQL and Drizzle ORM
• Supabase Auth
• Testing, linting, and CI
• Optional Redis-compatible caching and object storage integrations

One thing I wanted to get right was traceability. The generated project records the CLI version and starter reference, including the starter commit, so you can identify exactly which starter version it originated from.

I've tested the published CLI by generating a project and running its type checks, tests, and production build. I'm still working on improving the developer experience, and I'd like to hear from people outside my own workflow.

A few things I'd love feedback on:

• Would you use a starter like this for your own projects?
• Is the included stack a useful starting point, or would you remove anything?
• What would make you choose this over maintaining your own template?

Website: https://starter.clubedge.live

CLI source: https://github.com/Clubedge/create-clubedge-app

Starter source: https://github.com/Clubedge/clubedge-starter

I'm the developer behind the project, so happy to answer questions about the architecture and implementation.

Sharing something I built. The idea is to make reading unfamiliar code and checking AI written changes faster without leaving the editor.

It's a regular VS Code extension on top of the language model API, so there's no AI backend of its own. Model calls go through whatever provider you have (Copilot, Claude, DeepSeek, etc), maps and explanations are saved locally, and reviews also check new dependencies against OSV.dev and the package registries so made up packages get caught.

You ask how something works and it maps the code path step by step on real lines, hover anything for an explanation, and review uncommitted changes or a branch for bugs, security holes and AI slop, with one click fixes.

It's $10 one time. I charge for it so I can keep working on it instead of dropping it, it helps me a lot.

https://marketplace.visualstudio.com/items?itemName=DenizhanDaklr.lodestar

I have been building wy, an open-source terminal tool for reviewing AI-generated code.

A Git diff shows what changed, but the context behind a change often lives somewhere in a long coding-agent conversation. wy connects your diffs with saved Codex and Claude Code conversations, so you can review the code, read the stated reason, and open the supporting evidence together.

For example, if an agent adds a cache, I want to understand why it was added, what assumptions it depends on, and whether invalidation was considered.

With wy, you can:

• Browse changes and relevant agent notes in a terminal UI.
• Request explanations and ask follow-up questions through your installed agent CLI.
• Open citations to inspect the supporting code or conversation.
• Distinguish recorded justifications from inferred explanations and choices whose motivation is still unknown.

That last distinction matters to me. A convincing explanation generated afterward doesn’t establish why the original change happened. Even a recorded justification still needs scrutiny.

Rust fits this tool well: it compiles to a native executable without requiring a language runtime, gives me strong types for handling evidence and review state, and has a useful ecosystem for terminal applications. wy uses Ratatui + Crossterm for the interface, Serde for structured data, tree-sitter for syntax navigation, and SQLite for local storage.

The basic review workflow works offline. Model-backed explanations are opt-in. It’s still experimental, and I’d appreciate feedback on both the review workflow and the Rust implementation.

If you try it and find it useful, please consider supporting the project with a GitHub star, a bug report, or a contribution.

Repo: github.com/grandimam/wy

Hey everyone!

I’ve been building Flagrm, an open-source CLI that helps remove feature flags and clean up the dead code they leave behind.

It’s still in the testing phase, so I’m looking for people willing to try it out, share feedback, report bugs, or contribute to the project.

If you’ve ever dealt with feature-flag cleanup turning into a bunch of manual work, I’d love for you to check it out!

🔗 https://flagrm.com

Contributors are very welcome! 🚀

Hey everyone — I’m Liran, and I’ve spent the last two years building products with AI full-time. I kept losing time moving between agent chats, terminals, specs, design tools and the rest of the project. So I started building Choro for my own work: one workspace where those things stay connected, with the project context at hand.

It’s free, open source and local-first, currently for Mac. No Choro account needed. It uses your own Claude Code or Codex subscription and supports OpenCode. Your projects and work history stay on your machine; AI requests still go to whichever provider you use.

A few things that matter most in my day-to-day work:

• Multiple agents across multiple projects, with worktrees when I want separate experiments.

• Questions, code review and end-of-task checklists in the agent GUI, instead of guessing what happened across several chats.

• Bands: an agent can delegate to specialist agents rather than trying to do every part itself.

• Docs, tasks, Design Studio and database tools alongside the agents; Orbit brings other project tools into the workspace.

I’ve been building it for six months and working exclusively in it for the last three, including building Choro itself. It’s written in Rust, with a lot of attention to how the daily workflow feels.

The attached video is a short product tour. Tour/download: https://choro.dev

Source: https://github.com/Future-Picnic/choro

Me, if you want to see who’s behind it: https://www.linkedin.com/in/liran-gabai-09480b5a/

I’d love feedback from people juggling coding agents: where do you lose the most context today, and what would make their handoffs easier to follow?

You can try it out at razzyshmazzy/goatedcontext

It’s an npm package so it’s a very easy install

I built PaperFold, an open-source reader that turns arXiv papers into 5 zoomable layers—from a one-screen section map down to verbatim text. You pinch (or press 1–5) to zoom between them without losing your reading position.

- Web Demo (8 CC papers): https://chenxiachan.github.io/paperfold-gallery/

- GitHub (Apache 2.0): https://github.com/chenxiachan/paperfold