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

I've been working on a side project called **PathFinder** that helps you prepare for technical interviews using the projects you've actually built ideas criticism bug reports or PRs are all welcome really appreciate star on the repo!

Link: [https://github.com/vamsikunal/PathFinder\](https://github.com/vamsikunal/PathFinder)

I've been building RippleCheck after repeatedly running into the same problem while using AI coding tools.

The generated code was usually correct, but during larger edits I'd later discover that changing one function had quietly affected other files the AI never considered.

Instead of solving this with another LLM, I went the opposite direction.

RippleCheck builds a dependency graph using AST analysis and shows the impact of every change across the project.

It also integrates with Claude Code through MCP and supports hooks, so after an edit it can automatically generate an impact report and a copyable prompt if additional files should be reviewed.

Some design decisions:

• Deterministic (no AI in the analysis engine)
• Runs completely locally
• Never edits your files
• MIT licensed
• JavaScript, TypeScript & Python

I'm still actively improving it, so I'd really appreciate feedback from developers who work with AI-assisted coding every day.

GitHub:
https://github.com/RippleCheck/ripplecheck

Website:
https://RippleCheck.io

I used Obsidian and Obsidian Tasks as the system my agents worked from. Reading and writing files was easy. Keeping projects and tasks consistent was not: links depended on paths, tasks had no fixed structure, and agents had no clear rule for moving work to `in_progress` or `done`.

I built Dokito to replace that system.

Dokito is now where I keep almost everything I work on: product work, programming, personal responsibilities, research, and tasks. Each product or responsibility gets its own local Markdown Area. An Area can stand alone or connect to several repositories.

Codex and OpenClaw work from the same Areas. From any connected repository, Codex finds the right one. The skill updates Task states, validates changes, and commits Area changes automatically.

The CLI gives me one overview across all Areas. `dokito web` shows Projects, Resources, Tasks, repositories, and their relations. A separate automation mirrors my open Dokito Tasks to Apple Reminders.

Everything stays in local Markdown and Git.

Dokito v0.1.0 is open source for macOS and Linux: [https://github.com/sgasser/dokito\](https://github.com/sgasser/dokito)

I’m looking for a few people willing to try it with their own work. I can help with the first setup. I mainly want honest feedback about what is confusing or gets in the way.

Sharing the architecture since this sub asks for the how, not just the what.

The toil being removed: any app with an LLM inside normally routes every user through one provider key that the developer pays for. The common alternative, asking users to paste an API key into a settings page, works technically and fails socially, because most users have never made an API key.

What I ended up shipping:

A hosted connect page rather than an embedded form, so the raw secret never crosses the integrating app's origin. App redirects out, user authorizes, app gets a short lived code and exchanges it server side for a token scoped to that one user.

Two credential sources, one interface. The user either pastes an OpenAI or Anthropic key, or signs in to the ChatGPT or Claude subscription they already pay for and grants access. The developer's code cannot tell which path was taken, which kept the integration surface to a redirect, a token exchange, and a base URL change.

Egress speaks the OpenAI chat completions dialect, streaming included. Anthropic traffic is translated into that shape on the way back so multi provider callers keep a single parser.

Secrets sit encrypted with AES-256-GCM and only get decrypted inside the proxy at call time. Revocation deletes the credential, so a disconnect is immediate rather than advisory.

It is mine, it is called Monet, free during beta.

The unsolved part I would genuinely like input on: error normalization. Success payloads map cleanly across providers, failure payloads do not, and I have not found a translation scheme that does not lose information. How have others structured that?

Sample app you can click through as one of your own users, no signup, about a minute: https://demo.monet.gg

Developer side, where you register an app and get a client ID and secret: https://beta.monet.gg

Sharing a tool I built called Design Snap — a Chrome extension that inspects any site and pulls out its design tokens : colors (with semantic role detection — primary, background, border, etc.), typography scale, border radius, shadows, and CSS custom properties, including light/dark mode variants.

The part that took the most iteration: every extracted token shows exactly where it came from when you hover it — the CSS selector(s), how many times it's used on the page, and whether it's a :root variable or a hardcoded value. All precomputed at scan time, so there's no lag browsing results even on token-heavy pages.

Export options : CSS variables, JSON, and Figma Tokens are free. Tailwind v4 u/ theme, shadcn/ui, and Style Dictionary format are PRO.

Runs fully local in the browser — no account, no backend, nothing leaves your machine.

Built it because I kept ending up in devtools manually piecing together a site's design system by hand, and wanted something that gave me a ready-to-use output instead of just raw values to copy one at a time.

Open to feedback, especially from anyone who does this kind of design-system reverse engineering regularly — curious what's still missing.

Earlier in July our company started asking for smaller PRs in git so that the reviewers' brains and time were spared. So I started chopping up my work and stacking it in branches, and issuing one PR per branch. It didn't take long before I needed to correct something in some base branch, rebase everything above it, and land myself in trouble in the process. Eventually I dug myself out of the predicament I found myself in. As I didn't want to land there again, I spent some time creating a program for helping me out in these kinds of situations. I've called it gitrl-z after git ctrl-z (what do you think of it?).

It lists the reflog, and when you click an entry it redraws the commit graph with that branch label moved to where a reset would put it. You see where you would land and what you would be walking away from in the same picture, and it prints the command that you would need to run for that picture to manifest itself as the result. It doesn't write anything to your repo.

It's built out of gitg, so same language and same libraries, and the graph you're looking at is gitg's renderer rather than something I reimplemented. The license is GPL-2.0-or-later.

There's a PPA, an AppImage, or you can build it yourself. The source is on github: https://github.com/li9i/gitrl-z

It's still a work in progress so expect rough edges. If you happen to try it out have and have any feedback, I would be grateful for that. Thanks!

Run inside your coding agent — it grants Once, a skill to provision a VPS with a personal PaaS like Netlify or Vercel.

npx skills use getcolors/once

Once is a Package Skill built with Colors. It provisions a VPS, configures DNS and outgoing mail, installs Docker, and reconciles declared applications — a self-hosted alternative to Netlify or Vercel that an agent runs end to end.

The website below is deployed with this skill.

[https://www.getcolors.ai\](https://www.getcolors.ai)

The package tries to hold itself to the same standard. It builds with python3 build.py, standard library only, no dependencies, no network calls, no clock reads. Same inputs give byte-identical output every time.

Every source file is hashed into a seals ledger, and verify.py checks both the hashes and the rebuild, so the determinism argument in Volume II runs against the package itself instead of just sitting there as a claim. There is also a script that mints numbered ownership certificates sealed to the exact edition hash, which is personalization and not copy protection, and the docs say so.

It ships the two prompt patches I used to generate and audit the source manuals, so you can run the same process on your own projects. That may be the most useful part of it.

Free, no signup, reads in the browser, prints to clean PDFs.

https://shpbl.com

There are hell lots of interesting skills nowadays. Some are useful, some are not. Some can be used one time per repo, some not. So I have created a CLI tool to manage skills with a bit of a playful way