5 NEW Vibe Coding Repos You Haven't Heard of Yet

Overview

The video highlights 5 lesser-known GitHub/Open-source “vibe coding” / AI dev tools. Each tool is demonstrated as part of a broader workflow: understanding system architecture, preventing over-engineering, improving code/token efficiency, accelerating idea capture, and security auditing for skill libraries.

---

1) draw.io CLI / “draw.io skill” — architecture diagrams from your repo

Problem addressed

Vibe coding can leave non-engineers (and even engineers) unsure of what was built and how components connect, which makes debugging improvements rely on the model instead of real system understanding.

What it does

• Uses a draw.io command-line interface to generate editable architecture diagrams from the codebase.
• Accepts natural language prompts (e.g., “visualize layers/services/repo architecture”).
• Example breakdown shown:
  • Presentation layer: mobile/web/admin UI surfaces, UI state, overlays, icons/badges.
  • Front-end state management: interfaces between presentation and downstream logic.
  • Service layer: business logic, including natural-language to action mapping (e.g., “Log me my chicken and rice bowl” → search/recipe functions).
  • Database layer: food entries, recipes, macro targets, etc.
  • Edge/external functions:
    • PostHog for product events
    • OpenAI for chat completions

How it’s used in practice

• Helps target debugging/refactors to the most likely area (e.g., parser/resolver layer first, not telemetry/analytics).
• Acts as a learning loop: the model goes as far as your understanding, and diagrams help you build that understanding.

---

2) Ponytail — reduce over-engineering (simplify implementations)

Problem addressed

AI coding tools tend to over-engineer, introducing unnecessary abstractions and complexity.

What it does

• Installed as a plugin/marketplace tool.
• Provides commands:
  • ponytail: implementation assistance (simplification while coding)
  • audit: scans code for unnecessary complexity and dead/unused parts
  • Supports outputs in a code review style

Demo findings (example)

• Recommends deleting unused imports/files (e.g., default Expo items not actually used).
• Recommends “shrink down” duplicated components (e.g., multiple error-strip components differing only by copy/color/handler → replace with one configurable component).
• Uses ideas like YAGNI (“you ain’t gonna need it”) to avoid future/non-real requirements.

Key theme

Produce simpler implementations by moving from verbose/duplicative code to concise patterns.

---

3) Handy — free/open-source voice-to-prompt assistant (WhisperFlow alternative)

Problem addressed

Text typing limits context throughput; voice can capture more intent faster.

What it does

• Free + open-source option similar to WhisperFlow, but with less functionality.
• Installation options:
  • Homebrew or download from the website; platform-specific.
• Model selection based on speed vs accuracy:
  • Mentions options like “Parakeet” (faster) and Whisper large (slower, more accurate).
• Demo workflow:
  • Use “command spacebar” to start speaking and generate transcription for a prompt.
• Difference vs WhisperFlow:
  • WhisperFlow may remove filler words; Handy is presented as “good enough” for language-model prompting.

---

4) Improve — codebase auditor focused on reducing unnecessary LLM calls

Problem addressed

AI apps often waste tokens by calling LLMs when deterministic logic would work.

What it does

• Runs an “improve” codebase audit targeted at language model call effectiveness.
• Example use case:
  • Audits resolver functions that parse user chat input and decide whether to call an LLM agent vs do deterministic resolution (like search/composition).
• Demo result:
  • Finds an optimization opportunity exists only in one function (e.g., recipe composition function), while other places unnecessarily send work to the language model.
  • Reports multiple issues (at least four) where refactoring could reduce LLM usage with relatively low risk/effort.

Workflow emphasis

• The tool builds plans rather than directly applying changes.
• Suggested integration:
  • Create GitHub issues for each recommended change
  • Let agent workflows implement changes
  • Open PRs and review before merge

Why the diagram tool matters here

• draw.io architecture diagrams helped identify where resolver logic lives, enabling a more accurate audit target.

---

5) NVIDIA “Skill Spectre” (skill library scanner) — security auditing for skills

Problem addressed

“Skills”/tool libraries can be an attack surface (supply chain, malicious scripts, unsafe install/update processes).

What it does

• Security scanning toolkit that reviews skill libraries for risky behavior.
• Typical requirements/steps:
  • Clone the scanner repo
  • Install Python
  • Create a virtual environment and install dependencies
  • Run the scan (e.g., via something like skill spector scan with the provided repo URL)

Running mode notes

• Free scans can produce many false positives and may be less usable.
• The demo uses an OpenAI API key for better results.

Demo findings (example repo)

• Marked critical: “do not install.”
• Reported many issues (e.g., 63).
• Two highlighted risk types:
  1. Cookie/session exposure: scripts prompting users to paste cookies → attackers with access can hijack sessions (Twitter/Reddit/etc.).
  2. Remote code execution via unverified install/update scripts: external install script downloaded and piped to the machine → high likelihood of full compromise (supply-chain risk).

Cost mentioned

• Example scan cost ~$5 for that run; smaller repos ~$0.20–$0.30.

---

Main speakers/sources (as inferred from subtitles)

• Primary speaker/host: the narrator demonstrating each tool (name not given in subtitles).
• Referenced external source: CEO of Microsoft (via a tweet; not named explicitly in subtitles).
• Referenced tool creator: Shad CN / Shade CN (developer of the “Improve” tool; pronunciation uncertain per host).
• Referenced organization/tool publisher: NVIDIA (publisher of the “Skill Spectre” scanner).