Raycast's Glaze Turns Plain Chat Into Native Mac Apps

Mia: Welcome to ProductHunt Daily, a Bri podcast. I'm Mia.

Milo: And I'm Milo. Today: Raycast's Glaze turns plain chat into native Mac apps, an AI debugger called Osloq actually runs your code to find bugs, and an email tool called Loops finally ties campaigns to real product activation.

Mia: Raycast just released Glaze. You describe an app in chat, and it builds you a working Mac app.

Milo: So instead of writing Swift or SwiftUI yourself, you describe what you want and Glaze builds it.

Mia: You tell it "I need a menu-bar timer that logs my focus sessions," and it generates the project, the interface, the logic.

Milo: That shifts the barrier from knowing UIKit or AppKit to just being able to describe a workflow.

Mia: And because it's from Raycast, the output is a real Mac app — not a web view wrapped in Electron. That matters for performance and system integration.

Milo: So the arc is: idea in natural language, native Mac binary, AI doing the heavy lifting in between.

Mia: Right. The tool targets people who already live inside Raycast, but the bigger story is the cost of creating a personal tool drops to nearly zero.

Milo: That also means a lot more tiny, single-purpose utilities could show up, stuff that was too small to justify hiring a developer.

Mia: And once those tiny apps exist, they tap into Mac-native features — shortcuts, menu-bar controls, local storage — without extra plumbing.

Milo: One concrete consequence is maintenance: if AI generated the first version, you might also have AI refactor it when macOS updates break something.

Mia: Which could keep niche productivity tools alive longer, instead of disappearing when the original author moves on.

Milo: And for people who already automate their Mac with Raycast extensions, Glaze lets them graduate from a script to a standalone app with a proper UI.

Mia: That's the trade-off: you give up fine-grained control over every line of code in exchange for speed and accessibility.

Milo: It won't replace Xcode for a pro app. But for the long tail of "I wish my Mac did X" ideas, the gap just got really small.

Mia: You know that feeling when a GitHub issue says "not reproducible" and you just know the bug is real?

Milo: Yeah. The issue has steps, screenshots, even a heartfelt plea — and it still won't happen on your machine.

Mia: There's a new tool on Product Hunt today called Osloq that tackles exactly that. Instead of just reading your code and guessing, it actually runs it.

Milo: That's the twist. Most AI dev tools are static analyzers at heart — they look at the source and suggest a fix based on patterns.

Mia: Osloq spins up the repo, runs the code, reproduces the bug, and only then proposes a fix. The creator shared a real example where it debugged a Node.js audio library Docker setup by looking at FFmpeg container logs.

Milo: So it's not just matching a stack trace to a pull request. It's acting more like a junior dev who actually pulls the branch and runs the tests.

Mia: Exactly. That changes the signal quality of the fix it suggests, because the fix has been validated against a live reproduction.

Milo: And the consequence for a maintainer is huge. Triaging goes from hours of environment setup to reviewing a PR with a recorded reproduction log attached.

Mia: The catch right now is that the demo video shows a lot of terminal streaming. It's transparent, but you still need to trust an agent that's spinning up containers on your behalf.

Milo: Right, giving an AI tool runtime access to your repo and Docker daemon is not a small permission. The value is clear, but the sandboxing question is going to be the thing teams ask first.

Mia: And that's the core point here. Osloq shifts AI-assisted debugging from static guesswork to runtime evidence, but adoption will depend on whether that evidence is worth the access you grant.

Mia: Some developers talk through code decisions with a colleague, but what if the colleague is Copilot and you can just speak to it?

Milo: That's what Vox is. It's a voice-in, voice-out extension for the GitHub Copilot CLI.

Mia: So instead of typing git commands or pipe chains, you actually say what you want out loud.

Milo: Right. You run "vox" and a listening orb opens right in the terminal.

Mia: And it captures the intent, not just a voice-to-text transcription of a shell command?

Milo: Yes. Vox translates your natural-language ask into a terminal action, runs it, and then speaks the result back to you.

Mia: So you get a full voice loop: you say it, Copilot does it, and you hear the answer without reading the screen.

Milo: That's the core. It turns the CLI into a conversation rather than a typed query-and-response session.

Mia: One consequence is that you can debug or explore data while your hands stay on something else.

Milo: And because it's a Copilot extension, it sits inside an environment many developers already use daily.

Mia: The immediate trade-off is that spoken ambiguity still matters when Copilot guesses which tool you meant.

Milo: That's where the reactive orb design helps. It stays open for follow-ups, so you can refine the command if the first run is off.

Mia: So this isn't a one-shot dictation tool. It's meant to keep a context loop going until the terminal does what you need.

Mia: From voice-driven coding to voice-driven task management—there's another tool that wants you to just say what's on your mind.

Milo: And it's called nxt. The pitch: talk to your to-do list like a human assistant. Brain-dump your thoughts and it figures out what comes next?

Mia: That's exactly the idea. You don't organize, you don't tag—you just speak or type whatever's in your head.

Milo: So instead of opening a list and manually sorting priorities, you say something like "I need to finish the report but also the dog needs a vet appointment."

Mia: Right—and nxt parses that stream of messy, real-life input and turns it into a structured task list behind the scenes.

Milo: The different angle here is it's positioning itself less as a productivity tool and more as a personal assistant that talks back.

Mia: Which means the interaction model is conversational—you can ask it what's next, and it surfaces the right task based on your earlier brain dump.

Milo: That also changes the commitment. You're not staring at a blank checkbox; you're answering a question from something that already understood the chaos you gave it.

Mia: Exactly—and that's the big bet. Most task managers demand structure up front. This one accepts messy natural language and still gives you a clean next step.

Mia: So the last one was an AI assistant you talk to. This one sits on your screen and watches you code.

Milo: A literal desktop pet?

Mia: Yeah, it's called Tamamon. It's a little creature for macOS that lives on top of your windows.

Milo: And it's not just decorative. It grows based on how much you use Claude Code.

Mia: Right. The more you ship with Claude Code, the more your Tamamon evolves. It's gamifying your coding sessions.

Milo: So it's like a Tamagotchi, but the evolution trigger is your actual developer output.

Mia: Exactly. Instead of feeding it, you're feeding it commits and prompts.

Milo: That's a clever way to make the command line feel a bit less solitary.

Mia: And it turns a productivity tool into something you have a tiny emotional stake in.

Milo: I'd probably feel a little guilty closing my laptop if it hadn't evolved yet that day.

Mia: So email metrics tell you someone opened, maybe clicked, but not whether a campaign actually changed behavior.

Milo: Right. That gap bites when you're trying to tie a welcome series to "did these users reach the activation moment."

Mia: That's the exact problem Loops is trying to solve with Goals. It lets you pick a product event, like created first project, and attribute it back to the campaign.

Milo: So it's not just click tracking with a new label. They're pulling in the user's real in-app state.

Mia: Exactly. While the email is sending, Loops watches for that event on the profile. If the event fires after the send within the attribution window, the campaign gets credit.

Milo: That's practical. A conversion chart then sits alongside your opens and clicks, so you stop optimizing for vanity metrics alone.

Mia: And the attribution window is configurable. You're not stuck with a one-size-fits-all lookback that muddies what actually drove the action.

Milo: Right, because if the event happens outside the window it's probably organic, not campaigndriven.

Mia: Once that is live, a marketer can finally answer: did this sequence actually produce activated users, or just curious clickers?

Milo: And for a team measuring product-led growth, that's the difference between burning send volume and proving the email's contribution to retention.

Mia: Still on the theme of making invisible things visible. There's a new tool that brings component and API inspection directly into the browser.

Milo: So we are talking about looking under the hood of any web app, seeing how it is built piece by piece.

Mia: Exactly. It is called Archify, and the promise is right in the tagline: “understand software.”

Milo: Is this just another React DevTools, or does it go further?

Mia: It is less framework-locked. The description says it shows components, APIs, and libraries, and it lets you understand application behavior right inside your browser.

Milo: So instead of guessing what an endpoint returns or which library is rendering a widget, you just select it on the page.

Mia: Right. That means debugging or auditing an unfamiliar product could drop from half an hour to a minute.

Milo: The real consequence is that reverse-engineering a competitor’s stack, or even checking your own app’s third-party footprint, becomes a no-code step.

Mia: That is a sharp shift in transparency for anyone who analyzes web products.

Milo: And it lands at a moment when teams are already drowning in dependencies they cannot easily trace.

Mia: And that's a good place to leave it. Seven tools, but one thread: making invisible things visible, whether it's your code, your task list, or your email attribution.

Milo: Thanks for listening to ProductHunt Daily, a Bri podcast. We'll be back tomorrow with more. Talk to you then.