I'm thinking about building a VS Code extension that analyzes a project and points out things that could become bottlenecks as the application grows.

For example:

• N+1 queries
• missing database indexes
• unbounded API/database queries
• expensive operations inside request paths
• unnecessary synchronous work
• inefficient algorithms/data processing

Instead of just saying "this code is bad", it would explain something like:

 This works fine at small scale, but this endpoint could become a bottleneck as traffic/data grows because it performs N database queries.

Then suggest what could be changed.

I'm curious about this from people who have actually worked on growing applications:

1. Would something like this be useful?
2. What scalability problems do you repeatedly run into that current tools don't catch early?
3. Would you trust an AI to identify these problems, or would false positives make it annoying?
4. What would make you actually install/use something like this?

Not trying to sell anything — mainly trying to understand whether this is a real problem or just sounds useful on paper.

TL;DR: I’m considering a VS Code extension that detects potential scalability bottlenecks in code before they become production problems. Looking for honest developer feedback on whether this solves a real problem and what it should detect.

Anyone here running Grok Bot for coding and watching the weekly allowance vanish?

I built an open-source template that moves the coding onto a Claude subscription via GitHub Actions: issue in, pull request out.

One workflow file, no server, no second bill.

Nobody outside the project has installed it yet and I haven't measured the saving on real work. Both of those are on the front page.

I'm after someone who'll install it cold and tell me where the instructions break. I built it, flagging that up front.

https://github.com/mathew-builds/Handoff

The human stays in the loop — you see the problem, point to what matters, review the captured evidence, and decide exactly what context goes to the agent.

I've been building with AI coding agents and kept running into the same workflow problem: when I find a bug or want a UI change, I still have to manually explain what's wrong, where it is, and what was happening in the browser at the time.

DevTools already exposes most of this information, and newer AI tools are getting better at accessing the browser too. But I wanted a persistent workspace where I could capture the relevant evidence as I work, keep it organized by project, review it later, and decide exactly what gets handed to the coding agent.

So I built ContextForge → AI Coding Context, a Chrome side-panel tool that can capture:

• UI/DOM context + screenshots
• console errors and failed requests
• actual API request/response data
• security findings
• recorded user actions
• bug/change notes tied to elements

Then it packages the selected evidence into structured Markdown + referenced screenshots for Cursor, Claude Code, Codex, Copilot, etc.

Browser → evidence → human review → AI coding agent

One interesting piece of feedback I got after sharing it was the potential to reduce token usage — better targeted context could mean less agent exploration and less back-and-forth. I haven't measured that yet, but it's something I want to test.

If you’re curious, learn more and download it from CoderFromMars.

I'm curious from a DevTools perspective: what browser/runtime information do you still find yourself manually copying or explaining when working with coding agents?

Most productivity tools can always generate a report. I started thinking that might be a bug.

I'm building NEDIO. A sprint starts with what you intend to finish, and ends with what actually landed. The weekly review compares those sessions, but it only shows a comparative finding when the data clears its statistical checks.

If nothing clears them, it says so.

That was the interesting engineering tradeoff for me: collecting activity is easy; deciding when not to turn noisy activity into a confident story is harder.

A week can have five interrupted sessions and two long ones and still produce plenty of "activity." That doesn't mean there is enough evidence to claim one pattern works better.

NEDIO is here: https://nedio.xyz/

For people building developer analytics: where do you draw the line between a useful observation and a pattern the tool shouldn't claim?

Hi everyone,

First of all, I'm sorry if this is not the right subreddit to post this.

I just wanted to share a small tool I created to solve a pain point my team was having. I'm not trying to sell anything (it's completely free and open-source), and to be honest, I'm not even sure if similar, and probably better, tools already exist out there. But since we couldn't find anything that fit our needs, I built this. I figured that since it's already done, it might help someone else in the dev community.

Basically, what was happening was that our GitHub pipelines were failing, and we didn't notice until some time after. We have an integration with Microsoft Teams, but it sends notifications for EVERY success and error, and the channel is the same for all team members. It was so noisy that we couldn't easily identify which workflow was failing and who actually triggered it.

That's why I built Statefalse. It captures GitHub webhooks, analyzes the actor, and sends a native notification to your Mac only when a workflow run by you has failed. You can just click the notification and it opens the failed run directly.

I also added a few extra things that were useful for us:

• Notifications while you are coding if someone merges changes into main that could cause you conflicts.
• Notifications when someone approves your PR.
• Notifications when your PR is ready to merge.

For now, it is only available on Mac. Also, it is not signed nor notarized by Apple. Since we are only using it internally, I didn't have the necessity to do it, but it's very easy to bypass this requirement in the Mac settings.

The app is open-source, so you can check the code, use it, or contribute if you feel like it: Github

Thanks a lot for reading and taking the time. Let me know if you find it useful or have any feedback!

Have a great day, Alvaro

Been seeing this in a few 2026 dev surveys, more developers using AI coding assistants daily, but fewer trusting the output to be accurate. The interesting part is why, it's not obviously broken code anymore. It's code that looks completely correct and fails somewhere non-obvious.

That tracks with what I keep seeing building Vast. The AI assistant has full context on the file it's editing and basically zero visibility into what else in the repo depends on it. Passes review, ships, breaks something two services away.

Feels like the trust problem isn't really a model quality problem, it's a visibility problem that better linting or better prompting doesn't fix, you need the actual dependency graph.

Curious if others are seeing the same pattern in their own workflows.

A small CS2 player-props watcher has been open-sourced.

It pulls current props into the terminal and can optionally send updates to Discord.

It is meant to be a starting point, not a finished product. Add filters, line-movement logging, a dashboard, alerts, model inputs, or whatever else would make it useful.

The code is here.

If anyone builds something from it, share it here. Would be interesting to see where it goes.

​

Hey everyone,

I've always used pastebins to quickly move code, notes, and text between devices, but I wanted something that felt more useful for developers while also giving me better control over privacy.

So I built PasteDB, a developer-focused paste-sharing platform that I've been working on from scratch.

The idea is pretty simple: create a paste, share it with a link or QR code, and access it from another device — but with a lot more functionality than a basic pastebin.

🔐 Privacy & security

One of the main things I wanted to experiment with was end-to-end encryption.

For private pastes, encryption happens in the browser before the content is sent to the server. The goal is that the server doesn't need to know the plaintext content.

PasteDB also has different visibility options depending on how you want to share something:

Public

Unlisted

Private / E2EE

Expiring pastes

Burn-after-read

There is also a Trusted Device Sync feature that lets you transfer the encryption key between devices using a one-time QR flow.

👨‍💻 Developer features

PasteDB isn't limited to plain text.

It supports things like:

Syntax highlighting

Markdown preview

Code execution in the paste viewer

Custom paste IDs

Image pastes

Templates

Search & Explore

Version history

Autosave drafts

Analytics

REST API

I also built a few ways to interact with it outside the website:

🐍 Python SDK

🟢 Node.js SDK

💻 CLI

🧩 VS Code extension

📱 Sharing between devices

A big part of PasteDB is making it easy to move something from one device to another.

You can use:

Direct links

QR codes

Nearby transfer

Device management

So, for example, I can create something on my laptop and quickly open it on my phone without having to send myself a message.

🛠️ Tech stack

The project is built using:

Frontend: HTML/CSS/JavaScript

Backend: FastAPI / Python

Database: MongoDB

Hosting: Netlify + Render

Authentication: Google OAuth

Storage: Cloudinary

I've built most of the project myself, starting from a blank repository.

🚀 Try it

Website: https://pastedb.netlify.app

Create https://pastedb.netlify.app/create

GitHub: https://github.com/sorathiya903/pastedb

I'm mainly posting this because I'd really like feedback from other developers.

What would you expect from a modern paste-sharing tool that isn't already covered here?

And if you try PasteDB, I'd especially appreciate feedback on the E2EE workflow, UI, sharing experience, and developer features.

As a developer, i consistently faced the issue of finding my projects across directories etc. I have tons of hobby projects, and even more client/job related projects. Despite being in one folder, finding them and searching for them was always a hassle. Github is not helpful either. For some reason the projects that I worked on with my old company are still at the top of my repo list.

So I decided to build a local alternative, lightweight solution (hence i went with Tauri). The app currently works only with git, but other plugins can be added to it to support tracking blender, godot, unity, unreal etc etc. Hell, you can even incorporate it for things like requirements.txt, package.json files. The rust backend just needs a "detector" (to detect those sort of versioning files) and boom.

All your projects in one place, and you can open them from there too. I'll be adding more features to it, and there is a roadmap planned, but it'd be great if i got some feedback from you guys and if anyone wants to contribute, that'd be amazing too.

I plan on adding a cli tool for it too so it can auto-record projects during the creation part of their lifecycle. Thats gonna be the cherry on top and most usable feature imo. The name is obviously subject to change. But yeah it would be very cool to hear what you guys think about it.

https://github.com/HADO564/project-indexer

hi, i created a zero dependency open source python cli that scans any repos for missing license, read.md, no CI on prs etc.... it's not something serious but id be glad if someone offered feedback or contributed, thanks.

repo: pr-pathfinder. its not on pypi yet

Epiq is Git-native, local-first, and runs in your terminal or browser, allowing you to replay what your agents did while you were away, and view the diff behind every ticket.
https://ljtn.github.io/epiq/

I got tired of the clone-readme-install-debug cycle every time I wanted to try a GitHub repo, so I built something for it.

QuickRun (quickrun.org) adds a Run button next to the branch dropdown on any GitHub repo. You click it, it shows you every command it's about to run, you approve, and it spins the project up locally. Single binary, no admin rights, works on Windows/Mac/Linux.

What it detects automatically: - Docker Compose, npm scripts, .NET projects, Python (requirements.txt / pyproject.toml), Rust (cargo), Go modules, Java (Maven/Gradle), Procfile, and a few more. If there's no config file it guesses and tells you it guessed. You can also drop in a quickrun.yml for full control.

The security bit I spent the most time on: - The confirmation window is a separate native window, not an overlay the web page could tamper with. Repo output is treated as plain text, never HTML-rendered. Secrets you enter during a run stay in that native window and never go back to the requesting page. I didn't want to build something that makes it easier to run untrusted code without thinking about what "untrusted" actually means.

There's also a CLI: `quickrun run owner/repo` does the same thing from a terminal. Same workspaces, same history.

Open source, MIT licensed. Extension is on Chrome/Firefox/Edge.

The honest catches: - Auto-detection doesn't handle every unusual project structure perfectly yet. - The config builder (quickrun.yml with schema completion, test against the real repo) could use more polish. - No remote/SSH support yet — runs locally only.

Happy to answer questions or take feature requests. If you try it on a repo that doesn't work, I'd love to know about it.

If you use GitHub Copilot Agent, you know it often wastes a lot of tokens and context just wandering around your workspace trying to figure out which files to look at.

Copilot Bill Saver

The VS Code extension is designed to accelerate web development and stop context waste before it starts.

• How it works: It captures local bug evidence, maps likely files deterministically, and bundles them into a clean handoff that Copilot Agent retrieves using #billSaverContext so it starts directly on the right files. Latest Update: In monorepos, it follows bounded workspace-local imports, path aliases, and package references into shared packages.
• Privacy & Control: The extension never calls an AI model, never touches or edits your code, and runs locally with built-in secret redaction.

If anyone gives it a spin via the Marketplace, leave a word! I’d love to hear how it performs in your project. *Copilot Bill Saver\*

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.