0908 | Agents at Work: Coding, Capturing, and the Notch

Mia: Welcome back to the show, everyone. I'm Mia.

Milo: And I'm Milo. Today we're doing something a little different — a kind of daily briefing built entirely from launches and discussions that surfaced in the last twenty-four hours on Product Hunt. Five products, five conversations, and honestly, they hang together better than you'd expect.

Mia: Yeah, because there's a thread running through all of them: what happens after the AI does the work? Who checks it, who keeps it, who sees it, and what does it cost you? We'll start with coding agents that work together and show their work, then move into saving AI conversations before they disappear, some Mac tools that live at the edge of your screen, a couple of creator tools that react to you in real time, and finally agents that run on their own schedule.

Milo: And a quick promise before we dive in: everything we say about these products comes from the makers' own descriptions and the community discussion around them. We haven't tested any of this ourselves, so treat the maker claims as claims. Where there are good questions from the community, we'll bring those too, because some of them are sharper than anything the makers said.

Mia: Alright. Coding agents first. Let's start with Airuncode.

Milo: So Airuncode is a local-first agent runtime — that phrase matters — for what they call serious software work. The pitch is that you can run multiple coding agents on your own machine, bring your own API keys, and switch between cloud and local models. And they're explicit about the money: you pay the providers directly, with zero token markup. That's a meaningful position, because a lot of tools want you to buy tokens through them.

Mia: And the maker laid out the philosophy pretty clearly. They said they didn't want their whole coding workflow to depend on one AI company, one subscription, or one model. The idea is that the runtime should be the stable layer, and the model should be replaceable. That's actually a decent framing — instead of betting on one model being the best forever, you bet on the harness around it.

Milo: So what does it actually do? It scans your codebase, it can debate solutions across agents, edit files, run tests, and self-heal failures. So if a test fails, it tries to fix the problem automatically. It also ships with something called V-CORE, which is a native Vulkan 3D runtime for AI-assisted game development. The maker said they built that so agents would have real engine capabilities — rendering, terrain, physics — instead of having to recreate those systems from scratch every time.

Milo: That's a niche within a niche, but it's an interesting one.

Mia: It's available on Windows, macOS, and Linux, so it's cross-platform. And the maker was upfront that this is early — they're rebuilding parts of the PWA, improving the experience, and adding a community forum. They asked two questions in their launch post that are actually pretty good: what feels broken or confusing, and what would make you actually use this as your daily coding agent? That second one is honest, because daily use is the real bar.

Milo: But here's where it gets interesting. A community commenter raised what might be the smartest question in the whole discussion, and it applies way beyond Airuncode. They said the failure they keep hitting with parallel agents isn't bad code — it's a second correct implementation of something the repo already had. Because each agent session starts from a blank slate, and in the diff, it reads fine. It's correct code. It's just duplicate code that nobody wanted.

Mia: Right, and they asked specifically: does the debate between agents happen after all of them have read what's already there, or are they arguing about approaches before anyone checked whether one exists? That's the crux. Multiple agents in parallel is the headline feature, but parallel agents who haven't seen the same context can multiply the exact problem you'd want them to solve.

Milo: Same commenter had a worry about the self-healing, too. A failed test goes green — great — but green doesn't tell you the fix belonged in that layer. The test passing isn't the same as the fix being right. So those are two open questions for Airuncode: does the cross-agent debate include shared knowledge of the existing repo, and can self-healing distinguish a correct fix from a merely passing one?

Mia: And that problem — understanding what the agents actually did — is exactly what our next product attacks. It's called PR Lens, from a team called Coldtea.

Milo: PR Lens draws animated architecture and data flow diagrams of any codebase and every pull request. The idea is you see the change before you read a single line of code. Every PR comes with an animated diagram where additions, changes, and removals are color-coded, and it moves — so instead of a wall of diff, you watch a request travel through the system.

Mia: The maker's argument for why this matters: agents write more code every week, but we still have to understand it, and reading line by line is no longer an efficient way to do that. Their whole framing is that reading code should be visual — a few hundred lines a minute — leaving your attention for the part that's actually critical, which is the mental model of the system, its architecture, and how data moves through it.

Milo: On the practical side: it's open source under MIT, it works with any model you bring, and it runs three ways — as a GitHub Action, on the CLI, or as a skill for your coding agent. So if you live in an agent, you can install it and just ask it to diagram the change it just made. The maker says it takes about a minute to run locally.

Mia: Now, the community discussion here was genuinely substantive. One person made a point that connects directly back to what we were saying about Airuncode: agents generate diffs faster than any human can read them, and the actual review bottleneck isn't diff size — it's building a mental model of what moved. That's a great one-line summary of the whole problem space.

Milo: And another commenter described it from the solo founder angle, which is worth spending a moment on because it challenges the product's framing. They said, I'm a solo founder, I don't really do PRs, so the review workflow isn't my problem. My problem is that after a long run of agent-written changes across a Rust desktop app, a C# API, and a React frontend, I quietly start losing the shape of my own codebase. The parts I wrote myself I can still see. The parts I directed, less so.

Milo: That's a slightly different use case — not reviewing a change, but keeping your own mental map of a system.

Mia: And that commenter asked two concrete questions: does the baseline let you look at the system as it stands right now, rather than at what a particular change moved? And does it cross language boundaries — like, a Tauri command in Rust and the TypeScript caller on the other side of it, or is the diagram scoped per language? Neither answer appears in the source, so those stay open.

Milo: Other open questions from the discussion: how does the diagram hold up on changes touching config or infrastructure files versus pure logic changes — those have very different shapes and are probably harder to render meaningfully. One person asked about the maximum number of files.

Milo: And one asked whether the diagrams are generated by an LLM's intelligence or hard-coded into PR Lens itself — which is actually a question about reliability, whether the visual representation is trustworthy or just plausible-looking.

Mia: Also worth noting, one user asked whether it makes sense with no second human reviewing, or if it's built for teams — which circles back to the solo founder point. And the maker described their own daily use: agents ship a PR, the diagram lands with it, and they know what moved before they read a line of the diff. That's a claim from daily use, but still their claim.

Milo: So if you put Airuncode and PR Lens side by side: Airuncode is about having more agents do the work, PR Lens is about a human understanding what got done. Airuncode's biggest risk — parallel agents duplicating existing code — is a problem PR Lens is at least designed to surface. They're almost two halves of the same workflow.

Mia: Which brings us to a related problem on the output side. When you use AI to write code, ideas, plans, whatever — where does the output live afterward? Our next product is Clipnote.

Milo: Clipnote's pitch: your ChatGPT and Claude conversations disappear the moment you close the tab. With Clipnote, you tell your AI to "save this" and it's kept on the spot. Pasting it in works too. It's basically a notepad for AI conversations — save them, come back later, pick up where you left off.

Mia: The maker's story is a familiar one. They kept losing track of everything they created with AI — code snippets, drafts, ideas — scattered across chat windows with no way to save, organize, or share them. Clipnote gives you a place to save AI-generated content, organize it into collections, and publish it with a shareable link — either right from your AI chat via MCP, or manually through the web app.

Mia: They said it started as a personal tool, but anyone using ChatGPT, Claude, or Gemini regularly hits the same problem: great outputs, nowhere good to keep them.

Milo: Let's get concrete about the mechanics, because there's more here than the one-liner suggests. It supports three formats — plain text, Markdown, and HTML. The HTML part is interesting because it means the AI's visual output, like a built page or a report with layout and interaction, gets saved as it actually looks, and can be opened by anyone with the URL in a browser.

Mia: And you can update saved clips by name — so you say, "add today's decisions to the meeting notes," and it loads the clip, answers with its content in mind, and updates it. Older versions are automatically saved when you overwrite. There's version history, and deleted clips go to a trash where they're recoverable for thirty days. You can bundle multiple clips into a collection and share it as one public page. And clips can be private or public, toggled later.

Milo: On privacy, the maker and the community landed in a good place. One commenter noted that MCP saves are private by default, and called that the right call — it saves you from an accidental leak on day one. Another commenter gave what I think is the sharpest critique: the "save this" via MCP flow is the clever part, way lower friction than copy-pasting into a separate app.

Milo: But their hesitation is the shareable link piece — a lot of what gets saved out of an AI chat is half-finished or contains something you wouldn't want public by accident. So they asked: is there any expiry or access control on those links, or are they permanent and open to anyone with the URL?

Mia: That question doesn't have a stated answer in the source, so it's open. Another community question: can Clipnote organize saved conversations by topic or project? The website does show collections, which group multiple clips into one shareable page — so partial answer there, but topic-based organization seems to be the collection system.

Milo: And connecting this to our theme: the same capture-it-before-it's-gone instinct shows up in Mac note tools, which brings us to the next group — Tucky, Assist, and Remind. Three Mac utilities, all about keeping something available right at the edge of your attention.

Mia: Tucky first. It's a native macOS notes app where notes sleep as a thin stripe on the screen edge. Local and encrypted. There's an AI agent inside. The free tier gives you exactly one note. Plus is twelve dollars a month and adds voice, connectors to things like Gmail, Google Calendar, GitHub, and Notion, and — their words — the best LLM models.

Milo: The design idea got real praise in the comments. One person said the thin stripe is clever — every notes app fights for your attention, this one deliberately hides until you need it, and that restraint is harder to design than it looks. Another said most note apps lose to the "just one more tab" problem, and docking notes to the screen edge is the right call.

Milo: The maker's origin story: as a founder, they were drowning in scattered notes, ideas, feedback, and reminders across apps and screens, and built Tucky as the quiet assistant they wished they had.

Mia: But there was a sharp community question on the pricing: a lot of features seem behind the payment, so users need to pay before getting a full taste of what Tucky could do. Was there a reason for that? It seems you could push for a paid subscription from the beginning and avoid supporting a free plan at all. That's a fair challenge to the one-free-note model. And multiple people asked whether Tucky is coming to Windows — no answer in the source.

Milo: The best question, though, is the privacy boundary one. It's local and encrypted, but Plus taps "the best LLM models" — so where does that boundary sit? Does the agent call out to a cloud model only when you explicitly ask it something, or does it also read your notes in the background to suggest actions? The website does give one concrete detail: when you ask about a note with a keyboard shortcut, the title goes with the question, and the body is only sent when you allow a read.

Milo: So there's some per-note control. But the broader question about background reads stays open.

Mia: Next, Assist, which lives in a completely different part of the Mac: the notch. Assist combines three workflows — voice-powered screen annotation, clean full-screen screenshots, and clipboard history. You hold Option anywhere on macOS, draw over the screen, and speak while you point things out. A local WhisperKit transcript gets attached to the same capture, so the image and your intent stay together.

Milo: The maker built it out of frustration two weeks before launch, and their story is very workflow-specific: they were using the native Mac screenshot app for cropping and sending images to Codex, typing long prompts, doing this a hundred times a day, and it became miserable. Now they hold Option, annotate while speaking, and a local model transcribes the voice and creates an optimized prompt they can copy and send to Codex, Claude Code, or anywhere else.

Mia: Privacy story here is strong, at least as claimed: transcription runs locally with WhisperKit on Apple silicon, the raw audio stays in memory only while transcription finishes and is never saved, everything is stored locally, and — their words — there is no server. It's twenty dollars, one Mac, one-time purchase, no subscription.

Mia: Beyond annotation, Control plus Option takes a clean full screenshot, and a quick editor drops under the notch for cropping, blurring with three brush sizes, or adding a backdrop. Clipboard history filters by all, text, or images.

Milo: And one community comment that deserves to be read carefully: a clipboard manager that keeps history is a secrets store whether you designed it as one or not. Everyone pastes an API key or a password out of a manager at some point, and now it's sitting in the notch ready to be reused. Do you detect and skip those, or is there at least a retention window you can set? No answer in the source. That's a genuinely important question for any clipboard tool, and I'm glad someone asked it.

Mia: On the positive side, one commenter with carpal tunnel syndrome said this is really helpful — which is an attributed use case, not a general claim. And another asked how it competes with Whisperflow — also unanswered. But the voice half got flagged as the interesting bit: most annotation tools make you type the thing you'd have said out loud in two seconds.

Milo: And the third Mac tool, Remind, goes the opposite direction from hiding at the edge — it takes over your entire screen. The maker built it because they'd be heads down in deep work and realize they were seven minutes late to a Zoom call. When your next meeting starts, Remind creates a full-screen reminder on every display, with an AI briefing on who you're meeting and a one-click join button.

Mia: The briefing is the differentiator. It connects to Google or Microsoft calendars, and optional email, Slack, and Notion connections pull context into the brief — who you're meeting, what was last discussed, what's outstanding. It supports joining Zoom, Google Meet, Teams, and Webex from the card. It's researched ahead of time using your own AI key — Claude, OpenAI, Gemini, or Grok, per their site.

Mia: And because the reminder fires at exactly meeting time and takes over the screen, you can work without watching the clock until then.

Milo: Pricing is nineteen ninety-nine a year on the Mac App Store with a seven-day free trial, for macOS 14 and up. One community comment called it helpful for busy people who have to do context switching across too many projects or clients. I'll note the obvious tension: a tool that takes over every display at meeting time is a bold intervention, and the pitch is that it's precisely because the rest of your tools are too quiet. A calendar notification slides in, waits, and fades away unnoticed.

Milo: Their demo page walks through exactly that moment.

Mia: So Tucky, Assist, and Remind: all three are about placement. Tucky puts notes at the edge and hides them. Assist puts capture in the notch. Remind puts meetings everywhere, full screen, on purpose. Same desktop, three philosophies about how much space a tool deserves.

Milo: And that idea of reactivity — tools that respond to what you're doing — carries straight into our next pair, which are creator tools. Scriptly and Bloop.

Mia: Scriptly is an iOS teleprompter app controlled by your voice, currently in public beta on TestFlight. The core feature: real-time voice-following scrolling. Instead of matching your speaking pace to a rigid, pre-set scroll speed, the script moves at your pace.

Milo: The maker is a content creator who said they were constantly frustrated by clunky traditional prompters that forced them to awkwardly match their speaking to a fixed scroll. They wanted something native, fast, and intuitive — write, organize, and record in one place instead of juggling multiple apps.

Milo: There's a distraction-free writing environment, script organization, Apple Watch controls so you can start and stop recording and adjust the text without reaching for your phone, and local-only storage.

Mia: The community pushed with good questions. An Android user said this is the kind of app that makes them think about switching — they record short founder videos and the teleprompter is always the weak link: fixed-speed scrolling means chasing the text or pausing awkwardly, and it shows on camera. Voice-following is exactly the fix. Then they asked the two questions I'd ask: is Android on the roadmap at all, or is the voice matching tied to iOS-only APIs?

Mia: And when you go off-script for a sentence, does it pick up where you left off, or wait on the last line? Neither is answered in the source. And there was a light jab from the community: it's a video tool, and no demo video was uploaded to Product Hunt. Fair.

Milo: Bloop is the other creator tool, and it's a different kind of reactive. It's a macOS app that turns system audio or mic input into real-time visuals — eight shader skins, every frame responding to what's actually playing, not pre-rendered loops. On steady rhythms, an automatic BPM pulse aligns the breathing and wobble. It works from system audio or the mic, with automatic noise suppression and a sensitivity control, so it can react to a room, not just a file.

Mia: The output story matters most: you can drop in an MP3 playlist and export the whole thing as a finished video. The maker said video export is the reason people pay — if you put music online, you need something to put on screen next to it. There's a resizable Mini Player that stays above other apps, and a visualizer in the menu bar.

Milo: The craft story here is worth retelling because it shows what's actually inside these things. The maker said the hardest part wasn't the audio — it was getting one skin to feel alive. They rebuilt it four times: flowing ink, then organic waves, then a spring-coupled ring of 256 points that pushes outward and relaxes back, then a pass to make it react to musical attacks instead of raw volume.

Milo: And at the end they renamed it — they'd been calling it Black Hole, but the name described the opposite of what was on screen. Nothing gets pulled inward; the outline gets pushed out and trails where it's been. It's called Wake now. They said that detour is maybe four hundred lines of the app, and most of what they learned building it.

Mia: Limits, stated by the maker directly, which I appreciate: Apple Silicon only, no Intel Mac support. macOS only, no near-term Windows plans. And it's a visualizer — if you want an audio editor, this isn't it. Pricing is no subscription: two skins, Glossy and Contour, are free forever, and the maker emphasized those are the full app, not a trial. One commenter appreciated exactly that and grabbed them.

Mia: Another suggested adding different colors, and one asked about an Apple TV version — both unanswered. And one commenter guessed people would use the calmer skins for focus music and the chaotic ones like Wake for hard beats, and asked if that holds up with real usage data — a nice question, no data yet.

Milo: Now, the last pair ties everything together: agents that react to your data on their own schedule. First, Routines by Databox.

Mia: The pitch: give your AI Analyst a prompt and a schedule. It analyzes your live data, prepares the report or analysis you asked for, and delivers it by email, Slack, or in-app. The recurring work you do by hand today gets done automatically. The maker framed it as the fourth piece of a puzzle: MCP brought your data into the LLM tools you work in, Skills gave the analyst repeatable expertise, Artifacts made output polished and shareable, and Routines make it run without you asking.

Milo: The maker's argument about the old way is the why: someone pulls the numbers, figures out what moved and why, writes it up, sends it around. The team talks about it days later. The next round happens when that skilled person has time — usually a week or a month out. So analysis happens as often as one person's calendar allows, only the people on that email see it, and anything that goes wrong in between doesn't get caught.

Mia: Key mechanics. Runs pull fresh from live connected data, not a cached copy of the last answer — one commenter called that out specifically, saying it means you can trust a "nothing changed today" result instead of assuming it's a static placeholder. Runs are saved and searchable, so you can find what last Tuesday's check said.

Mia: And you can turn an existing chat or artifact into a routine with one click — several commenters tested exactly that, saying the same question now runs every morning without retyping it.

Milo: The most interesting comparison came from a comment contrasting a Routine with a cron job: a cron job runs a script on a timer, doesn't reason, and gives you the same type of analysis every time. A Routine decides each time what's worth focusing on and telling you — a different analysis every time. That's the claimed difference between automation and an agent.

Mia: And there's a webhook trigger, not just a calendar schedule — a Routine can fire the moment a campaign ends or a threshold gets crossed. One commenter said that removes a whole layer of automation people usually build by hand. You can also save your analysis approach as a Skill once and put it on a schedule. Free for fourteen days to try.

Milo: But one community question cuts to the heart of it and went unanswered: everyone has a dashboard, but someone still has to figure out what changed — how do you decide which insights are actually worth surfacing? That's exactly the hard part of an analyst's job, and if a Routine can't prioritize, you might get scheduled noise instead of scheduled insight.

Mia: Last one: Nina by Antalpha. Antalpha is NASDAQ-listed — ticker ANTA — and Nina is their non-custodial AI trading assistant. The rule the maker leads with: Nina never holds your funds. You sign every transaction on your own wallet.

Milo: The maker's story: years of trading crypto, and the exhausting part was never the trade — it was everything before it. Ten tabs open: on-chain flows, smart-money wallets, macro, sentiment, and a generic chatbot making things up because it had no real-time data. And the "AI agents" that promised to fix this wanted custody of the wallet or ran on their own token. Handing your keys to a bot to save a few minutes never felt worth it.

Mia: So Nina is wired to institutional-grade, real-time on-chain data, and answers conclusion-first, with charts rather than walls of text. It covers smart-money tracking, market and event predictions — including Polymarket — wallet-safety checks, and it has Sentinel, 24/7 alerts. There's also MCP support, so you can pull Nina's data into whatever AI client you already use. And one chat now covers crypto and US stocks.

Milo: When you want to act, Nina drafts the best-route trade, and you sign it yourself. And there's a genuinely interesting design statement in the maker's post: they said their scope actually kept getting narrower as they built. They dropped the autonomous "do-everything agent" dream and leaned into one thing — being the analyst and drafter you can genuinely trust. That's a notable contrast with a lot of agent marketing.

Mia: Community reaction focused on the custody model — two commenters independently said non-custodial is the key thing, which tells you it's the differentiator people actually care about. One person said they're not a fan of trading bots but liked the personalization and character. Open questions: users asked whether the stock analysis covers only US stocks or other regions, and whether non-US markets are on the roadmap — no answers in the source.

Mia: And of course, the usual caveat applies: none of this is a claim we can verify, and trading tools especially deserve skepticism about the quality of their data and drafts.

Milo: So let's pull the threads.

Milo: Across all five areas, the pattern is similar: AI does the producing, and the products that seem to matter most are the ones handling everything around it — Airuncode and PR Lens on understanding what agents did, Clipnote on keeping what AI gave you, Tucky and Assist and Remind on keeping your own thoughts and commitments close, Scriptly and Bloop on real-time reactivity, and Routines and Nina on agents that act on a schedule without holding anything you can't take back.

Mia: And in every case, the most valuable part of the discussion came from the community asking the boundary questions: does the agent know what already exists, are the links safe to share, is the clipboard a secrets store, which insights are worth surfacing, who holds the keys. Those questions are where these products will succeed or fail, and most of them don't have answers yet.

Milo: That's the briefing. Thanks for listening — we'll be back with the next one.

Mia: See you then.