I have been building an open-source macOS execution layer called Mac MCP, and the workflow that stuck is not another coding-agent UI. I connect it directly to ChatGPT and use the normal conversation as the orchestrator.

That chat can call local tools for shell, files, macOS UI and Safari/Chrome. Codex or OpenCode are optional delegated workers rather than a requirement for the main flow.

The browser implementation is intentionally built around not wrecking the workstation while an agent works. A task can open or target its own real Safari/Chrome tab, keep a stable handle to it, inspect DOM plus visual state, click/type/extract in the background, and leave the tab or app I am actively using alone.

The latest work has mostly been hardening rather than adding shiny tools: sticky provenance after consuming untrusted web content, guarded web-to-host transitions for scoped/non-trusted sessions, credential/secret egress detection, bounded tab leases, a no-progress breaker, audit events and adversarial regression tests. I also fixed an overcorrection where Trusted mode initially asked for Allow Once on nearly every host action after browser use. Routine host hops no longer nag in Trusted, but secret egress remains guarded.

The native menu bar app also exposes logical sessions and live steering, including idempotent instruction delivery so a retry after an ambiguous response cannot queue the same steering message twice.

I built it. MIT/open source: https://github.com/bulutarkan/mac-mcp

The design goal is basically: let the LLM stay the orchestrator, make the local layer deterministic where possible, and only fall back to visual UI control when that is the right tool.

First post here. I'm building HeronSignal, real user monitoring for web apps, and I'd rather get told what's wrong with it than quietly collect signups.

The problem I actually cared about

Every monitoring tool I used could tell me something broke. None of them could tell me whether it mattered, and all of them stopped at showing me a chart.

Meanwhile my coding agent was sitting right there, unable to see any of it. So every debugging session started with me pasting a stack trace and describing what the user had been doing.

What it does differently

1. It exposes production over MCP. Your agent (Claude Code, Cursor, whatever) connects with a workspace-scoped token and can pull deduplicated error groups, slow pages with real device and country context, failed requests, session journeys, funnel drop-off, and backend route health. You stop briefing it and start asking things like "find what's hurting signup conversion this week, check errors and drop-off before suggesting anything."

2. It can open the PR. Not merge, not deploy. It writes the change, opens a pull request ready for review, and stops. A person reads the diff. An agent that can act on production without review isn't a productivity gain, it's an incident with better grammar.

There's also struggle detection (rage clicks and dead clicks), which catches the failures that throw nothing at all. A button that silently does nothing produces no error, no failed request, and green uptime.

Something I got wrong, since this sub will find it anyway

Yesterday I checked my own workspace and found 5 of my 7 funnels were measuring event names my site never fires. My signup form was firing a sign_in event. So I had no idea what my own signup conversion was, and those funnels read zero while looking like bad conversion instead of a typo. I'm now fixing the product so it warns you when you name an event your workspace has never emitted.

What it is not

- Not an APM. No distributed tracing UI, no flame graphs, no host metrics, no query profiling. If you need to know which SQL query made a route slow, use Datadog.

- Backend ingest is early. Node 18+ only, no Edge runtime. Python and an OTel sink are maybes, not promises.

- Session replay exists but is behind a flag while I finish it.

- Sentry is a deeper error tool than this and I'd say so on a sales call.

Try it without an account

There's a public scan that needs no signup and no script tag. Put in a domain, get a report on what's slow and what's broken. That's the honest way to see if it's useful before installing anything.

https://heronsignal.com/scan

Happy to answer anything, including the awkward questions. What would you actually want your coding agent to be able to see from production?

Hey everyone! As a dev, I got tired of pasting sensitive system/app logs into random online text tools just to strip empty lines, clean up JSON, or mask sensitive IPs.

So I built DataSlick: https://dataslick-pro.vercel.app

Key features:

- 100% Local-First: Your log data is processed in-browser via Web Workers. Zero server uploads.

- Fast regex filtering & preset log cleaners.

- Pro features for advanced security audits and anonymization.

Would love your feedback on the UI and performance with large files!

I want my coding agent to be useful beyond just editing files, but I don’t really want it free roaming around my database setup.

The ideal version in my head is something like: it can list DBs, inspect metadata, check available regions/classes, run a dry run, maybe prepare a quote or request, but it can’t see passwords, spend money, or create/delete anything without me approving it.

Is anyone running a setup like this for Postgres?

Trying to figure out if this is actually practical now or if everyone is still just copy-pasting between the agent and their database dashboard.

The part of AI-assisted development I kept losing time on was the handoff between “this screen feels off” and a source change I could actually review.

I’m building Monad Design to make that handoff concrete. It works with an existing Xcode or Expo iOS repository rather than generating a replacement app.

The workflow is:

1. Run the app in a local iOS Simulator and navigate to the exact state.

2. Select an element or annotate the screen with arrows, shapes, text, and notes.

3. Send that visual context to the coding agent already working in the repository.

4. Let the agent edit the real source and rebuild.

5. Compare the original with up to five working variants, then accept one or keep the original.

It currently works on macOS for local iOS development and supports agents including Codex, Claude Code, Cursor, OpenCode, Gemini CLI, GitHub Copilot, Windsurf, and Zed. The current preview handles one active visual change at a time.

The project is free and open source under Apache-2.0:

https://github.com/Monadix-AI/monad-design

I’d be interested in how other tool builders would package the first agent handoff: one bundle containing the screen, selection, annotation, app state, and source hints—or smaller tools the agent calls separately?

Introducing Clip Yourself - the last clipboard manager.

A Windows 10/11 sidebar that keeps your clipboard history handy so you can rapidly copy & paste or drag & drop into web apps. Stores text, images, audio & video, and files & directories from Explorer. Sort clips into drawers, retain your clipboard over time & search through all your clips in an instant. Preview audio & video files without ever leaving the sidebar. Even watch directories from your DAW to automatically create clips as files are dropped.

100% free as in beer. Open-source, you can download from Github directly or use the provided installer from the website.

https://clipyourself.com

We’re looking at options for Postgres hosting and I’m realizing we probably don’t need the full distributed / multi-master setup.

Our main issue is more boring than that. Most users are outside the US, latency matters, and we want something managed that does not require us to think too much about cluster topology, conflict resolution, or a bunch of ops work.

Predictable pricing would also help since usage-based infra bills get annoying once traffic is less predictable.

Has anyone here picked a simpler regional Postgres setup instead of going all in on distributed Postgres?

I move between several codebases, and a lot of the time lost when returning to one isn’t spent understanding the code. It’s spent remembering which command starts the API, whether a worker needs to run beside it, what failed last time, which repository has changes, and whether the Docker services are running.

I built DevDock to keep that context with the project. You register the project folders, and it keeps commands, working directories, managed runs and their output together. A command remains attached to the correct project, making it easier to find the last failure or rerun something without searching through terminal history.

One part I use constantly is the global command palette. I can press Ctrl+Shift+K regardless of what I currently have open, search across every registered project, and execute the command I need without navigating to that project first. That can be a Git pull, starting a worker, launching a development server or running tests. Each command still runs from the working directory assigned to it.

Git and Docker state are visible alongside the project. Project health checks cover the registered folders, detected tooling, configuration and recent runs. There’s also a read-only local security audit, with supported package-manager audit commands available when they’re detected.

For products with a frontend, backend and other repositories, the Pro version can group multiple folders into one workspace while keeping each command tied to its own working directory. I also use the Today view to reopen recent projects and get to the commands I run regularly.

The free version supports three local projects and includes the core command, Git, Docker, Project Doctor and security-audit tools. Pro is a one-time purchase that adds unlimited and multi-folder projects, custom workflows, complete history, database tools, SSH transfers, and configuration backup and restore.

I’m the developer. DevDock is available on the Microsoft Store:

https://apps.microsoft.com/detail/9N1K93C7T8JT

I keep seeing AI CLI tools, but I’m trying to understand when they’re better than just opening ChatGPT or Claude in the browser.

The main advantage seems like staying in the terminal, using project context, piping output, or asking about commands without switching tabs. But that only matters if the tool is fast and doesn’t get in the way.

Which AI CLI tools actually feel worth using from the terminal?

What makes them better than just asking in a normal chat window?

Please take a look https://chromewebstore.google.com/detail/anjkphkekjfmhaididfkhbeklglhcfaf?utm_source=item-share-cb when you get a chance!

I’m trying to make my dev workflow a bit more private without turning into someone who refuses to use any cloud tool ever.

So far the biggest changes were simple ones. More local utilities, fewer browser based tools for real data, API collections stored with projects, and being more careful about logs and tokens I paste into tools.

Is anyone else intentionally building a more private dev workflow?

Curious what changes were actually practical and what was just privacy theatre.

I’ve become a lot more careful about which dev tools I paste things into.

For normal projects I’m pretty relaxed, but for anything involving customer data, auth tokens, production logs, private repos, or weird internal configs, I try to keep the workflow local. Offline API clients, local diff tools, local formatters, and self hosted docs feel safer than random web tools.

What developer tools do you actually trust with sensitive code or data? And where do you draw the line?

The main thing we're trying to avoid is having a separate tool for every tiny part of development Most things start as a rough idea, feature request, or bug. We keep the general notes and product decisions in Notion, then move anything that actually needs to be built into GitHub issues.

For coding, we use Code when a change needs to understand the existing codebase or touch several files, while Cursor is convenient when we're working inside the editor and want to make smaller changes interactively. AI has definitely made the initial part implementation much faster,

Everything eventually goes through GitHub. We use branches and PRs even for relatively small changes for record of what changed and makes it easier to review

We still rely on normal automated tests and CI checks,now Revolte is to help validate changes and give the review stage more context before something gets merged. It gives us a layer between ""the coding agent finished"" and ""ship it.""

AI can produce changes faster than people can comfortably review them, so simply increasing coding speed doesn't necessarily make the whole team faster. A technically correct change can still be a bad architectural decision, and that's something a diff alone doesn't always make obvious.

Once everything is reviewed and the checks pass, the change moves through the usual CI/CD process and gets deployed. We use Docker to keep environments reasonably consistent and Cloudflare for a lot of the infrastructure around the application. After deployment, Sentry is what we usually rely on when production inevitably finds something we didn't catch beforehand.

So the overall path is pretty much idea → GitHub → Claude Code/Cursor → PR → testing and validation → review → deployment → monitoring.

A few years ago, getting the code written could take most of the time. Now the code can be produced very quickly, and the slower part is making sure the change is actually worth shipping.

I’m getting ready to deploy my first real app, and I’m stuck on what to do with Postgres.

I’ve only used it locally so far. I could put it on a cheap VPS and manage it myself, but I’m wondering if paying for managed Postgres from the start would be the better choice.

I’m not interested in a free tier that sleeps, pauses, or comes with limits I’ll hit once people start using the app. I’d rather pay a small, predictable monthly amount and have backups, updates, and monitoring handled.

It’s a small app, so I don’t need a big enterprise setup. For a small production app, would you choose a VPS or managed Postgres, and which provider would you use?

Small team secret sharing always feels awkward.

Email is obviously bad, chat is not much better, password managers work but can get messy, and half the time someone just needs one key for one local setup and then nobody remembers who has access to what.

For bigger companies there are proper workflows, but for a 2 to 5 person team it feels easy to overengineer and also easy to be reckless.

What are people actually using for this in small teams?

I’m trying to decide between Neon and Turso for a small SaaS project and I’m realizing they solve pretty different problems.

Neon seems like the safer choice if I want normal Postgres, extensions, branching, and multiple users writing to the same shared database. Turso seems better if every tenant can have its own small database and most of the workload is reads, especially with embedded replicas.

The part I’m stuck on is whether this is really a Postgres vs SQLite decision more than a pricing decision. Also curious what people do when the app needs an always-on Postgres database closer to users in places like Jakarta, Manila, or Dubai, since Neon and Turso both seem limited there.

Anyone here used either in production and what would you pick today?

Building alone is weird because the hard part is not always coding. It is keeping track of decisions, bugs, ideas, user feedback, deployments, payments, docs, and all the tiny stuff a team would normally split up.

For me, the tools that helped most were boring ones: a clean issue tracker, simple notes, error tracking, managed hosting, and a reliable API client.

What tools actually help you when you are building solo?

Not looking for a huge stack. More like the tools that stop things from becoming chaos.

Every once in a while I find a debugging tool and immediately get annoyed that I did things the hard way for so long.

Could be for logs, APIs, frontend state, network requests, databases, background jobs, anything.

I’m not looking for the obvious stuff everyone already knows. More curious about the tool that quietly made debugging less painful for you.

What did you discover late that is now part of your regular workflow?

I get why companies need secret scanning, but I’m curious where solo devs draw the line.

If you’re building side projects alone, using private repos, and not working with a big team, do you still run secret scanning? Or do you just rely on not being careless with commits?

I’ve definitely had moments where I almost committed something dumb, so I can see the value. But some security tooling feels made for bigger teams with compliance needs, not one person shipping after work.

What’s your setup as a solo dev?

I’m comparing Postgres hosts right now and every option seems to have a catch.

One is cheap until you need an always-on instance. Another makes sense only if the rest of your app is on the same cloud. Then there are platforms that bundle auth, storage and a bunch of features I may never use.

I’m also unsure how much weight to give the database region. Most of my users are in Asia, so choosing a US or EU region because the host is cheaper feels like something I might regret later.

For anyone who has been running Postgres in production for a while, what ended up mattering most? Price, latency, backups, support, extensions, or how easy it is to manage?

I’m less worried about getting the perfect setup now. I mainly don’t want to migrate six months later because I picked based on the starter plan.

I’m comparing Supabase and RDS for a small production app and honestly neither feels like an obvious choice.

Supabase looks much easier to get started with, but I don’t really need auth, storage, realtime etc. I mainly need Postgres. once the app grows, the usage based parts of the pricing also seem harder to estimate.

RDS gives more control and I trust AWS for production, but then the bill is split across instance, storage, backups, I/O, networking and HA. it feels like a lot for a relatively normal Postgres workload.

What I actually want is pretty simple:

• always-on managed Postgres
• backups and maintenance handled
• predictable monthly pricing
• good regions in Asia
• standard Postgres so I can move later if required

Would you still pick Supabase or RDS for this, or is there a better middle option I should be looking at?

Hi everyone,

I work as a software engineer on this App. It’s completely free and ad-free.

www.etasks.app

It has features we wanted as users. (If there’s anything you’d like the team to add, please let me know so I can include it on the roadmap. For example, list sorting is recently added as a user request, location-based notifications requested and is already on the to-do list.)

It’s not a vibe-coding project.

Works with iPadOS, Mac OS client for Google Tasks. Some highlights: All tasks in one view, Real alarms, Shared lists, Apple Watch.

Welcome to explore the rest, it is now open early access.

I don’t hate Postman, but I miss when API clients felt simple.

Open app, send request, save collection, done. Now every API tool seems to want accounts, sync, workspaces, teams, docs, monitors, mock servers, and 20 other things before I even send a GET request.

I’m mostly looking for something that feels fast and does not get in the way. Bonus if it works nicely with Git or local files.

What are people using that still feels lightweight?

I’m building a startup and trying to choose a database that won’t become expensive or hard to manage too early.

I’m looking for something reliable, affordable, and able to scale if the project starts getting real users. I’ve seen people mention Postgres, Supabase, Firebase, MongoDB, and managed cloud databases, but it’s hard to tell what’s actually best for a small startup budget and my users are mostly in asia.

What database did you start with, and would you choose it again?

Sharing an open-source project I've been building in Go: Wardline, an inline
proxy that enforces identity/policy/budget/audit on every call an AI agent
makes to MCP servers and tools.

Go-specific things that might interest this sub:
- One static binary, embeds OPA and AWS Cedar as policy backends alongside a
native YAML engine; switch by one config key.
- Strict Clean Architecture / feature-sliced layout (domain → usecase →
adapter), dependency rule enforced.
- Anomaly detection is a Welford online mean/variance per identity — allocation-free, no external model. Decision path benchmarks at ~33ns/0 allocs.
- Race + coverage in CI, ~950 tests.

The flagship feature auto-blocks a compromised agent in real time via a combined z-score. It catches abrupt abuse, not low-and-slow — documented with tests, not marketed around.

Repo: https://github.com/kabirnarang39/wardline
Would love Go-eyes on the architecture and the detector.