I've been using Claude Code for a few months and noticed AI agents consistently skip the same things: hardcoded secrets, unbounded retry loops, referencing tools that don't exist, and massive system prompts that blow context windows.

So I built Agent Verifier — an AI agent skill that acts as an automated reviewer which does more than just code review (check the repo for details - more to be added soon).

GitHub Repo: https://github.com/aurite-ai/agent-verifier

Note: Drop a ⭐ if you find it useful to get more updates as we add more features to this repo.

----

2 Steps to use it:

You install it once and say "verify agent" on any of your agent folder in claude code to get a structured report:

----

✅ 8 checks passed | ⚠️ 3 warnings | ❌ 2 issues

❌ Hardcoded API key at config.py:12 → Move to environment variable
❌ Hallucinated tool reference: execute_sql → Tool referenced but not defined
⚠️ Unbounded loop at agent/loop.py:45 → Add MAX_ITERATIONS constant

----

Install to your claude code:

npx skills add aurite-ai/agent-verifier -a claude-code

OR install for all coding agents:

npx skills add aurite-ai/agent-verifier --all

----

Happy to answer questions about how the agent-verifier works.

We have both:
- pattern-matched (reliable), and,
- heuristic (best-effort) tiers, and every finding is tagged so you know the confidence level.

----

Please share your feedback and would love contributors to expand the project!

So I wondered sometimes, how little info we have when we install NPM packages.. so I built revera... its a npm package scorer, but on steroids. It uses a complex sophisticated algorithm (still not perfect, but near-perfect) that nails at ranking NPM packages.. it gives every package a score and the score is determined on criterias such as maintainability, trust, package releases, downloads, much more..

the audit command scans the working directory for

it has the following extra features:

• logging in with github for higher rate limits
• why command for explaining a certain package's score
• doctor for checking if everything is working
• caching system which lives for 24h on local machine
• and a customizable config

It would mean the world to me if you all could try it out and give feedback (bad or good)!

github repo: https://github.com/aaravmaloo/revera

npm package page: https://www.npmjs.com/package/@aaravmaloo/revera

I built safer-dependencies, a security layer for Claude Code that checks packages before AI coding assistants add them to a project. I originally built this for my own workflow, but I’m sharing it publicly in case it’s useful to others using Claude Code.

It runs dependency safety checks for things like known CVEs, typo-squatting, abandoned packages, stale releases, package age/cooldown windows, and PyPI hash-pin integrity.

It currently supports npm, PyPI, RubyGems, Maven, Go, and Rust. Open source to help others.

GitHub: https://github.com/robert-auger/safer-dependencies

Your mouse is slowing you down.

Every time your hand leaves the keyboard, you lose focus.

I switched to a keyboard-only workflow on macOS, and it's surprisingly addictive. The app is made using Swift, and it is created with the help of AI.

Try it yourself:

👉 https://github.com/bhavesh164/mouseless

You'll wonder why you ever reached for a mouse.

Note: This app is made with the help of LLM (AI)

Builders-welcome post with the substance up front (disclosure: I'm the maintainer). OmniRoute is a free, MIT, self-hosted AI gateway — one OpenAI-compatible endpoint over 237 providers — built around two problems: runs dying on a provider 429, and tokens bleeding on tool/log output.

One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.

Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.

Fusion — an ensemble mode for the hard steps. Beyond simple routing, there's a fusion strategy that fans a single prompt out to a panel of different models in parallel and then has a judge model synthesize one best answer (mixture-of-agents, built in). It's cost-aware, so easy turns stay on one fast model and it only fuses when the step is worth it.

A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.

Agent-native — the agent can drive the router itself. There's a built-in MCP server (95 tools across 30 audited scopes, over stdio / SSE / streamable-HTTP), plus A2A (v0.3, JSON-RPC 2.0) support. That means an agent can query providers, switch combos, read its own remaining quota and manage memory through the gateway — not just consume tokens through it.

It's 100% local (zero telemetry, AES-256-GCM at rest), MIT-licensed, has a prompt-injection guard on every LLM route, opt-in memory, and runs on npm, Docker, desktop or your phone via Termux.

For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.

npm install -g omniroute

GitHub: https://github.com/diegosouzapw/OmniRoute · Site: https://omniroute.online

Would value a critique of the routing/compression architecture from this crowd.

What My Project Does

SOAR (Script Optimization and Automation Runtime) is a Python-based automation runtime system that helps manage and run scripts in a more structured way than simply executing standalone .py files.

It provides a lightweight runtime layer where users can:

• Organize scripts into projects
• Run automation tasks through a CLI-style interface
• Generate or scaffold simple project structures
• View basic diagnostics/log output for runs
• Experiment with modular “automation workflows” inside Python

The goal is to make small automation projects easier to manage without needing a full framework.

Target Audience

This project is mainly aimed at:

• Beginner to intermediate Python developers
• People who write lots of small automation scripts
• Developers who want a lightweight alternative to heavier workflow/automation frameworks

It is currently more of an experimental / hobby project than a production-ready tool.

Comparison

Compared to existing tools:

• vs plain Python scripts: SOAR adds structure and centralized execution instead of scattered files
• vs full workflow tools (Airflow, Prefect, etc.): SOAR is much lighter and not designed for large-scale pipelines
• vs CLI frameworks: SOAR focuses more on script organization + runtime behavior rather than just argument parsing

It sits somewhere between a script organizer and a minimal automation runtime.

Source Code

GitHub repository:
https://github.com/ScriptOptimizationAutomationRuntime/latest-version

(Additional resources like tutorials and updates are included in the repo.)

Hey,

I got tired of debugging my AI agents with print() statements so I built PeekAI.

It's a lightweight, framework-agnostic observability tool for Python AI agents. Zero config, no cloud, no account needed.

What it does:

• Auto-instruments OpenAI/Anthropic SDK calls
• Full span-based trace with waterfall view
• Token + cost tracking per span
• Tool call tracking
• Trace replay — re-run any past trace, even swap models to compare cost/quality
• CLI + Web UI, all local SQLite storage

Install in 2 lines:

pip install peekai

import peekai peekai.init() # that's it

It's early (v0.1) and open source (MIT). Would love feedback from anyone building agents — especially multi-agent systems.

GitHub: https://github.com/oussamaKH63/peekai PyPI: https://pypi.org/project/peekai

Hi,

I got tired of copy-pasting the same rules and skills across OpenCode, Cursor, Claude Code, GitHub Copilot, Windsurf, Gemini CLI, etc. So I built Rulepack.

It’s a declarative package manager where each rule/skill/agent is a YAML PKGBUILD descriptor. One source, multiple targets. You can create PKBUILDs manually or with help of your agent.

Quick workflow:

  bin/rulepack build                         # fetch sources & build platform artifacts                                                                                                                        
  bin/rulepack install --target opencode     # deploy with symlink/copy/inject/append                                                                                                                          
  bin/rulepack verify --target opencode      # detect drift                                                                                                                                                    
  bin/rulepack fix --target opencode         # repair drift                                                                                                                                                    
  bin/rulepack bump                          # check upstream git-sourced packages                                                                                                                             

Highlights:
• 14 supported agent platforms (user + project scope)
• Registry-driven translate/transform defaults (data/registry/platforms.yaml)
• Surgical installs, skill-bundle sub-skill selection, marker-based AGENTS.md append
• Upstream version tracking, transaction rollback, SHA256 checksums
• Ruby stdlib-only core, 357 tests, 0 failures

Repo: https://github.com/ozgurulukir/agent-rule-sync

Feedback, bug reports, and new platform/translator contributions are very welcome. If you maintain rules for more than one coding agent, this is the exact itch it scratches.

I'm looking to sell Inspect Mode Pro, a Chrome extension built for developers, designers, and indie hackers who want to inspect websites more efficiently.

The product is fully functional and includes Polar payment integration, making it easy to manage one-time purchases, licenses, and customer access without additional setup.

What it does:

• Inspect fonts, colors, spacing, and UI elements
• Extract website assets and images
• Analyze website design systems
• Faster workflow than digging through DevTools for common tasks

What's included:

• Full source code
• Chrome Web Store listing
• Branding and assets
• Existing user base
• Documentation and deployment instructions

Why I'm selling:
I'm currently focused on other projects and don't have the time to continue growing and marketing this one.

Potential growth opportunities:

• SEO content around web design and development
• YouTube tutorials and demos
• Partnerships with design communities
• Expansion into Firefox and Edge extensions
• Additional premium features for agencies

If you're interested, send me a DM and I'll share details on users, revenue, traffic, tech stack, and asking price.

Happy to answer any questions.

I’m building Rockxy, an open-source native macOS HTTP/HTTPS debugging proxy:

https://github.com/RockxyApp/Rockxy

It’s for developers who need to inspect traffic from real apps, not just browser DevTools: Mac apps, command-line tools, iOS devices, iOS Simulator, HTTP/HTTPS, WebSocket, GraphQL, replay, rewrite/map local, breakpoints, and export/redaction workflows.

I’m not doing a big launch yet. I’m trying to improve the repo and understand what would make developers trust or try a tool like this.

If you have a minute, I’d love feedback on:
- Does the repo explain the product clearly?
- What would stop you from trying it?
- What should be more visible: screenshots, install flow, security model, roadmap, comparison with Proxyman/Charles?
- What issue would you open first?

Repo feedback is very welcome.

hey guys there's this tool which lets you dictate nicely into claude code with technical + cursor terms, great for vibecoding. if you guys want to try, here's the link: github.com/eliasmocik/dum-dictation (we are building it on the side so if you guys like it or don't, please drop feedback would mean a lot ;)

https://imgur.com/a/dum-dictation-w9MIIT7

Hey everyone!

I've always struggled with keeping my HTB notes organized. Copy-pasting machine IPs, tracking what I've rooted, and organizing my write-ups manually in Obsidian/Notion was getting tedious. So, I spent some time building Plethora.

Plethora is a local-first desktop-style web app. You connect your HTB App Token, and it automatically pulls in your Machines and Challenges in the background while you play.

What it does:

• 100% Local & Private: Uses a local SQLite database. Your private write-ups and secrets never touch the cloud.
• Smart Auto-Sync: Tracks your progress and builds a global activity timeline (complete with a GitHub-style hacking heatmap and streak counter).
• Rich Journaling: A dedicated markdown editor with instant auto-save and inline screenshot pasting.
• Command Palette: Press Ctrl+Q to instantly full-text search thousands of your past journals, or let the app automatically extract your past bash/powershell commands (like finding exactly what nmap flags you used 3 months ago).

I just open-sourced it on GitHub and would love for people to test it out, break things, and give me feedback!

GitHub Repo: https://github.com/krishjain-2301/Kri27

To get started, just clone the repo, run npm install, and hit npm run dev.

Let me know what you guys think!

Kiro CLI is powerful for single tasks. KiroEnsemble turns it into an entire development team.

If you use Kiro CLI, you know it's great for single tasks at your desk. But I wanted it to carry a whole feature the way a real developer does:

• plan it
• build it
• test it
• review it
• document it
• and open the PR
• without me driving every keystroke.

So I turned it into a team. A lead agent orchestrates and never writes code itself: a builder writes the code, a validator runs the tests and checks the spec, a reviewer diffs the branch, and a documenter writes the docs

You hand it a ticket or a spec, and it delivers a tested, reviewed, documented, PR-ready change. No babysitting.

This isn't a toy. It's enterprise-grade, used by engineers within a renowned international company.

📊 It runs as a full-stack developer on live enterprise codebase:

in one month, straight from personal session logs (using /record-session custom skill):

- 20+ tickets shipped across 4 repos

- 89% completed clean (18 success, 2 partial, 0 failed)

- Features and bug fixes delivered, with tests, documentation and code review on every run

It picks up a ticket, builds it, tests it, reviews its own diff, documents it, and hands back a PR. That's the job of a full-stack dev, and it does it on real, conventions-heavy enterprise repos.

🏗 It also builds projects from scratch:

Point it at an empty directory and it ships. My portfolio site (https://mmo.sidihub.cloud/) and its AI assistant were built end to end by this team, from spec to deployment.

• ⚙️ Why it holds up where other agent setups fall apart
• 🧠 Real separation of roles, not one model pretending to be five.
• 📋 Spec-driven: requirements, design, and tasks, so it builds what you asked for.
• 🪶 Lean orchestrator: the lead never loads your code, so context stays sharp across long runs.
• 🔁 Self-correcting: bounded retries with a diagnostician pass before giving up.
• 🎫 Process-aware: reads tickets, follows your branch and commit conventions, opens the MR, posts the summary.
• ✍️ Grounded knowledge and context through typed files & can be integrated with obsidian
• 🔒 Safe by default: a guard blocks destructive commands and asks before anything risky.

🛠 How it works

Clone the repo, copy the .kiro setup into your desired repo, and either manually edit the conventions and names to fit your needs & project, or ask kiro to adapt it, 5~ minutes setup.

1. Prepare a Spec or a Plan document for what you want to work on.
2. Start a kiro-cli session -> type `/agent swap team-lead`
3. prompt the team-lead to pickup the spec and start the agentic workflow

NOTE: Agents have pre-chosen models that I personally use, edit the agent configs to change the models to your credit budget.

GitHub Repo: https://github.com/Moifek/kiro-ensemble

Free and open-source (MIT). Clone it, run it on your own project, and tell me where it breaks.

Roadmap: Better logging & Mobile integration

What's the most complex thing you'd trust an agent team to ship for you?

Hey u/few_Map7816 I'll be trying to make this work with your solution :D let's connect !

Spent the weekend building ai-commit - a CLI tool that generates commit messages from your staged diff. The gimmick is it's provider-agnostic: works with OpenAI, Anthropic, Ollama, Groq, whatever you have.

Why this exists: every other AI commit tool locks you into one provider. OpenAI only. Anthropic only. A local Ollama thing. If you switch providers, you switch tools. This one swaps providers in a config line or env var.

Also has a --install-hook flag that sets up a prepare-commit-msg hook.

Install: pip install ai-commit. Source: github.com/mohamedorigami-jpg/ai-commit

Curious what people think. Does provider-agnostic matter to you?