
Sign up to save your podcasts
Or


Ben Tossell thinks of his personal AI agent as a folder: context he can open, inspect, edit, and take to another model. When its memory started holding on to too much old information, he pared it back.
In this outdoor conversation with Michael Galpert, Ben explains how he makes AI useful through small experiments. They discuss the animated mascot on his personal site, learning coding concepts visually, and an email client he built before realizing that labels and archiving were what he actually wanted.
In this episode:
• Learning by playing and asking basic questions
• Building prototypes you can throw away
• Making technical vocabulary easier to understand
• Steering coding agents as the work develops
• Keeping personal context portable and inspectable
• Deciding what an agent should remember or forget
• Starting instructions with one line and adding only what is needed
• Building small tools for yourself without turning every idea into a company
Ben’s examples show how experimenting can lead to a smaller, more useful system than the one you first imagined. This is his evolving approach to personal AI, including the friction and bugs that come with it.
About Already Here: Michael meets people already living with personal AI in everyday life. The conversations explore what changes in how people work, make decisions, and direct their attention.
Follow him on x: https://x.com/msg
Subscribe for more conversations with people already living with personal AI. What small tool would you build for yourself?
Referenced tools, people and background:
Ben's Bites: https://www.bensbites.com/
Ben personal site: https://bentossell.com/
Josh Puckett: https://joshpuckett.me/
Matt Pocock dictionary: https://github.com/mattpocock/dictionary-of-ai-coding
Index: https://index.how
Pi coding agent: https://github.com/earendil-works/pi
Factory / Droid: https://factory.com/
Codex: https://openai.com/codex/
BB: https://getbb.app/
Claude / Opus: https://claude.com/product/overview
Claude Code: https://claude.com/product/claude-code
ChatGPT: https://chatgpt.com/
GLM / Z.ai: https://chat.z.ai/
OpenRouter: https://openrouter.ai/
Latent Space / OpenRouter episode: https://www.latent.space/p/openrouter
Pragmatic Engineer / Matt Pocock: https://newsletter.pragmaticengineer.com/p/ai-skills-with-matt-pocock
Matt Pocock skills: https://github.com/mattpocock/skills
ASD Simplified Technical English: https://www.asd-ste100.org/about_STE.html
Muse: https://about.fb.com/news/2026/09/introducing-muse-personal-ai-agent/
Dots: https://help.openai.com/en/articles/20001530-getting-started-with-your-dot
Grok Bot: https://x.ai/bot
Karpathy LLM Wiki: https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f
Instinct: https://instinct.com/
Google Drive: https://workspace.google.com/products/drive/
Makerpad background: https://techcrunch.com/2021/03/08/zapier-buys-no-code-focused-makerpad-in-its-first-acquisition/
Superhuman: https://superhuman.com/
Gmail: https://workspace.google.com/products/gmail/
Google Workspace CLI: https://github.com/googleworkspace/cli
Cognition: https://cognition.com/
OpenAI Sol models: https://openai.com/index/introducing-gpt-6-1-sol/
OpenAI Astra: https://openai.com/index/gpt-6-astra/
AGENTS.md: https://agents.md/
Model Context Protocol: https://modelcontextprotocol.io/
Jacob Miller turned his AI coding workspace into something out of Warcraft III, complete with wrought-iron panels and lighting that follows the cursor. His starting point was an image.
In this episode, Michael sits down with Jacob, creator of DiffUI, to walk through how he designs with image models before handing the results to a coding agent. They explore why AI-generated apps can look generic, how to give them a distinct visual style, and how to keep that style consistent beyond the first screen.
In this episode:
• A walkthrough of Jacob’s Warcraft-inspired BB workspace
• Why Jacob starts with images before generating code
• Using DiffUI to explore designs and pass visual references to a coding agent
• Keeping settings pages and other screens consistent with the rest of an app
• Building tools around your own repeated tasks
• Experiments with AI-generated game characters and worlds
• Jacob’s one-month filter for deciding which new AI tools are worth learning
Jacob’s approach gives the coding agent a clearer picture of what to build: explore the look, design the related screens, then hand over the visual context.
About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people work, make decisions, and direct their attention.
Subscribe for more conversations with people already living with personal AI. Then comment: what would you redesign if your software could look and work exactly how you wanted?
Links mentioned in this episode:
DiffUI: https://diffui.ai/
BB: https://getbb.app/
Follow Jacob Miller on X: https://x.com/pwnies
Serial founder and Crazy Egg CEO Hiten Shah thinks most people are still using AI like Google: they type a short request, accept the first answer, and stop. His alternative is to give AI real context, show it what good work looks like, and let specialized bots carry a job further—while a person keeps the final judgment.
In this episode, Michael and Hiten compare the friction of earlier agent setups with Grok Bot, which gives each bot a computer it can use. Hiten explains how he connects research, product-marketing, and librarian bots; uses private GitHub repositories as shared context; and limits risky actions with read-only access, explicit constraints, and approval steps.
The examples are concrete. Hiten’s bots made 1,800 GitHub commits in a day before he corrected the behavior and set a limit. In another workflow, a local AI system reproduced a desktop-app bug, gathered screenshots and video, debugged the problem, and prepared a pull request for human review.
In this episode:
- Why Hiten calls today’s shallow AI use “the Google problem”
- What changes when a bot has its own computer instead of only a chat box
- How a research bot, product marketer, and librarian can work as a team
- Why Hiten stores bot-created context and artifacts in private GitHub repositories
- How he handles access, permissions, read-only connections, and approval gates
- Why he does not use one chief-of-staff bot as a bottleneck
- How to get better output by showing AI examples of what good looks like
- Why human judgment remains the final mile before anything is published or shipped
- How local models can support QA and move work from a bug report to a reviewed pull request
- The product question Hiten now asks repeatedly: “If we were to build it today, what would we build?”
- Why distribution and go-to-market may need to shape the product from the beginning
Try one low-risk experiment: choose a task you already understand, give AI the relevant context and one strong example, constrain what it can change, and review the result before it acts publicly.
About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how work is assigned, how decisions are made, and where people spend their attention.
Subscribe for more conversations with people already living with personal AI. Then comment with one task you are still treating like a search—and what it would look like to delegate the whole job.
Official links mentioned in this episode:
Hiten Shah: https://www.hiten.com/
Crazy Egg: https://www.crazyegg.com/
Typeahead: https://www.typeahead.ai/
Grok Bot: https://x.ai/bot
Cursor: https://www.cursor.com/
OpenClaw: https://openclaw.ai/
Hermes Agent: https://github.com/NousResearch/hermes-agent
Last 30 Days: https://github.com/mvanhorn/last30days-skill
GitHub: https://github.com/
ChatGPT: https://chatgpt.com/
Claude: https://claude.ai/
Codex: https://openai.com/codex/
Granola: https://www.granola.ai/
Greg Mushen built a personal AI agent that tracks meals, movement, and health data without making him live inside tracking apps. Instead of tapping through forms all day, he can message Hermes Agent in Telegram, send a photo or barcode, and let scheduled check-ins keep the record current.
In this episode, Michael and Greg break down what makes that system work—and where personal AI becomes much more than a chatbot.
In this episode:
• How Greg replaced manual food and activity logging with a conversational AI workflow
• How Hermes Agent uses Telegram, scheduled check-ins, and nutrition data to reduce tracking friction
• Why making a health system easier to use can matter more than adding another dashboard
• How AI helped audit 54 cited research papers behind a daylight-saving-time claim
• How Greg runs Gemma locally on NVIDIA Jetson AGX Orin hardware for sensitive health-data work
• Why local Whisper transcription, embeddings, and classification can keep private data off third-party APIs
• How Claude Code and OpenAI Codex change the way Greg builds and reviews software
• Where autonomous agents are useful today—and where human judgment still belongs
About Already Here: Michael Galpert meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people work, make decisions, and direct their attention.
Subscribe for more conversations with people already living with personal AI. Then comment with the first piece of health tracking you would hand to an agent.
Links mentioned in this episode:
Greg Mushen on X — https://x.com/gregmushen
Hermes Agent — https://github.com/NousResearch/hermes-agent
Telegram — https://telegram.org/
Cronometer — https://cronometer.com/
Pedometer++ — https://pedometer.app/
USDA FoodData Central — https://fdc.nal.usda.gov/
Apple Health — https://www.apple.com/ios/health/
Google Gemma — https://ai.google.dev/gemma/docs
NVIDIA Jetson AGX Orin — https://developer.nvidia.com/embedded/jetson-agx-orin
OpenAI Whisper — https://github.com/openai/whisper
Claude Code — https://code.claude.com/docs/
OpenAI Codex — https://developers.openai.com/codex/
Blake Eastman tried rebuilding the SaaS products his company depended on—from Riverside and Asana to bookkeeping software—using AI.
The tools worked for his personal workflow. Then he encountered the difference between building something for yourself and operating a real software company: infrastructure, edge cases, observability, maintenance, design, guardrails, and thousands of users.
In this episode:
- Why Blake became less eager to replace mature SaaS products
- The hidden work required to turn an AI prototype into reliable software
- How he decides what to build and what to leave alone
- Why he now prefers products with APIs, CLIs, and MCPs
- How PostHog and Sentry expose errors, usage, and LLM costs
- The 85% rule he uses to avoid endless AI experimentation
- How builder critiques reveal what polished productivity advice misses
- Why Blake believes “everything is connectable”
- Inside his source-bound research system, the Academic Holocron
Blake’s conclusion isn’t to stop building. It’s to build narrow tools that create personal leverage, respect the complexity of mature infrastructure, and connect the best existing products into a system shaped around how you actually work.
Already Here explores how people are already living and working with personal AI—and what changes when these tools become part of everyday life.
Links mentioned in this episode:
The Nonverbal Group: https://www.nonverbalgroup.com/
Blake’s newsletter: https://www.nonverbalgroup.com/newsletter
Blake on X: https://x.com/blakeeastman
Michael on X: https://x.com/msg
Riverside: https://riverside.com/
Asana: https://asana.com/
Bench: https://www.bench.co/
PostHog: https://posthog.com/
Sentry: https://sentry.io/welcome/
Warp: https://www.warp.dev/terminal
Aside: https://aside.com/
Upwork: https://www.upwork.com/
Claude Code: https://claude.com/product/claude-code
OpenClaw: https://openclaw.ai/
Lettera: https://lettera.md/
Agentation: https://www.agentation.com/
Priya Rose can walk her daughter to school, mention work in an ordinary conversation, and come home to find that an AI agent has done it. Then the same setup published a casual thought to her company’s live website.
Priya is a software engineer and cofounder of Fractal, where she teaches people to build useful personal AI systems. Her own setup listens to conversations she chooses to record, finds work hidden inside them, and tries to complete it—from coding changes and reports to grocery orders and tiny family apps.
In this episode:
Priya’s central idea is simple: the best personal AI should fit into your life so naturally that talking becomes a form of doing. But the more an agent can act, the more its permissions—not just its instructions—must reflect the boundaries you actually want.
Links and resources:
Priya Rose: https://x.com/prigoose
Fractal: https://fractalnyc.com/
Zo Computer: https://www.zo.computer/
Otter: https://otter.ai/
Privacy.com: https://www.privacy.com/
Gumroad: https://gumroad.com/
Robin Sloan, “An app can be a home-cooked meal”: https://www.robinsloan.com/notes/home-cooked-app/
About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people work, make decisions, and direct their attention.
Subscribe for more conversations with people already living with personal AI.
Cathryn Lavery uses personal AI for the work that creates friction at home: family logistics, complicated travel, and information she meant to organize years ago. Her approach is concrete: give the assistant context, give it a narrow job, and preserve human approval for decisions that matter.
In this episode, Michael sees Cathryn’s AI house manager in action. It is a shared assistant her family can message to research options, prepare paperwork, update calendars, and handle recurring administration. During a fast move to San Francisco, it helped the family compare housing, find childcare, choose meals, and secure a place from a filling waitlist after Cathryn approved the sign-up.
Cathryn also shows how she made eight years of voice memos useful. Her system transcribes the recordings on her own computer, creates a searchable index, groups related themes, and adds new recordings each week.
In this episode:
• What Cathryn means by an AI house manager and how her family talks to it
• How the assistant researched housing and summer camps, then handled paperwork after a human decision
• How it helped manage meals, calendars, and the logistics of a rapid move
• How Cathryn compared airline-points options for travelers leaving from Austin, Dublin, and Belgium
• How separate assistant profiles keep shared family requests apart from Cathryn’s private tasks
• Why a Mac Mini serves as a familiar, dedicated computer where her assistants can run
• How local transcription keeps voice recordings on her computer while turning them into searchable text
• How she turned eight years of voice memos into usable personal context
• The boundary between automatic low-risk corrections and proposals Cathryn must approve
Cathryn does not begin with AI. She begins with the friction already present in her life, gives the agent enough context and tools to help, and preserves approval for the decisions that matter.
About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people manage daily work, how families make decisions, and where attention becomes available again.
Subscribe for more conversations with people already living with personal AI. Then comment with the household task you would hand to an AI house manager first.
Follow Cathryn on X: https://x.com/cathrynlavery
Follow Michael on X: https://x.com/msg
Links mentioned in this episode:
https://www.bestself.co/
https://openai.com/codex/
https://docs.anthropic.com/en/docs/claude-code/overview
https://github.com/cathrynlavery/voice-memo-organizer
https://www.apple.com/mac-mini/
https://openclaw.ai
Thanh Pham does not begin an AI setup with a long list of tools. He begins with one repeated task, one result a person can recognize, and one clear reason to use it again.
In this episode, Michael talks with Thanh about helping executives move from curiosity to practical use. Thanh demonstrates small workflows with obvious value, then adds more capability only when the person understands and trusts the result.
He also explains the difference between local and cloud AI. A local setup runs on a computer the person controls, which can provide more control over where data is handled. A cloud setup sends work to computing services run elsewhere, which may offer different capabilities but requires a deliberate decision about what information leaves the machine.
In this episode:
• Why Thanh teaches one useful skill before introducing a larger system
• How an automatic meeting briefing gathers email history, messages, and public research 30 minutes before a call
• How lead enrichment adds public details to a contact so a business can judge whether that lead is a good fit
• What an AI “agent” means here: software that can use approved tools and complete a sequence of steps
• Why Thanh gives one assistant responsibility for email, calendar, and meetings, while another handles research and project work
• The practical difference between running AI on your own computer and using a cloud service
• Thanh’s 10-80-10 model: define the job, let the system do the work, then review the result yourself
Thanh’s approach is easy to remember: choose one repeated task, make the first result immediately useful, and keep the final review with a person. His examples show that practical AI adoption depends less on presenting every possible tool than on giving each assistant a clear job and giving the person a result worth trusting.
About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in three places: how work is assigned, how decisions are made, and where people spend their attention.
Subscribe for more conversations with people already living with personal AI. Then comment with your biggest takeaway and the first repeated task you’d like to test.
Follow Thanh Pham on X: https://x.com/runsonai
Follow Michael Galpert on X: https://x.com/msg
Official links mentioned in this episode:
https://openclaw.ai/
https://github.com/NousResearch/hermes-agent
https://chatgpt.com/
https://claude.com/
https://openai.com/codex/
Matt Van Horn can turn a personal annoyance into a useful AI tool in a day. His method is simple: start with a problem you actually have, give the agent enough context, ship the smallest useful version, and let real users decide whether it should grow.
In this episode, Michael talks with Matt about three connected ideas: research, building, and publishing. Matt shows Last 30 Days, an open-source AI skill that searches recent posts on Reddit, X, and the web so an assistant can use what people are learning now—not only older articles. “Open source” means the instructions and code are public, so others can inspect them, use them, and suggest improvements.
Matt also demonstrates Printing Press. It examines how a website or online service works, then creates a command-line tool: a small set of written commands that an AI assistant can operate. His Flight Goat example uses that approach to compare nonstop flight options across multiple travelers and departure cities.
In this episode:
• Why old search results failed Matt when AI tools were changing week by week
• How Last 30 Days combines recent findings from Reddit, X, and the web
• How Matt built the first version during a day on a ski mountain
• What 50,000 GitHub stars represent—and what publishing made possible
• Why public work creates surface area for discovery, feedback, and contributions
• How Printing Press turns websites into tools an AI assistant can operate
• How Flight Goat compares complicated flight options across several travelers
• How Matt turns a personal annoyance into a tool, an article, or a public experiment
• Why the real lesson is the process, not the viral result
Matt’s system starts with a problem he personally wants solved. The agent helps him build it, publishing creates the surface area for discovery, and the community decides how large it can become.
About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people create, make decisions, and share their work.
Subscribe for more conversations with people already living with personal AI. Then comment with the problem you would try to solve in a day.
Links mentioned in this episode:
https://x.com/mvanhorn
https://github.com/mvanhorn/last30days-skill
https://printingpress.dev/
https://printingpress.dev/library/travel/flight-goat
https://github.com/openclaw/openclaw
https://openai.com/codex/
and X https://x.com/@alreadyhereshow
Sam Gaddis built an AI tool to help him and his wife fight better. It transcribes conflict in real time, tracks who is dominating the conversation, looks for destructive patterns, and can recommend a pause when things get too heated.
That deeply personal experiment is also the clearest window into how Sam builds with AI everywhere else: focused helpers, explicit access limits, and a person responsible for every consequential decision. In this episode, Michael sees how Sam uses Slack, email, meeting notes, repositories, nightly error checks, and voice capture to keep work moving without handing the system unlimited authority.
In this episode:
• How Sam’s relationship tool scores the way he and his wife handle conflict
• What the system learned when it showed Sam he was talking 60% of the time
• How the AI recognizes when a conversation is too heated and recommends a pause
• How Sam asks an assistant in Slack to find meeting notes, locate a client email, and prepare a reply in Gmail
• Why his default rule is “draft, don’t send”
• How Pointman gives his team a simple doorway into focused AI helpers
• How nightly checks identify failures and repair routine problems
• How Sam captures an idea by voice, researches it, and deliberately refines it before building
• Why his assistants can access his own software projects but not protected client work
Sam’s system is not one agent doing everything. It is a set of boundaries: draft before sending, personal repositories but not client repositories, fast capture before deliberate building, and a human still responsible for the relationship.
About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people work, make decisions, and direct their attention.
Subscribe for more conversations with people already living with personal AI. Then comment with the first safe experiment you would try.
Links mentioned in this episode:
https://runpoint.ai/
https://github.com/hermes-agent-org/hermes
https://openai.com/codex/
https://docs.anthropic.com/en/docs/claude-code/overview
https://www.granola.ai/