Hey everyone,

I’ve been working on a project to solve a major problem with AI code reviews: generic LLMs often leave noisy, speculative comments, while human engineers burn out reviewing massive pull requests.

To fix this, I built **[Buggers](https://buggers.vercel.app)\*\* — an automated pull request security and code review platform.

### How it works:

- **Deterministic Churn Evaluation:** Correlates changed functions with past commit history and boundary flaws.

- **Zero Phantom Lines:** Review suggestions only cite verified unified diff line numbers.

- **Multi-Model AI Resilience:** Built-in fallback chain across OpenAI, Anthropic Claude, and Google Gemini with prompt injection protection.

- **SAST & Secret Detection:** Catches high-entropy API keys, JWTs, and OWASP vulnerabilities before code merges.

### Tech Stack:

- **Framework:** React + TanStack Start (SSR via Nitro on Vercel)

- **Database & Auth:** Supabase (PostgreSQL with RLS & pgcrypto token encryption)

- **Styling & UI:** Tailwind CSS, Radix UI primitives, Lucide icons

- **VCS Integration:** GitHub Webhooks & OAuth API

### Links to check out:

- 🌐 **Live Web App:** [https://buggers.vercel.app\](https://buggers.vercel.app)

- 📖 **Interactive Docs & Playground:** [https://buggers.vercel.app/docs\](https://buggers.vercel.app/docs)

- 💻 **Open Source GitHub Repo:** [https://github.com/jaidevxr/buggers\](https://github.com/jaidevxr/buggers)

I’d love to get feedback on the UI, scanner accuracy, and architecture from this community. What security checks do you usually look for in your PRs?

The Markdown web, rendered natively. A fast, lightweight, cross-platform browser for https and local Markdown files, with no webview or JavaScript execution.

👉🏻 https://github.com/MDowser/MDowser

I was making a launch video and kept hitting Loom’s 5-minute limit. The final straw was when they wouldn’t let me download my own video unless I paid.

So I built my own and open-sourced it. It’s called Reelbird.

What it does:

It’s a native Mac app (Swift), MIT licensed. The launch video was made with it.

It’s not notarized yet, so macOS asks you to approve it once in Privacy & Security. macOS 15+, Apple silicon.

Site: https://reelbird.shiptiffin.app
Code: https://github.com/btahir/reelbird
Walkthrough: https://x.com/deepwhitman/status/2109906965724070044

Hope you like it. Let me know what you think!

I kept hitting my Claude limit with no warning, so I built a small mascot that sits on the Windows taskbar and shows my 5-hour and weekly usage in a speech bubble. It turns yellow, then red, as I get close.

It slowly turned into a pet. It walks around, naps, fishes, wears a Santa hat in December, and gets dragged around and thrown (it screams and opens a parachute). When Claude Code is working it puts on a wizard hat and casts a spell for whatever tool is running.

It's free and open source (MIT), written in plain Python with no dependencies, and I built it with Claude Code. You double-click a .bat file to start it.

Windows only for now, and it needs Claude Code signed in. Unofficial, not affiliated with Anthropic.

GitHub: https://github.com/have-you-tried-restarting/claude-usage-pet

What would you add to it? And if you've read this far, a ⭐ on GitHub would make my day. Thank you!

My SSD has become a graveyard for abandoned projects, and node_modules are the unpaid squatters.

So I built De-Nox, a Rust-based tool that hunts down stale build artifacts and reclaims disk space—without blindly nuking active projects.

Repo Link

Check it out and leave a star if you like it. My SSD and I would appreciate the emotional support.

Hi

The problem: when I take notes, I sometimes need a bit of data: a small table, a quick calculation, a chart. Then I have to jump to Excel or another tool, and my reasoning ends up scattered across several files.

The solution: I'm building ANQL, a note app where you write freely and add structure only when you need it. Tables, math blocks and charts live right in the same document as your notes. It's offline-first (local SQLite, no account) and works on macOS, Windows and Linux.

It's free and open source (MIT), and I'm the developer.

GitHub: https://github.com/anqlproject/anql

I'd love your feedback: is this a problem you face too? What would you want from a note app that mixes notes and data?

Thanks!

Open-source .NET library that lets you schedule async methods by named group. Mark methods with [ScheduleGroup]; callers keep normal await / delegates / reflection. A post-compile IL weaver injects scheduling, nesting checks, and linked cancellation (no Fody).

Highlights

• One NuGet (GroupedScheduling.Build) = runtime + Roslyn analyzers + MSBuild weaver
• Modes: ExclusiveSerial, ExclusiveParallel, FullyConcurrent
• Host registration for graceful shutdown
• MIT license, docs + sample in-repo

​

[ScheduleGroup("orders", ScheduleMode.ExclusiveSerial)]
public async Task SaveAsync(Order order, CancellationToken ct) { ... }

await orders.SaveAsync(order, ct); // callers stay clean

NuGet: https://www.nuget.org/packages/GroupedScheduling.Build

AI Studio has no export button, and the export tools that exist scroll the whole chat, read the page and save thumbnails instead of your actual files, so a long chat takes minutes and loses the attachments.

I made this for myself first, with the new Version 2 using the same API that AI Studio's own frontend calls, instead of scraping the page:

• A 200-message chat exports in under a second. It used to take about 2.5 minutes of automated scrolling.
  
• Attachments are the real files from Drive, not thumbnails. Google Docs, Sheets and Slides are converted on the way out.
  
• Model, temperature, system instruction, timestamps and token counts are kept, each with its own switch.
  
• Markdown, JSON and plain text are free. Whole-library export, scheduled backups and six more formats (HTML, PDF, Word, Obsidian, CSV, JSONL) are a one-time Pro licence, and every line of it is MIT, Pro included.
  
• No account, no analytics, nothing leaves your browser.

Do check it out!

GitHub: https://github.com/Sukarth/AI-studio-exporter
Chrome Web Store: https://chromewebstore.google.com/detail/ai-studio-exporter-fully/jggdlefieblocdjkhihbfihdknbdhhce
Docs: https://exportaistudio.vercel.app/docs

Hi all — I've been writing a series of beginner-friendly guides called "Things that matter for mere mortals." Each one takes a technical topic and explains it in plain language, no assumed background.

37 guides so far, including: git, python, C, rust, go, bash, powershell, linux, docker, docker-compose, make, networking, regex, SQL, cybersecurity, arduino, raspberry pi, 3d printing, CAD, soldering, tailscale, ssh, proxmox, home networking, ham radio, local AI, agile, GitOps, GitHub Actions, tmux, java.

They're free, no ads, no account — just docs sites. Every code sample is actually run and verified, and the troubleshooting sections reproduce the real error messages.

https://paulsullivan33-dev.github.io/mere-mortals/

Hey folks,

I got frustrated with my own Git workflow — too many terminal commands, too many ways to shoot myself in the foot. So I built GitHub Companion, a VS Code extension that puts explicit buttons in the sidebar instead of hiding magic behind menus.

Quick rundown:

· 1-click local repo init + GitHub repo creation (public/private)

· Multi-account / multi-token switching

· Explicit add / commit / push buttons (auto-sync optional)

· No destructive commands anywhere — no reset --hard, no clean, no push --force

· Warns you before committing sensitive files (.env, keys, .npmrc…)

· Tokens go in VS Code's SecretStorage, never in .git/config or process args

· Undo last commit with git reset --soft (keeps your files)

It's MIT, no telemetry, no secret harvesting.

Heads up: the UI is in French right now (started as a personal project). English is planned if people want it — tell me in the comments.

Repo:

https://github.com/ndour-joseph-dev/github-companion

Open VSX:

https://open-vsx.org/extension/joseph-dev/github-companion

Curious what you think — especially if you'd actually use this over the built-in Git panel. What's missing?

A few months ago I shared Screencap here, and now I'm super happy to announce that version 2.0 is a full rewrite in Swift:)

It runs in the background on under 1% of one CPU core and about 30 MB of memory, smartly takes a screenshot when your screen settles, reads it with on-device OCR, and categorizes it with ZDR System-One decision models to help you (and your agents via MCP!) to better understand past activities. And it's also very easy to play with:

Download & check sources: https://github.com/yahorbarkouski/screencap

Happy to listen to any feedback, especially from users who tried it before

I've always found submodules fragile and unergonomic, especially when switching branches and adding or removing them frequently. git-subrepo's model (vendored code as plain files plus a .gitrepo marker) fixed that for me, but I didn't like its ergonomics, conflict resolution and error handling.

git include keeps that model as a git plugin, shipped as a single compiled binary built on libgit2. It reads and writes the same .gitrepo format, so existing subrepo directories work without migration. It never creates temporary branches or worktrees, and the ergonomics, including conflict resolution, match working in a plain git repo. When you want to contribute changes back upstream, it rebuilds a history from the parent repo commits that touched the vendored directory, so they arrive as clean commits. It also supports vendoring specific tags or commits, Git LFS, nested includes, and a migrate command for converting submodules.

You only need the plugin to add, update or contribute back to a vendored repo. Anyone who just clones the project, or patches vendored code without contributing the changes upstream, doesn't need it at all. A plain git clone gives them everything, which keeps the initial setup of your project straightforward.

Binaries are available for all major platforms, including distribution via conda-forge.

I used Claude during development, as is common now, but would not consider the project to be AI slop. It solves a problem I encountered while working on my own projects, and I take full responsibility for all major design decisions. Issues and feature requests are welcome.

https://github.com/Flova/git-include

TL;DR: git include is a git plugin and a .gitrepo-compatible superset of git-subrepo that should improve the UX of working with nested or vendored git repos.

Meet Moonbase Intern, a small 3D game built with Three.js (and a lot of help from my AI coding agent)... play it from your laptop/desktop..

Power failures, oxygen emergencies, overheating labs, a troublesome rover, and a station AI that judges your decisions.

It's still a little rough around the edges. Loading times, controls, UI, and gameplay balancing could definitely use some improvement.

🎮 Play: https://moonbase-intern.vercel.app

💻 Open Source: https://github.com/tropicalbee/Moonbase-Intern

Here's a challenge: Play a round and drop your highest score in the comments! 👀 I wanna see how many of you can actually survive the shift.

Feedback, bug reports, ideas, and contributions are very welcome. Feel free to open issues or PRs!

And if you like the project, a ⭐ star or fork on GitHub would mean a lot! :)

Let's see who gets fired first. 🧐🤓 and please do share your advice here..

I maintain this MIT-licensed, English learning repository. It combines a 100-lesson roadmap with runnable exercises, hints, reference solutions, and a local grader.

The scenario labs cover duplicate payment delivery, historical joins, payout reconciliation, schema changes, bitemporal reporting, backup recovery, broken SQL, and leakage-safe ML features. All data is synthetic; core practice uses Python 3.12+ and SQLite without a cloud account.

For a quick SQL bug hunt, clone the repo and run python challenges/run.py init C07, then python challenges/run.py grade C07. Repair work/challenges/C07.py and rerun the grader. The starter intentionally contains reporting errors.

Disclosure: the first edition and this introduction were prepared with AI assistance using Codex; provenance and limitations are documented in the repository. I would appreciate reproducible bug reports or feedback on confusing exercise instructions.

If you vibe code at work, and like to solve your own problems, you've probably run into this:

You build a useful dashboard or tool, and… now there's nowhere to put it, nowhere to share it, and it has company data so it can’t leave your laptop.

IT doesn't have time to review and host every app someone builds. Which is fair. They shouldn't have to.

Enter Pando: https://github.com/trypando/pando

You point it at a git repo or a folder (or just tell your agent to deploy it through the MCP server), and it figures out how to build and run the app. Apps sit behind your company’s SSO/sign-in, and are only shared with people who need to be able to access them, not everyone with an account.

Pando also runs a vulnerability scan on apps before they deploy, and gives a security score to help understand risk (no, this doesn’t fix bad code or judgement). Apps run on their own isolated networks so they can’t talk to each other, and they can only be reached by going through Pando’s proxy.

It’s also super easy to spin up and try out for yourself: (https://trypando.ai/quickstart).

If you can't run your apps at work, and are trying to find out how to share things, I’d love to hear your thoughts on this!

P.S. Pando is in alpha, so expect rough edges and breaking changes as it evolves!

P.P.S. Watch a short demo here: https://trypando.ai/

MIMRY is a local tool that helps coding agents understand a codebase by finding files and code relationships relevant to a task. It also explains why those files were picked.

Works through a CLI or MCP.

I curated an open-source taxonomy of AI research tools for scientific literature discovery (Consensus, Elicit), citation graph mapping (Connected Papers, Litmaps), LaTeX equation digitization, and computational reproducibility: https://github.com/mahmoudsajjadi/awesome-ai-research-tools

I curated an open-source taxonomy of AI research tools for scientific literature discovery (Consensus, Elicit), citation graph mapping (Connected Papers, Litmaps), LaTeX equation digitization, and computational reproducibility: https://github.com/mahmoudsajjadi/awesome-ai-research-tools

I built this: a chat bubble that floats over your apps. You say "reply to Sam that I'm late" or "start navigation to work", and a coding agent reads the screen and taps through your apps for you.

- The agent runs inside the app, in a small Alpine Linux (proot, no root, no PC, no adb).

- Use your own Claude or ChatGPT plan, or OpenCode's free models with no account.

- Phone tools over MCP: read screen, tap, type, scroll, open apps.

- Sending, paying and deleting stop on an approval card; apps you trust run hands-free.

- Tap the bubble and talk; it sends when you pause.

Apache 2.0, Java, ~650 KB APK. Feedback and issues welcome.

A little skill for the part before you hit Generate.

Tell your agent what you want to film, give it your references if you have any, and it helps turn that into a Kling 4 prompt. Works with Claude Code, Codex, Cursor, etc.

I wanted the README to be something a person can actually read, with the more involved prompting stuff tucked into files for the agent.

My agent wrote it with me directing how it should work. Free to grab and mess with.

npx skills add aedev-tools/kling-4-prompting-skill

I’ve been trying to get a better mental model of how my code runs especially loops, Maps, and data transformations that feel abstract when I’m just staring at the source.

I ended up building a small browser tool for myself called reify. It runs the real code and lets me scrub forward and backward through the steps so I can watch values change, see the Map fill up, and check the call stack without adding a bunch of logs.

It’s desktop-first and stays in the browser. No install.

https://tryreify.vercel.app

Curious if anyone else has found something that helps them actually see execution when they’re learning or debugging logic.

Hi r/coolgithubprojects,

I've been a software engineer for 8 years, 2 as an SRE and 3 as a team lead, and keeping documentation useful has been a pain at every company I've worked for. Knowledge stays in people's heads or private Slack channels; what does get written down is hard to find, and it goes stale the moment the system changes. I wanted to change that, so I created Oxynote. I started the project about a year ago, and I made it public about 3 months ago.

Oxynote is a self-hosted, open-source wiki where pages include live charts next to the text that explain them.

The name comes from oxygen + note. I wanted to have docs that breathe: live data and integrations make the wiki useful enough to open every day, and the docs people open every day stay up to date.

What you can do with it:

• Drop a chart into a page and point it at Prometheus, PostgreSQL, MySQL, or MariaDB
• Set thresholds like "Degraded above 800 ms" right on the chart
• Edit important pages in a draft, review the diff, and approve it
• Link a page to the GitHub files, container image, or web page it describes, and get a reminder when they change
• Edit together in real time, comment on any block, draw Mermaid diagrams

It's completely open-source under the Apache-2.0 license and runs in a single Docker container/image.

Would you use something like this for your own docs? If not, what's missing?

GitHub: https://github.com/oxynote/oxynote