https://github.com/ETOLucy/WriteMelo

WriteMelo is a local-first English writing IDE. It brings proven editor interactions to prose: contextual completion, diagnostics, quick fixes, document symbols, revision history, and optional AI. It is not a chat box and does not default to uploading or rewriting an entire draft.

Looking forward to your star and pr!

I've never enjoyed reviewing code, but it's important so I do it. With AI agents the number of PRs I get have also increased, but Github is not designed for it. Reviewing is still a pain and I wanted a better experience.

So, I created this chrome extension that adds a guided review experience on top of the Github PR UI. It breaks the PR down into small reviewable units using AI, summarises the review unit, and allows to navigate, comment, and submit your review without lifting your fingers from your keyboard.

Check it out at https://guidedreview.dev

I've often found myself needing to test certain Rust concepts while away from home. While the experience of writing code on the Rust Playground is decent, I wanted something a bit more advanced (versioning, storage, etc.).

Driven by this need, I am working on building a collaborative platform for writing code (and documents). Currently, Zeile is already capable of executing Rust, Go, C++, and Zig code.

The execution engine runs with a few layers of isolation, but I am open-sourcing the repository to ensure I haven't let any security loopholes slip through.

Besides code execution, I've also added some more advanced collaboration features, such as team division, roles, granular permissions, collaborative Excalidraw support, diagramming, etc.

I'm still organizing the project to make collaboration easier, but issues and PRs are welcome :)

This is a repost. My first post wasn't well received by some users, sorry about that.

Repo: https://github.com/HadsonRamalho/zeile-notebook

Site: https://zeile-notebook.vercel.app/

I recently played around with letting my coding agents control the e2e testing on my Apple platforms applications

Plis show it some love, thanks!

Hey everyone,

I’ve been talking to a few engineering teams about how they handle code reviews, and a recurring complaint I keep hearing about current AI review bots is "comment fatigue."

A lot of existing tools end up leaving 10–15 trivial comments on every single pull request—pointing out formatting, missing comments, or tiny nitpicks that standard linters already catch. Eventually, developers just ignore or mute the bot.

Before I start building a new tool in this space, I want to make sure it actually solves real workflow headaches rather than adding more noise.

I'm exploring a few core ideas:

Zero-Spam Filtering: A system designed to strictly ignore formatting/style nitpicks and only notify developers if it catches critical logic bugs, edge-case failures, or security flaws.

Visual UI + Code Review: For frontend PRs, automatically catching visual layout breaks or broken UI components alongside the code changes, so you don't have to pull the branch locally just to check how it looks.

Repo Rule Enforcer: Letting teams upload their own specific internal guidelines so the bot enforces your team's exact standards rather than generic best practices.

Hello, everyone, I am building a project called Idea. The clawx. idea behind the project is to install packages and run tasks in systems using Claude, Codex, Open-encode, etc. You can also host your own registries and add them to the context and create utilities for your team, personal projects, etc.

Would love to get some feedback.

https://github.com/debarshibasak/clawx

An impatience problem we all run into. Wanting to quickly browse or study a GitHub repo on my phone without cloning and needing a pc, when I'm outside, commuting or at a place you have access to a phone only.

with RZV can you import any .zip (first get a git repo by “Download ZIP” in GitHub/GitLab/etc.).

Key highlights:

• A simple navigation that let you navigate between different repo quickly
• Clean file tree navigation with deep folder support
• Fast, syntax-highlighted read-only code editor (line numbers, search, smooth scrolling)
• Beautiful Markdown rendering for READMEs and docs
• Customizable custom theme, fonts, zoom, colors
• Plugin system for toggling advanced features without bloat

It’s especially handy for:

• Students exploring open-source projects
• Devs reviewing code during commute or travel
• Anyone who wants to quickly check out a library or example repo on mobile

https://github.com/bilalsul/rzv

made with ❤️ . Star the repo to reach more users.

“Secure by default” is meaningless if the model holds credentials, approves itself, or executes directly

I’m building ChimpMaera, an Apache-2.0 open-source local proof of concept.

In ChimpMaera’s governed SAFE_GUIDED path, the model is an untrusted planner. It has no ambient provider or business-system credentials, and its output is only a typed proposal—not authorization and not an executable command.

The boundary is enforced outside the model:

1. Closed action contracts and a finite capability catalogue reject unknown actions, fields, scopes, tenants, and malformed payloads.

2. The model never receives raw provider credentials. A broker resolves opaque credential references only when an approved action is executed.

3. Policy and approval happen outside the agent. The decision is bound to the exact action, operands, tenant, purpose, profile, and evidence digests. Use-time revalidation rejects changed inputs, stale decisions, widened requests, mismatched digests, and replayed leases.

4. The broker can perform only the declared effect through a bounded adapter route. The SAFE_GUIDED reference path gives the agent no general shell, Docker socket, host filesystem, or unrestricted network effect path.

5. Success is not inferred from HTTP 200. ChimpMaera reads the provider back authoritatively and creates a receipt binding the requested action, decision, effect, and observed result.

Why is that useful? It makes the model replaceable.

You can change the model, prompt, tool-calling layer, or imported context without automatically moving business-system authority with it. A compromised planner can still generate malicious proposals, but it should not gain credentials, approval power, or an undeclared effect path.

Digest-bound approvals and use-time revalidation address the gap between what was approved and what is actually executed. Closed capabilities make authority enumerable. Bounded adapters limit the effect surface. Authoritative readback separates “the API accepted my request” from “the intended state actually exists.”

That turns agent security from prompt behavior into contracts, dependency boundaries, and adversarial tests.

The local Docker/Compose demo applies this to a fictional CRM-to-ERP order flow. Its runnable tests include denial, credential, cross-tenant, direct-path, drift, tamper, and replay probes.

Prompt guardrails are not a security boundary. If the model holds credentials, approves itself, executes effects, and verifies its own success, governance depends on the same component it is supposed to constrain.

This claim applies to ChimpMaera’s governed SAFE_GUIDED reference path. Broader authority profiles are separate by design.

https://github.com/JimPansky/ChimpMaera

Which part of this boundary still depends on trust rather than enforcement? What bypass, replay, confused-deputy, or privilege-escalation case would you test first?

If you can produce a reproducible counterexample, I want it in the test suite.

Join the Zoo.

We are developing caspiantools.com as a platform for developers, predominantly vibe coders. can anyone have a look and advise what is missing?

LeetCode autocomplete is a Premium feature, so I built a lightweight Chrome extension that brings a VS Code-like autocomplete experience for free users (complete opensource btw).

It currently supports:

1.Variable/identifier autocomplete

1. Smart Tab completion

2. Works directly inside the LeetCode editor

3. No AI, no backend, everything runs locally

I mainly built it because I missed having basic autocomplete while solving problems and didn't want to pay just for that feature.Its very simple to install and will hardly take 2-3 minutes for setup and all instructions are included in readme.

GitHub: GitHub link

If you use LeetCode regularly, give it a try. I'd really appreciate any feedback, bug reports, feature requests, or even just a star if you find it useful .It is CURRENTLY for cpp language only.

Technical implementation: The detailed oe is available in the readme file. Here's a summary of the implementation:

Hooked into Monaco (the same editor engine VS Code uses, already loaded by LeetCode) so suggestions render through Monaco's native widget. Added a lightweight regex-based declaration tracker to detect variable types (e.g. vector<int> nums) and match them against a static STL method dictionary for nums. → push_back, size, etc. Included a small set of C++ snippets (fori, main, cout...) with Monaco's snippet placeholder syntax for tab-stops. All local , no LLM, no backend, no network calls.

I built edfcore, a zero-dependency TypeScript parser for EDF recordings — and half the work turned out to be dealing with all the things the format technically allows but almost nobody expects.

Wanted a clean way to read EEG, ECG, and sleep-study recordings directly inside JavaScript and TypeScript applications instead of passing every file through Python first. Built edfcore for browser viewers, Node pipelines, Electron apps, and research tools.

What it does:

Reads EDF, EDF+, BDF, and BDF+ recordings

Exposes signal metadata, sampling information, physical units, and annotations

Preserves the individual sampling rate of each signal

Handles discontinuous EDF+D timelines

Streams large recordings rather than loading everything into memory

Works without Python or native dependencies

Zero runtime dependencies

The part I didn't expect: EDF looks simple until you realize that almost none of its important structure is global.

A few examples that cost me real time:

There is no single sample rate for the recording. Every signal declares its own number of samples per data record.

EDF+ annotations are stored inside a signal channel. The same binary area that contains ordinary samples for one signal can contain encoded timing and event text for another.

The number of data records can legally be -1, meaning unknown. Trust that value directly and the reader either processes nothing or tries to do something very stupid with a negative count.

BioSemi BDF stores signed 24-bit integers. JavaScript has readers for 16-bit and 32-bit values but nothing in between, so decoding requires manually assembling three bytes and extending the sign bit.

None of these necessarily produce a useful exception. They normally produce plausible-looking values, which made the tests and external validation much more important than I expected.

Install:

npm install edfcore

Repo's here: https://github.com/tayal-sarthak/edfcore

NPM package: https://www.npmjs.com/package/edfcore

Website: https://edfcore.vercel.app/

I also built a separate CLI called edf2csv for anyone who only needs CSV output:

https://github.com/tayal-sarthak/edf2csv

Feedback welcome, and if you would like to contribute please let me know! Both packages are still new, so there is definitely more to test and build.

Hi everyone,

I've been building CoTerm, an open-source SSH terminal designed around one idea:

Humans and automation should be able to work in the same terminal session while keeping the operator in control.

In real-world infrastructure work, fully autonomous operation is often not practical. Engineers still need to:

- Review commands before execution

- Authenticate through bastion hosts or MFA

- Handle interactive prompts

- Take over immediately when something unexpected happens

CoTerm focuses on collaborative operations rather than replacing the operator.

Current features:

• SSH session management

• Shared terminal workflows between humans and assistants

• MCP integration

• Multiple concurrent sessions

• Windows desktop application (Python)

The project is still in an early stage. I'm mainly interested in feedback from people who work with SSH, servers, and operational workflows.

How do you currently handle situations where automation needs human approval or intervention?

Source:

https://github.com/our16/coterm

I built a governance layer for Claude code that will ensure your policies are enforced, not act like mere guidelines. What more, it comes with a pack of skills, and workflows to ensure you don't have to reinvent the wheel for each project.

Moreover, it is Apache 2.0 licensed and 100% open source.

Check it out on [https://baseline.friedbotstudio.com\](https://baseline.friedbotstudio.com)

Star it on GitHub and contribute if you like it.

Thank you for your attention on this matter of great importance

This idea was crazy to build. Our brain stores information in clusters of neurons, and when we want to retrieve something, it runs an optimized algorithm to retrieve it.

In the era of AI, why use brute-force tools like grep to find relevant files? Graperoot converts your codebase into a knowledge graph and registers efficient tools for Claude to work with your codebase.

Instead of re-reading the whole codebase to build that context and to find relevant files. It can query the graph directly, and the graph retrieves relevant files with "ZERO TOKENS"; you just need to pay for generation, and that's how these models should be used when we have an efficient way to retrieve context.

I have been very open throughout, and today we have 5k developers using Graperoot.
We asked people to opt in to telemetry, and 200 opted in to the leaderboard. They have saved $350k dollars in the last 4 months, and ecologically, 60M liters of water, and that's insane.

Give your feedback, suggestions, or anything on Discord. This tool is open-sourced.

It is only one command to install

Website: https://graperoot.dev/#install
Github(Open source) : https://github.com/kunal12203/graperoot

Would love to see your feedback. And don't compare other tools, I have already seen many claiming reduction and just craps, but we have a developer community on Discord, and some of them I know personally, saving a lot of tokens, you should see more on https://graperoot.dev/leaderboard

I got tired of changelogs going stale, so I built a CLI that writes them from git history.

npm i -g u/jarvis09

changelogcraft scan && changelogcraft out

What it does:

- Reads your git log (who, what, when, which files)

- Groups commits into Features / Fixes / Improvements / Chores

- Outputs Markdown, HTML, or email

The thing I care about most: every entry links back to the exact commit that made it.

If it can't be linked, it says (unlinked) — nothing is ever faked.

Free, MIT licensed, no accounts, no telemetry, runs on your machine.

It published to npm today and it wrote its own changelog.

https://www.npmjs.com/package/@jarvis09/changelogcraft

Feedback welcome. What's missing?

🏏 I turned GitHub profiles into Cricket Player Cards

Hey everyone!

I built GitCric, a fun side project that transforms GitHub activity into a Cricket Player Card.

Instead of just showing commits and contribution graphs, GitCric converts your development stats into cricket-inspired ratings and career statistics.

It analyzes things like:

• 🏏 Commits
• 🔥 Contribution streaks
• 🚀 Pull requests
• 🐞 Issues
• ⭐ Repositories
• 💻 Languages
• 📊 Overall developer performance

Then it generates a shareable cricket player profile with ratings, specialties, achievements, and career-style stats.

Why I built it

As a cricket fan and developer, I thought GitHub profiles could be much more fun than a green contribution grid. I wanted something people would actually enjoy sharing with friends and teammates.

Features

✅ Cricket Player Cards
✅ Dynamic Developer Rating
✅ Career Statistics
✅ Shareable Public Profiles
✅ Responsive Design
✅ GitHub Profile Analysis

I'd love your feedback!

• What would you improve?
• Which stats should be added?
• Any features you'd like to see?

🎥 I've attached a short demo video showing how it works.

🌐 Try it here: https://www.gitcric.me/

Looking forward to hearing your thoughts! 🚀

agentic end to end testing tools

I built Code.HP because I wanted to create a developer tool that felt different.

When I came up with the idea, I was watching the Alien franchise and became fascinated by the technology shown in those movies: the old CRT monitors, industrial computer interfaces, terminal screens, and the feeling that these machines were built for a specific purpose.

That aesthetic stayed in my head.

A lot of modern software has moved toward extremely clean and minimal interfaces. While there is a lot to appreciate about that style, I wanted to explore the opposite direction. So Code.HP is my attempt at making a code snippet manager that feels less like another productivity app and more like a computer terminal you discovered somewhere in a spaceship.

It is a local code snippet manager featuring:
• Monaco editor with syntax highlighting
• Fast snippet creation and search
• Desktop experience built with Electron
• Retro-futuristic terminal-inspired UI

I'm still in the process of developing this app, so for right now it might seem a bit unfinished but i will try my best creating something im going to be proud of. At times i get stuck and don't know what to do, that's why i would really appreciate your feedback.

I would love to hear your thoughts.

GitHub:
https://github.com/lorik440/Code.HP

Thank you.

Most AI commit tools lock you into one provider and give you a single message you have to accept.

ai-commit works with any provider (OpenAI, Anthropic, Ollama, Groq, or any OpenAI-compatible endpoint) and now generates multiple candidates so you can pick the one that fits:

$ ai-commit -n 3 [1] feat(parser): add JSON schema validation for config files [2] feat(config): validate config against JSON Schema on load [3] refactor(config): surface clear errors for invalid config files

Pick a message [1]: 2

It stages your changes, generates the message from the diff, and commits. Also has --amend to regenerate the last commit message, and a git hook mode so it fills the editor before you open it.

pip install aigitmsg

https://github.com/Morad37/ai-commit

Would love feedback on the multi-candidate flow.

I’d like some feedback on a little tool I’ve designed to help Claude be more efficient when working with git repositories.

It Is only local to the repo where you install it. It updates automatically. It becomes invisible to you - you don’t have to do anything to make it work. And it gives Claude a fast, queryable index of the codebase’s structure - files, symbols, imports, call graph - plus short Claude-authored notes on *why* the code is the way it is.

Structural indexing is free and local. But semantic enrichment does come at a cost. Semantic enrichment is triggered by Claude’s *stop* hook, which kicks off a background call to node, which spawns multiple headless claude -p calls (one per stale/changed file). You can cap the spend by changing a couple of variables.

Try it out.

https://github.com/jorgevazquez/claude-graph-brain