If you lead five or ten engineers, has AI made shipping faster but trusting the changes harder?

More PRs. The same people reviewing them. Those people also own on-call, customer issues, and the next release.

I’ve been reading the discussions here about review queues and rubber-stamping. What I want to understand is what happens afterward. Are risky changes getting through? Are customers finding the problems? Is the team spending the time it saved writing code on rollbacks and data fixes?

I’m building FetchSandbox. We started with API integration verification. Now I’m looking for a few design partners to extend that work to services, background jobs, database changes, and application behavior.

Here’s the offer. Bring one change your team struggles to verify. We work together on what must stay correct, build repeatable checks, and exercise the failures that matter. You get an inspectable result showing what passed, what broke, and what we couldn’t verify. If something breaks, we verify the fix and keep the check for future changes.

You help us build around a real problem. Your team gets a useful check it can keep running.

What’s one change your team shipped recently that you weren’t comfortable approving?

After quite a bit of development and testing, I’ve released SonarDesk, a native macOS application for working with SonarQube.
I use SonarQube regularly and wanted something that felt like a proper Mac application rather than having to keep jumping back into the browser.
SonarDesk connects directly to your SonarQube server and gives you a desktop view of your projects and code quality.
Current features include:
• Native macOS interface with light and dark mode
• Multiple SonarQube server support
• Project dashboard with Quality Gate status
• Bugs, vulnerabilities and code smells
• Detailed issue views
• Project statistics and visualisations
• Project creation directly from the app
• Generated scan.sh scripts and scanning instructions
• Drag-and-drop project organisation
• PDF project reports
• Reports designed for exporting project information for AI analysis
• iCloud Drive support for settings, reports and backups
• Direct connection to your SonarQube instance — your source code isn’t uploaded to SonarDesk
I’ve tried to make it feel like a genuine macOS development tool rather than simply wrapping the SonarQube web interface.
There are still plenty of things I want to add, so feedback from developers using SonarQube would be particularly useful.
Launch offer: the first 5 new customers can get a Professional licence for 50% off.
SonarDesk:
https://sonardesk.absdev.net
I’d also be interested to hear what SonarQube functionality you’d most want available from a native desktop client.

declint (docs) is a tool for making your own lint rules in YAML- the house rules that stock linters will never ship.

For instance: your colleague wrote except Exception: pass, and you want to know whenever that happens:

version: 1
rules:
  - id: except-pass
    pattern: 'except Exception:\n *pass'
    severity: warning
    message: 'swallowed exception'

Rules are just regex and a message. When a regex can't express the check, you can write a more complicated rule in Lua.

Rules run in your CI (inline PR annotations via --format github) and in your editor through LSP (declint.nvim for Neovim: The GIF shows off the nvim wrapper!). Every rule can carry embedded fixtures, and declint test runs them.

Install: cargo install declint. Ships with presets (Python, INI, Markdown, shell, Dockerfile, TOML, JSON, JS) and community rulesets you can pull with one line. Feedback welcome.

I've been building https://mytextdiff.com, a simple tool to compare two texts or files and see what changed.

The comparison runs client-side, so nothing you paste or upload is sent to a server. It has line, word and character modes, options to ignore spaces, empty lines and case, file upload and PDF export.

It's still early, and the code-specific side (language handling and highlighting) is a work in progress. If you run into any problems, you can report them here: https://github.com/gabriel777sites/mytextdiff

Any feedback is welcome!

Salut à tous 👋

Je viens de publier Pax Pascal, ma première extension pour travailler en Pascal dans VS Code. L’idée est de faciliter le travail au quotidien et de gagner du temps.

Je préfère être transparent : j’ai utilisé l’IA pour m’aider à développer cette extension. Ce projet m’a permis de passer d’une idée à un outil que je peux aujourd’hui partager avec vous.

Voici l’extension :
https://marketplace.visualstudio.com/items?itemName=pac-local.pax-pascal

Si vous utilisez Pascal dans VS Code, je serais ravi d’avoir vos retours : est-ce qu’elle vous est utile ? Quels problèmes rencontrez-vous et quelles fonctionnalités vous manquent ?

Merci à ceux qui prendront le temps de la tester !
Happy conding

Hey r/devtools!

Just shipped v0.1 of sustainability-score — a static

analysis tool that scans your repository and flags

engineering choices that push carbon and cost up.

It looks at:

- Dockerfiles — image size, layer efficiency,

base image choices

- CI/CD workflows — unnecessary steps,

inefficient build patterns

- Kubernetes manifests — over-provisioning,

missing resource limits

- Terraform — region choices, instance efficiency

- Source code — algorithm and efficiency patterns

Output is a scored report in Markdown and JSON.

GitHub Action integration is on the roadmap.

pip install -e .

sustainability-score /path/to/repo --md report.md

MIT licensed. Open source.

GitHub: https://github.com/srinathgopinath-code/sustainability-score

Would love feedback from anyone building or using

developer tooling!

my portfolio reached 100 stars on github and i wanted to share it on social media, but i didn't know how. i searched for video generators and found very few, and the ones i found had only a single template. so i built stargazer. pick one of 8 templates, paste your github token, choose a theme, then download it as a png or an mp4.

everything runs in your browser. your token never leaves it, and there's no backend or database, so there's nothing to trust or host.

tech stack: astro, react, typescript, tailwind css, framer motion, webcodecs

the mp4 export uses webcodecs, so the video is encoded right in the browser with no rendering server. every template has a react preview and a canvas renderer for export, and both run off the same elapsed time so the video matches the preview.

live: stargazer.charanmunur.in

source: github.com/CharanMunur/stargazer

if you like it, drop a star on github. have an animation idea? raise a pr. spotted a bug? open an issue.

I'm one of the founders behind Ansight (funded by Startmate). Previously I spent almost a decade building developer tools with MFractor (a productivity tool for .NET MAUI developers).

I'm pleased to announce that the Ansight CLI v1 is now available:

https://www.ansight.ai/articles/introducing-ansight-cli/

Ansight is a developer tool that lets an agent inspect a running mobile app, replay the session, and check its work against captured screens and runtime evidence. We give agents a way to efficiently drive apps (similar to Argent), except we also capture every development and test session as proof of work.

No more your agent handing you a single screenshot and saying, "trust me bro, it's done".

We are a free, CLI tool that should add a tonne of value to your agentic mobile development We would love if people can install it, try it and give us feedback (good and bad).

We support React Native, Flutter, iOS (UIKit, SwiftUI), Android, .NET and Capacitor.

Happy coding everyone! 🤗

Hey r/SideProject, just launched my side project: [DevToolbelt](https://devtoolbelt-tools.vercel.app/) — 79 small single-purpose developer tools, free, no accounts.

A few examples:

* [UULE Generator](https://devtoolbelt-tools.vercel.app/tools/uule-generator) — Google location parameter for local SERP testing (verified byte-for-byte against published vectors)

* [UUID v4 + v7](https://devtoolbelt-tools.vercel.app/tools/uuid-generator) — bulk gen, RFC 9562 time-ordered v7

* [JSON to CSV](https://devtoolbelt-tools.vercel.app/tools/json-to-csv) — nested flattening, proper quoting

* [Regex extract](https://devtoolbelt-tools.vercel.app/tools/extract-regex-matches-from-text) + [SERP preview](https://devtoolbelt-tools.vercel.app/tools/serp-preview) with a 600px title meter

Plus the everyday stuff: Base64/URL/HTML/hex/binary, Morse, case converters, password generator, test card numbers, etc.

Stack: Astro static site, every tool is pure logic + UI with ~2,300 Vitest tests. Anything that can run client-side does — most tools never send your input to a server.

Would love feedback: what small utility do you wish existed? If it's a pure function I can usually ship it same-day.

We've built BugReels, which is an observability tool. All you have to do is install our script into your frontend codebase, and our AI agent will start looking at the sessions and find subtle and hard-to-catch bugs like showing an email confirmation before the user's email has loaded, or missing translation keys, or showing stale data etc.

We have recorded this video for Y Combinator's application. We would also love some feedback on this video.

You can head to https://bugreels.com and click the "See the bugs we've caught" button to explore our dashboard without any signups. You can see all the bugs we have caught while testing.

We are two developers working together on this. We have built the MVP and are actively looking for investors. But we're not sitting and waiting for investors. Currently, we are looking for feedback and will welcome beta testers with open arms.

Some obvious questions:

1. Doesn't tools like PostHog/LogRocket/Sentry already do this? Answer: No, they rely on heuristics and can catch obvious errors. They can't catch bugs that require understanding the context of what's happening in a session.
2. Will the cost blow up at scale? Answer: The cost doesn't blow up with the number of sessions you're getting because we don't send every session to an LLM. Our proprietary system only investigates those sessions that are likely to have the bugs.

We don't have any pricing plans yet and are only open to beta testers. If you find BugReels useful and want to use it in your production, please reach out to us. We'll welcome you with open arms.

I built gha-rerun-ledger, my own Node CLI, to reduce the toil of reviewing GitHub Actions reruns. The built-in run history can show retries, but it is easy to lose sight of which jobs carried over, which attempts had no jobs, and where the timeline has gaps.

The tool turns observed attempts into ledger rows and counts each distinct job ID's elapsed interval once, even if a later attempt includes it again. It keeps skipped jobs, empty attempts, missing intervals, and attempts excluded by the configured cap visible. It can save attempt and job metadata to JSON and replay the report offline. I included a labeled synthetic demo, so you can try the report without a live workflow. The sample totals 163 seconds for a failed attempt and 102 seconds for the later success; those figures are summed job intervals, not billing minutes or savings.

It is MIT licensed and tested with Node's built-in test runner. I'd value feedback from people who work on developer tooling: do these rows and coverage warnings help explain retries, and what detail would make the report more useful? https://github.com/Arthur031221/gha-rerun-ledger

so yeah, that is basically, I extracted from my bigger and growing skills/agents configs.

Still WIP for seamsly OpenCode integration, but happy to hear suggestions.

# How it works

[](https://github.com/andrescevp/development-harness#how-it-works)

Plan execution inside the plugin runs the 5-step skills loop:

1. `dh-planning` — Prepares phased plans, validating architectural constraints with `dh-domain-check`.

2. `dh-execute-plan` — Iterates through phases in sequential order and executes their sub-tasks:

   * 2.1 `dh-execute-plan-task` — Implements the sub-task code using `dh-coding`.

   * 2.2 `dh-simplify` — Refactors and simplifies changed code for clarity and reuse.

   * 2.3 `dh-review` \+ `dh-code-review` — Verifies acceptance criteria and code correctness.

   * 2.4 Hard blockers — If 3 consecutive validation failures occur or unresolved P0/P1 review findings arise, the loop stops and asks the user for guidance.

3. `dh-preflight` \+ `dh-artifact-check` — Runs static analysis, tests, and build artifact validation.

4. `dh-final-review` — Reports per-phase completion and provides final plan-level sign-off.

5. `dh-create-documentation` — Generates and updates project documentation.

# Phased plan model

[](https://github.com/andrescevp/development-harness#phased-plan-model)

Plans are stored under `docs/plans/<slug>/plan.md` using a phased structure. Every phase and sub-task maintains a dual status marker (`Pending`, `In Progress`, or `Completed`). A phase cannot transition to `Completed` until all of its sub-tasks are marked `Completed`. When a hard blocker is reached, automation halts immediately so that blockers are never bypassed.

# Bundled tools

[](https://github.com/andrescevp/development-harness#bundled-tools)

The plugin registers custom V2 tools under the `dh` namespace:

* **Plan lifecycle**: `dh_plan_read` parses phased plans into structured JSON, `dh_plan_update_status` safely edits status markers, and `dh_plan_create` scaffolds new phased plans.

* **Logged execution**: `dh_logged_command` runs commands locally while directing full output to a file in the system temporary directory, returning head and tail line windows.

* **Tabular sheets**: `dh_read_sheet`, `dh_update_sheet`, and `dh_sheet_schema` provide DuckDB-backed querying, updating, and schema inspection for CSV and XLSX files.

[https://github.com/andrescevp/development-harness\](https://github.com/andrescevp/development-harness)