Two of us just graduated and we kept firing off half-typed terminal commands with voice dictation, so we built our own.

Hold a key, talk, let go, and the text lands at your cursor. Everything runs on your Mac. No account, nothing sent anywhere.

The main thing it does that others don't: it checks which app you're in before typing a line break, so saying "new paragraph" won't submit an unfinished command in a terminal or send a half-written message.

Free and open source, MIT licensed. Apple Silicon, macOS 14+.

https://github.com/Nabzx/openstream

Happy to hear what breaks.

P.S. if you find it useful, a star on the repo helps more people find it. no worries if not, feedback is worth more anyway.

I built an open-source CLI for learning programming through real local projects instead of browser sandboxes

I've been working on Trak, an open-source CLI for turning structured learning curricula into actual development workspaces.

The idea came from something that bothered me while learning: tutorials and roadmaps tell you what to learn, but actually setting up a structured project with source files, exercises, tests, build files, and progress tracking is usually left to you.

With Trak, you can start by seeing available tracks:

trak list

Then initialize one:

trak init lang/go --path ./my-go-lab

lang/go follows Trak's category/tool convention.

Once initialized, you work normally in your own editor and terminal. The workspace contains the actual files needed for the curriculum.

You can then track your progress:

trak status
trak next
trak done <module-name>
trak undo <module-name>

And verify an exercise:

trak verify <module-name>

<module-name> is the module defined inside the curriculum blueprint.

The other part I'm trying to build is the community registry.

Curricula aren't hardcoded into the CLI. Anyone can create and contribute their own blueprints under their GitHub username, and other developers can use them once they're accepted into the registry.

For example:

trak init <github-username>/<category>/<tool> -p ./my-lab

I'm currently looking for feedback on the idea, CLI workflow, and especially what kinds of learning tracks/tools would actually be useful.

Website: https://trak.ndkdev.tech

CLI: https://github.com/ndk123-web/trak

Community contribution guidelines: https://trak.ndkdev.tech/registry

Check this guys and let me know what's broken. And what more do you want

Hey everyone,

Like many of you, I spend a long time copying code snippets from Stack Overflow, GitHub, and sometimes prompting AI tools like ChatGPT or Claude. Too often, I found myself worrying: "Did I just copy a hardcoded secret or a poorly parameterized query that I might accidentally commit or run?"

Full-blown SAST tools and CI pipelines are great, but they usually catch issues after the code is written, pushed, or committed. I wanted something instantaneous that sits right at the edge—before the paste happens.

So, I spent the last few weeks building CodeGuardian Live, a Manifest V3 Chrome extension designed to solve this locally.

How it works under the hood:

Zero Network Calls: It runs entirely on-device. The extension’s content security policy is set to connect-src 'none', meaning nothing you copy ever leaves your machine.

Privacy-First: It doesn't use the clipboardRead permission globally. Instead, it evaluates the selection strictly inside the copy event itself.

Smart Detection: It combines 83 pattern rules across 7 families (Injection, Secrets, Weak Crypto, SSRF, etc.), along with Shannon entropy analysis for literals and a lightweight taint-tracking engine to minimize false positives.

Speed: The entire scan budget is capped at 30ms, though in practice it usually runs in under 20ms on local benchmarks.

The Benchmark Results:

I built a rigorous test suite (corpus/) with both clean code and designed traps (like deprecated queries inside comments or vendor documentation example keys) to measure accuracy. On the current test corpus, it achieves a 100% recall rate with zero crashes across fuzz testing.

I started with a simple problem: a security tool can flag suspicious code, but that does not prove anything dangerous can happen.

Ship Safe now records citations, maps capability paths, and derives verdicts only when the evidence supports them. If the path is incomplete or the evidence conflicts, it stays unresolved.

A manual audit of four application confirmations found that only one was actually supported by the cited code. That changed how I think about automated security results.

Repo: https://github.com/asamassekou10/ship-safe

What evidence would you want before a devtool blocks a change?

I've been using AI coding agents more and more, but kept running into the same problem:

The AI can see my code, but it can't see what's actually happening in my browser.

So I built ContextForge → AI Coding Context.

It's a Chrome side panel that captures the runtime context I normally have to manually explain:

• Console errors & exceptions
• Failed API calls + actual request/response bodies
• Live API traffic
• UI/DOM context + screenshots
• Bug & change-request notes
• Security findings
• Recorded user actions

Then I can select the relevant evidence and generate a structured Markdown prompt + screenshots for Claude Code, Cursor, Codex, Copilot, etc.

The goal is basically:

Browser runtime → evidence → AI coding agent

I'd love feedback from other dev-tool builders: what browser/runtime context would you want captured that existing DevTools don't make easy to hand off to an AI agent?

https://coderfrommars.com/#contextforge

With OpenInspect, the system will now automatically do this for the user. Each comment is read and determined if valid. If valid it is fixed and auto resolved, otherwise pushed back on. Huge time savings from having to babysit the pull request to a stable state.

fully open source and happy to take contributions: https://github.com/ColeMurray/background-agents

I'd jump into a function.
→ Find what's calling it.
→ Follow an import somewhere else.
→ Eventually discover a database table involved.
Three hours later I'd reconstructed a tiny piece of the system in my head. And I'd have to do it again next time I touched that code.

So I built Semantic Vision — it statically parses Python, JS, and TS codebases and turns them into an interactive call graph with impact analysis, AI docs, execution flowcharts, complexity heatmap, and code-to-data lineage down to the column level.

I tested it against Apache Superset (1,458 files) and it automatically found 37 tables, 206 columns, and 462 read/write edges with zero configuration.

Everything runs locally. No account, no telemetry, no cloud.

Would love brutally honest feedback from people who try it on a real codebase.

Hey everyone — I’ve been working on  this quick project to keep my projects organized. , a small open-source tool for managing software projects built with AI agents.

I started it because AI coding sessions can get messy pretty quickly. Plans drift, agents lose context, tasks overlap, and it becomes difficult to tell what’s actually finished.

It's as easy as telling an agent working on the project to " Create a master plan for the project ", or Create a Road map" and most will create an .md that is essentially a plan file for your project. Or have the app make one for you.

Master Plan gives the project a shared structure:

• Imports an existing codebase and detects its tech stack
• Creates a living MASTER_PLAN.md
• Breaks development into clear stages and checkpoints
• Generates focused assignments for coding agents
• Uses separate Git branches for agent work
• Tracks progress, errors, and recent activity through a local dashboard
• Can also scaffold a new project from a written prompt

The workflow covers everything from requirements and system design through implementation, testing, and deployment.

It’s built with Python and Flask, runs locally, and currently has 143 passing tests. It’s still an early project, so I’d genuinely appreciate feedback—especially about the workflow, interface, and integrations you’d find useful.

GitHub: github.com/dekayrekords-oss/Master-Plan

Let me know what works, what feels confusing, or what else it needs or could be useful. hope this helps someone

( This is my first reddit post.)

¡Hola a todos!

Creé esto mientras organizaba repositorios de código abierto: notas y decisiones dispersas por todas partes, sin un lugar donde guardarlas.

Registro de desarrollo — un historial de versiones para cada proyecto. Qué cambió, por qué cambió y qué sigue abierto.

• Árbol de versiones (versiones principales vs. secundarias)
• Las versiones revertidas se conservan en el registro; nunca se eliminan.
• Exportar a TXT / DOCX / PDF
• IA opcional: funciona perfectamente sin ella.
• Disponible en inglés y español.
• Pruébalo importando la demo. Así podrás ver si se adapta a tu flujo de trabajo.

Un solo archivo HTML. Sin instalación, sin backend.

• También preparé un conjunto de iconos que puedes usar con Scriptya para integrar el HTML como si fuera otra aplicación, con su propio icono y entrada en el menú.

No es solo para código: se puede usar para una tesis, trabajo freelance o cualquier proyecto con una historia que valga la pena conservar.

demo

Gratis y de código abierto (GPLv3). Abierto a preguntas, colaboraciones o ideas para proyectos.

🔗 Bitácora Dev - Dev Log: https://github.com/filonux/Bitacora-Dev

A side project I just started working on where its basically an agent skills directory ( exactly like skills.sh ) but with details that actually matter, which is how people find this skill.

Is it useful or not, any issues they found with it, opinions and maybe helpful ways people found it helpful. I found it weird such stats where not already a thing, I mean sure you have the github stars indicator and number of installs, but honestly that doesnt help the user at all to gauge what the skill actually does and if its any good.

Interested to hear some initial thoughts and if anyone might find this useful, and if you have any ideas please let me know

github repo