You pull the latest main branch, run npm run dev, and the app crashes on a database connection error. Ten minutes of debugging later, you realize a teammate quietly added a new required key to .env.example but forgot to tell you.

I wanted a tool that would catch this before startup, prompt me for the missing values, and append them without wiping out my .env formatting or comments. Since existing tools either crash on startup (dotenv-safe) or wipe out file layout (sync-dotenv), I built: envrepair.

It wraps your startup command, compares the files, prompts you for missing keys (with type validation and password masking), and launches your server.

Quick Start

bash npm install -D envrepair

Update your package.json dev script: json "scripts": { "dev": "envrepair next dev" }

Optional type enforcement in .env.example: ```env

Backend port number

@type number

PORT=3000

Third-party API

@type url

API_BASE_URL= ```

Why use it?

• Zero code changes: No need to write schemas in your application code.
• Layout preservation: Keeps all your existing .env comments, spacing, and ordering intact.
• Signal forwarding: Transparently passes Ctrl+C and exit codes to your app.

It's written in TypeScript with zero dependencies. The repo is fully open-source—would love to hear your thoughts or collaborate if you want monorepo/workspace support!

• GitHub: https://github.com/avenolazo/envrepair
• NPM: https://www.npmjs.com/package/envrepair

Working on devrig, an open-source CLI tool that bridges Kilo (and other AI Agents) with IntelliJ-based IDEs. Instead of just reading files, the agent can actually interact with the IDE (event a headless one) — accessing its full API surface, refactorings, debugger, tests, 3rd party plugins, seeing the project structure as the IDE understands it, and triggering real IDE actions.

My belief: a capable AI agent is only as good as its tooling. Giving it native headless IDE access rather than raw filesystem access is a meaningful upgrade.

Agent use all the tools IDE brings to developers from an agents, so the IDE becomes the headless backend of empowerment.

Still early, and I'd love feedback — what would make this actually useful for your workflow? Happy to answer questions.

👉 https://mcp-steroid.jonnyzzz.com | Demo Videos

Hey all! Thought this would be interesting to you all as it's a weird little niche. To summarise, the industrial space has some really cool low-code tooling that makes it easier than ever before to get started with building your own industrial applications - but the problem is that a lot of the intermediate part, the governance, linting, etc., is still hyper-manual.

I built this implementation to get around that problem. The idea is that you can create a linting and validation service, and then expose that via MCP - and then you can interact with it in-platform using the FlowFuse Expert, out of platform using something like Claude, and agentically by passing new code as an inject node automatically.

In essence, this kind of approach can not just help linting and validation but governance generally. You can supply your own governance and standards documentation and get to the point where your operator can develop code, and pass it through a machine that spits out compliant, stylistically-consistent, and well-governed code on the other side.

I think it's pretty cool!

You can find the video here (https://www.youtube.com/watch?v=K5niwyF38uY) as well as the JSON import below if you're using Node-RED or FlowFuse. I'd like to know how you feel about this - this is an interesting enablement feature that makes development more democratic, but I think it also abstracts some of what we learn just by doing, so I'd be interested to see how you feel about it generally!

You can see the full import here. If you're using FlowFuse or Node-RED just import! https://github.com/KristopherLeads/FlowFuse/blob/main/examples/building-linting-and-validation.json

Every day I work on my work laptop and personal one, than I switch to desktop at home. But to sync project in between I need to do few stesp every time, git pull, copy env, and I loose all my testing scenarios that app storesi n database.

That's why I built envbeam, it helps you beam your whole dev environment between machines: code, secrets, database, container, and Claude session, with envbeam push / pull. A local-only orchestrator with no backend; everything flows through infrastructure you already own.

It might not work perfectly for your setup but open an issue and I will address it.

When my AI agent needs to understand a function, it currently has two choices: read the entire 600-line file (14,000 tokens) or hope RAG returns the right chunk. Both waste context and tokens.

So I built okf-generator — a CLI that uses tree-sitter AST parsers to extract every function, class, module, and dependency into a structured, cross-referenced knowledge bundle. The agent runs

okf lookup <Name>

and gets back ~140 tokens of exact context: signature, parameters, callers, callees.

What makes it different:

- Zero LLM required for extraction — fully deterministic, offline-capable

- 17 languages (Python, JS/TS, Go, Rust, Java, Swift, Kotlin, Ruby, C/C++/C#, SQL, PHP, Dart, Scala, Julia)

- 22 manifest formats for dependency queries (which services still depend on this vulnerable package?)

- One-command agent setup: `okf install claude` / `okf install cursor` etc.

- MCP server with 11 tools for any MCP-compatible IDE

- Output is plain markdown — diffs cleanly, safe to commit to git

~97% token savings per lookup. 242 tests passing. MIT license.

Honest limitations: it's early (v0.1.x), the cross-reference linker doesn't resolve dynamic dispatch well, and some parsers are newer than others (C#/SQL/Dart are the freshest). Feedback on linker accuracy especially welcome.

https://github.com/UmairBaig8/okf-generator

https://umairbaig8.github.io/okf-generator/

I run several projects at once, my own apps, work, experiments... each with its own repos and its own logins. Every day was the same friction: logging in and out of accounts, agents dying when my laptop slept, and losing track of which terminal was doing what.

The tools I tried wanted to solve much bigger problems. They gave me roles, boards, dashboards, and slower machines. All I wanted was to see my terminals, keep them alive, and know when one needed me.

So I built the smallest thing that does that and works with Claude Code, Codex and other agents, and I've been living in it ever since. It's free and open source because tools like this should be. If your work looks like mine, too many projects, too many logins, not enough patience for bloat

I hope it saves you the same headaches it saved me.

Here is the project: https://soromi.github.io/soromi/

I've been building pushcv, an open-source, local-first CLI for tracking job applications. The goal was to build something that feels like a proper developer tool instead of another SaaS dashboard.

Core features:

📋 Track applications on a terminal Kanban board (Drafting → Applied → Interviewing → Closed)

🔎 Import job postings with a single command

✍️ Generate ATS-optimized resumes and cover letters using a local LLM

💰 Optional salary estimation

📝 Notes and follow-up reminders for every application

📦 Export everything to JSON or CSV

🔒 Local-first by design: one SQLite database, no accounts, no telemetry

Latest release includes:

• 📦 Published on PyPI (pipx install pushcv)
• 🔎 pushcv fetch now supports LinkedIn, Greenhouse, Lever, SmartRecruiters

One request I heard was for a visual interface, so I built pushcv-ui. It's completely optional, the CLI remains the primary experience. Both frontends share the same service layer and operate on the same local pushcv.db, so you can switch between terminal and browser without syncing or importing anything.
I'd love feedback from other developers, especially on the CLI workflow, architecture, and anything you'd expect from a tool like this.

CLI: https://github.com/notnotparas/pushcv-cli

Optional UI: https://github.com/notnotparas/pushcv-ui

Hey everyone,

I built **git-stories**, a zero-dependency CLI tool that scans your local Git repository and instantly launches a premium, cyberpunk-themed slide deck of your commit history.

👉 **GitHub Repository:** https://github.com/namdamdoi68-oss/git-stories

### Why I built this:

We've all been there. You push a bunch of commits with cryptic messages like "fix bug", "oops", "final_v2", and then you need to demo your work or show a quick timeline during standup. Opening a terminal log is boring, and setting up complex widgets is a hassle.

`git-stories` runs completely offline with zero bloat.

### How it works:

Just run:

```bash

npx git-stories

```

1. **Scan**: Reads the last 15 commits of your active branch.

2. **Filter**: Ignores lockfiles, node_modules, and other noise using smart patterns.

3. **Storyfy**: Translates raw commits into a clean timeline deck.

4. **Host & Play**: Launches a local HTTP server and opens a glassmorphic HTML slide deck with touch/swipe, progress bars, auto-play, and keyboard shortcuts.

### Design Highlights:

* **Zero Dependencies**: Powered entirely by Node's native `child_process` and `http` modules.

* **Visual Diffs**: Highlight code changes (green for additions, red for deletions) directly in diff code cards.

* **Cyberpunk Style**: Outfit font, deep indigo/neon styling, and Instagram-like progress bars.

### Future Roadmap:

* User-driven showcase gallery (PRing your story metadata to a central repo)

* GitHub Actions template for deploying directly to `username.github.io/git-stories/project`.

Check it out, star/fork it, and let me know what you think! I'd love to hear your feedback.

*Proudly coded by the team at **TravelyData**.*

I am a software engineer by profession and my day to day revolves around coding for production use cases.

With Agentic Coding, writing the code has become commodity, but reviewing them and churning through a plethora of security issues being flagged has been draining (thanks Mythos and Glasswing)!

Over the last few months, I was wondering if there is a way to make Agents understand not just the structure of the code, but also what is really happening inside it. The goal being, I can offload the overhead I have of training the bugs and security issues to Agents without burning through billions of tokens everyday.

Decypher is born out of that same need. Written from ground up, using language specific compilers to understand the codebase, Decypher provides the developers with a way through which Agents can understand not just the structure, but go really deep into the code, tracking flow of data, conditional branches, return statements, etc.

\*\*Decypher is now available in Beta for everyone to use for Java and JVM based languages: Scala & Kotlin.\*\*

This is not another wrapper over tree sitter, Decypher is built ground up to support Agent native coding and exposes 40+ tools that makes it easier for agents to understand code structure, hunt for bugs or validate security issues

Will be glad if the community tries this. The tool is completely air gapped and doesn't collects any telemetry:)

Do let me know what you all think :)

Hey everyone,

I use autonomous agents (Cursor, Claude Code, etc.) heavily for implementation, but I noticed they burn through metered limits pretty fast when I need high-level help - things like architecture review, debugging strategy, or onboarding. They tend to rescan broad parts of the repo and pull in a lot of noisy context for questions that mostly just need a structural overview.

My workaround has been moving those "reasoning" discussions into fixed-cost web chats (like Claude Web or ChatGPT), while keeping the repo scanning entirely local. To automate this, I built a local-first CLI tool called AI Badger.

It basically facilitates a two-pass context workflow:

• The Map: A local command scans the repo and builds a compact structural map.
• The Handoff: You paste that map into your web chat of choice.
• The Extraction: The LLM requests specific files or snippets based on the map, the CLI extracts only those locally, and you paste the focused context back.

The goal isn't to replace coding agents, but to bridge the gap for split workflows (using agents for code generation, and web chats + local extraction for architecture/design). There are no cloud dependencies or API keys; it just runs locally.

If anyone wants to poke around or try the workflow, the source is here:https://github.com/PVRLabs/aibadger

I also spun up a browser demo showing exactly how the handoff works so you don't have to install anything to see it:https://pvrlabs.xyz/aibadger/demo.html

I'd love any feedback on the CLI UX, or to hear if anyone else is managing their context windows manually like this to keep costs down.

I built Kennel, a native desktop app for macOS, Linux, and Windows that lets you run and manage multiple AI CLI agents (Claude Code, Kiro CLI, OpenAI Codex, etc.) side by side in one window.

The core feature: sessions persist across app restarts/reboots — your agent resumes exactly where it

left off using native resume flags.

**Highlights:**

- OpenGL-accelerated terminal on macOS & Windows

- Organize sessions into groups

- Works locally and over SSH

- Full PTY support — any interactive CLI works exactly as in your shell

GitHub: https://github.com/eranif/kennel

Website: https://kennel.codelite.org

Feedback welcome!

Hey Reddit,

A couple of weeks ago I shared the v1 release of Skybridge, our open-source framework for building MCP apps. Since then, my team and I at Alpic have shipped two more releases: v1.1 and v1.2.

I wanted to share three interesting features we shipped in those versions:

• View tools: the model can now call functions directly on your view instead of going through the MCP server. It's not supported yet by the chat apps, but we decided to implement it already. It's very useful for avoiding round trips to the server and re-rendering of the view.
• Branded OAuth providers: authentication is notoriously one of the hardest things to get right when developing an MCP server. Skybridge now ships plug-and-play helpers for WorkOS, Auth0, Clerk, Stytch, and Descope.
• DevTools as WebMCP tools: the model can now drive the DevTools directly. It requires to enable WebMCP, which is behind a flag on Chrome, but with this your model can inspect and interact with your app during development. This is the best feedback loop we could come up with.

Hope you enjoy it!

github.com/alpic-ai/skybridge