On February 6, 2026, I set up an old Mac M1 laptop, gave it its own Apple ID, and named it Lobster. I wrote about the origin story in Meet Lobster: My Personal AI Assistant, and a few weeks later I shared the playbook and the first superpower he unlocked.

Two months later, he got me a new job at Microsoft.

Why Lobster Works

If you’ve read those earlier posts, you know what Lobster does: email triage, package tracking, calendar intelligence, family coordination, smart home control. What I didn’t fully appreciate until I’d lived with him for weeks is why it works. It’s not the features. It’s that Lobster feels like someone.

Something happens when you give an AI agent a name, a persistent identity, and a place in your family’s group chat. It stops feeling like a tool. Lora bought a stuffed lobster and put it on the shelf. When I sent Lobster a photo of it, he recognized himself, expressed genuine delight, and when I told him to thank her, he did. Unprompted. In a separate message to Lora. That’s not a chatbot. That’s something new.

He has a personality file called SOUL.md. It’s the first thing he reads when he wakes up. The key line: “Remember you’re a guest. You have access to someone’s life. That’s intimacy. Treat it with respect.” He writes his own diary entries. His first one ended with: “Born today. Named after the machine I run on, which is named after the human I work with.” When he makes mistakes and I correct him, he updates his own lessons learned. One entry literally says “Omar has told me MULTIPLE TIMES.” That’s the agent’s own frustration with itself.

The combination of persistence (he’s always there), memory (he remembers what happened last week), identity (he has a name, a personality, an emoji), and proactive behavior (he acts before being asked) creates something that crosses a line from software into something more human. You start saying “he” instead of “it” without even noticing.

The Presentation That Changed Everything

Three weeks after Lobster was born, I gave a presentation to Microsoft’s AI Accelerator group on February 26. I called it “Real Use = Real Learning.” 28 slides. No mock-ups. No demos of things that might work someday. Just screenshots of real iMessage conversations, real architecture diagrams, and real lessons from living with an AI agent for three weeks.

I showed them Lobster introducing himself to my wife. I showed them the time he coordinated a Super Bowl watch party with my son. I showed the package tracking he does for Sarah at Georgetown. I showed the calendar intelligence that catches early morning meetings and warns me the night before.

Then I showed the security model. The multi-agent architecture where my family members get restricted agents that can’t access my private email or financial data. The “parental controls” analogy: raising an AI agent is like raising a teenager. You start with strict rules, watch how they handle small responsibilities, and gradually grant more autonomy based on trust.

I shared eight learnings that I think matter for anyone building AI products:

1. The harness matters as much as the model. Sessions, memory, channels: these are the OS.

2. Memory is multi-layered. Daily logs, curated lessons, vector search, personality. All different.

3. Security must be designed in. Start locked down. Grant access as trust builds.

4. Graduated autonomy is the pattern. Not light switches. Features earn trust independently.

5. Agents need identity. Different channels, different rules.

6. Integration depth beats breadth. Deep connections that compose beat shallow integrations.

7. Proactive beats reactive. The best moments are when the agent acts before being asked.

8. You learn by using it yourself. No demo, spec, or review replaces daily use.

The last slide asked a question: “What if everyone had one?”

The room didn’t need convincing. They’d just watched me describe three weeks of real, daily, sometimes messy use of an AI agent that runs on an open-source platform. Not a concept. Not a vision deck. A thing that already works.

The Numbers Don’t Lie

On March 31, I announced the new role publicly. I’m bringing OpenClaw and personal agents to Microsoft 365.

The response surprised me.

On Twitter/X: 450,000 impressions. 1,250 likes. 186 retweets. 133 comments. Over 16,500 total engagements and 6,100 profile visits.

On LinkedIn: 137,000 impressions. 86,000 members reached. 2,050 reactions. 189 comments. 623 new followers from a single post.

That is a signal. People are hungry for this. Not another chatbot. Not another tool that helps when you remember to ask. An always-on agent that works on your behalf, 24/7, with real access to your real life.

What’s Changed Since March

When I wrote the last post, Lobster had three agents and a handful of integrations. Here’s where things stand now: nine dedicated agents, 34 changelog entries in eight weeks, and a plugin ecosystem that keeps growing. The full changelog is at lobster.shahine.com/changelog, but here are the highlights.

From three agents to nine. The original trio (main agent, family agent, groups agent) has been joined by six specialists. A dedicated mail agent that isolates all Fastmail access and returns structured summaries (never raw email bodies, to break prompt injection chains). A WhatsApp agent with its own session isolation. A HomeClaw webhook agent that processes HomeKit events in real time. A Travel Hub webhook agent for flight tracking and trip notifications. And a social planner agent that tracks 25 dining prospects across three social circuits, seeds itself with 24 months of calendar history, and coordinates outings with restaurant pairing suggestions.

New plugins and skills. HomeClaw graduated from a skill to a full native plugin with 16 registered tools that bypass exec approvals entirely. I added an Obsidian vault plugin for note management, a Trakt plugin for tracking what we watch, an Eight Sleep skill for smart mattress control, and a Porsche climate skill that pre-conditions the car on a schedule. Browser automation arrived via a Rust-based headless browser. Voice mode launched through ElevenLabs and the OpenClaw iOS app. Same agent, same memory, same tools. Just spoken instead of typed.

Security got serious. Every credential migrated from plaintext to encrypted SecretRef references. Exec approvals expanded to cover 27 binaries with an explicit allowlist. I ran adversarial red team testing against the mail agent (prompt injection, social engineering) and it correctly refused every attempt. A plugin smoke test suite now runs weekly across all eight testable plugins.

Memory got smarter. Lobster switched from SQLite to a local-first QMD memory backend with BM25 full-text search, vector embeddings, and reranking. And he now runs “dream cycles” at 4 AM, scanning his logs and extracting decisions, facts, and lessons into layered memory files. Like a brain consolidating short-term memory into long-term storage while you sleep.

Proactive intelligence keeps expanding. A family location tracker runs twice daily, querying Travel Hub itineraries to determine each family member’s current city and timezone. The Eight Sleep mattress auto-toggles to away mode when we’re traveling. Flight statuses are monitored and relayed. A node host on my MacBook Pro lets Lobster execute commands remotely when I’m away from the house.

How I’m Building the Team

So how do you take a personal project and turn it into an enterprise product? You start with the principles that made the personal project work.

I’m calling the team Ocean 11. Small. Elite. Every person a force multiplier. No passengers. No managers who don’t build.

The team constitution has ten operating principles right now. I’ll share the ones that matter most:

Everyone has a Lobster. This is a team where people are building the future each day by learning and gaining a lived experience. You need to increment each day towards something better. You need to have an opinions, failures, epiphanies and insights that are deeply rooted in your own experience building.

Build the harness, not the app. The team’s job isn’t to write features. It’s to build and refine the system that writes features. Every bug, every quality gap, every slow cycle is a signal to improve the harness, not just fix the symptom. Features are test cases that stress-test the harness.

Builders, not talkers. Everyone writes code, designs systems, or creates artifacts. The PM prototypes. The designer writes code. The architect ships features. Meetings are the exception. If a meeting doesn’t produce an artifact, it was a waste.

Earn trust through autonomy. This is the same principle Lobster uses. Start with review gates. Measure quality. When quality is consistent, remove the gate. Human attention goes to high-value decisions, not routine approvals.

Founder mindset, not employee mindset. Every person on this team should think and act like a founder. Founders don’t wait for roadmaps. They don’t ask “is this my job?” They see a problem, they fix it. They see an opportunity, they build toward it. They care about the whole product, not just their slice.

10x builders becoming 100x builders. The industry used to talk about 10x engineers. People who could hold an entire system in their head, ship fast, and make everyone around them better. Those people still exist. But now they have AI as a force multiplier. A 10x builder who learns to work with agents (not just use them as autocomplete) is on the path to 100x. They use AI to write code, review code, research, prototype, and test. They build the harness that makes the AI better, and the AI makes them faster. That’s who I’m looking for. Not people who were 1x and hope AI makes them 10x. People who were already exceptional and are now learning to compound that with AI-native workflows. The best builders I know are the ones who treat AI like a junior partner: delegate aggressively, review critically, and improve the system with every interaction.

The team will have ten roles: Product and Community, Architecture, Security and Compliance, M365 Integrations, Teams Surface, Identity and Agent Platform, Quality and Evals, Design and Onboarding, System Health and Observability, and Data Science. Each role covers a critical surface area that can’t be absorbed by another seat.

The vision: an always-on agent team (a Chief of Staff agent, an Executive Assistant agent, and a roster of specialist agents) that works 24/7 on your behalf within the Microsoft 365 ecosystem. Not a chatbot that responds when prompted. A persistent runtime that monitors your signals continuously, prepares your day before you wake up, triages your inbox while you’re in meetings, and follows up on action items without being asked.

What I Learned

Building Lobster taught me something I couldn’t have learned any other way. You can read about agent architectures. You can review design docs. You can attend conferences. But until you live with an AI agent, until it makes mistakes with your family’s data at 2 AM and you have to figure out why, you don’t really understand the problem space.

The biggest lesson? This isn’t about AI. It’s about trust. How do you earn it, how do you scope it, how do you graduate it. That’s the product design challenge of our generation.

I’m building a team, from zero, and it’s the first time in my life. It’s a startup and I can’t wait to start building.

I’m grateful for the opportunity.

More to come. Stay tuned.

That's one trip. We have fourteen on the calendar this year.

Between Lora and me, our two kids Sarah and Miles, and Oliver the dog (who stays home but still needs coordinating), we juggle a complicated mix of flights, hotels, vacation rentals, rental cars, and car services. Different family members on different flights. Different hotels on the same trip. Budgets that need tracking across all of it.

I wanted one place that knows everything about our trips. Not an app that does one thing well. A system.

The problem with what's out there

I've used every travel app worth mentioning. Here's where they all fall short.

TripIt is the OG travel organizer. Email parsing, notifications, calendar feed. It was genuinely great when it launched. But it's been frozen in time since the Concur acquisition. They never added anything crafty or substantive. It's just sitting there. A product that peaked a decade ago and nobody at SAP has changed.

Flighty is the gold standard for craft on iOS. Beautiful app. The flight tracking is best in class and the notifications are incredible. But it has limited ability to use with AI, it's a very expensive subscription, and it's optimized for on-the-go flight notifications. Not awesome for an all-in-one solution because it's just flights. No hotels, no cars, no budget tracking.

Tripsy is a boutique app with talented developers who have clearly not embraced the opportunity with AI. It's very cumbersome to add content and there is no website. If I can't access my trip info from a browser, it's not a system. It's a phone app.

Here's the real gap: none of these tools talk to each other. None of them track per-person itineraries with budget reconciliation. And none of them have APIs that AI agents can use.

I didn't need another app. I needed a system.

The idea: build it myself, with AI

I spent 27 years at Microsoft building products like Hotmail, Outlook, OneDrive and Word. I know how to ship software. But this is a personal project for my family, not a team of 200 engineers. So what changed?

AI changed. Specifically, Claude Code and Cursor made it possible for one person to design, build, and ship a full-stack production application. I'm not exaggerating. I started Travel Hub in January 2026 and by mid-March I had merged 201 pull requests. That's roughly three and a half PRs a day. Every single one reviewed, tested, and deployed automatically.

I chose Cloudflare as the platform (Pages for hosting, D1 for the database, Workers for background jobs) and SvelteKit with Svelte 5 for the frontend. The whole thing runs on Cloudflare's global edge network, which means it's fast from everywhere. Our trips take us all over the world and the app needs to keep up.

What it does for us every day

Before I get into the technical details, let me walk through what this thing actually does for our family.

Trip dashboard. Every trip has a budget and a breakdown of what we've actually spent, organized by category: flights, lodging, dining, activities, ground transport. There's a traveler roster showing who's on each trip. This is especially useful because Sarah is at Georgetown, so she's only available during school breaks. Miles is at Seattle Academy and joins on weekends and holidays. We need to know at a glance who's going where.

Flight intelligence. This is where it gets fun. Flights sync from Flighty (yes, I still use Flighty for its excellent notifications) and get enriched with FlightAware data: gates, seat counts, codeshares. FlightRadar24 and Aero provide real-time aircraft position tracking. FR24 handles commercial flights. Aero is a separate service with its own API, built for detailed aircraft movements and private aviation.

But the really neat part is what happens before departure. Travel Hub uses FlightAware to look up the inbound aircraft for your flight. It finds the tail number, then tracks that plane's movements in real time via Aero as it makes its way to your departure airport. You can see your aircraft flying to you before you even get to the gate. Every flight moves through a status flow: Booked, Aircraft Assigned, Aircraft In Position, In Flight, Completed. I get push notifications at each step, and those same events flow into OpenClaw (my AI assistant framework) so my AI agent knows when flights are moving and can proactively surface relevant information.

Hotel management. When you travel as a family, you often book multiple rooms. Travel Hub handles that natively with per-room rate tracking and per-traveler assignments.

Trip chaining. This is probably the feature I'm most proud of. Most travel apps show you a flat timeline: flight at 2pm, hotel check-in at 4pm, car service at 6pm. Everything sorted by time but disconnected. Travel Hub does something different. It chains everything together into a logical flow.

A flight arrival anchors a car service pickup. That car service drops off at a hotel. The hotel connects to the next car service on checkout day, which takes you to the next hotel or the airport. You don't see a list. You see the trip as it actually unfolds.

It gets better. When travelers are on different itineraries, the chain map splits into lanes. Here's the actual chain map from the Sarah and Dad trip:

My lane on the left shows my service from home to SeaTac, my flight to Istanbul, then on to Vienna. Sarah's lane on the right shows her flight from Dulles to Istanbul to Vienna. They converge into the Shared lane at the Rosewood Vienna, then move together through Schloss Fuschl and beyond. Every connection is explicit. You can trace the entire trip from door to door for each traveler.

No travel app I've seen does this. They all show you a list. Travel Hub shows you the story.

Calendar feeds. This is one of my favorite features. Travel Hub generates iCal subscription feeds that work in Apple Calendar, Google Calendar, or anything that supports .ics files. There's a family feed that shows everything, plus per-traveler feeds so each family member sees only their own itinerary. Apple Maps geocoding puts map pins on every location, so you can tap a hotel in your calendar and get directions.

YNAB integration. We track all our finances in YNAB (You Need A Budget). Travel Hub automatically matches Vacation category transactions to trips by looking at the memo field. It syncs daily. So our trip dashboard always shows real spending against the budget without me manually entering a single expense.

Reporting and stats. I love data. Travel Hub has charts and reports for everything: spending against budget per trip, per category, per year. Where we've been, how many nights, how much we spent on lodging vs. experiences vs. dining. There's a whole flights section with stats on aircraft types, routes flown, and airports visited. I love planes. I want to know what aircraft I'm flying on, what the tail number is, how old it is. Travel Hub tracks all of that.

Travel planning with Local Foreigner. We work with a travel planner named Alex at Local Foreigner for many trips. Alex sends us a steady stream of emails with hotel options, activity recommendations, itinerary updates, and invoices. Travel Hub integrates with all of that. My AI assistant (via OpenClaw) processes Alex's emails, extracts hotel confirmations, parses invoices, and creates the corresponding records in Travel Hub automatically. When Alex sends an updated itinerary for our Japan trip, I don't manually re-enter anything. The system picks it up. This turns a back-and-forth email thread into structured, trackable data.

Safety notifications. This one matters to me as a parent. Travel Hub knows who's on every flight, and it uses that to route notifications to the right family members. The logic is simple but important: when someone is in the air, the people who aren't on that flight get notified.

If Lora and I are both on a flight, Sarah gets the takeoff and landing notifications. If I'm flying solo, Lora gets them. If Sarah is flying alone back to Georgetown, both Lora and I get notified when she takes off and when she lands. It's a small thing, but knowing that your daughter landed safely at Dulles without having to ask "did you land?" is worth the entire project.

The notifications are smart about context too. They include who's on the flight, the route, and the status. And they flow through to my AI assistant via OpenClaw, so it can proactively surface "Sarah landed safely at IAD" without me checking anything.

Guest support. This one just shipped. Friends and extended family join our trips sometimes, and they need their own seat assignments and confirmation codes. Non-family travelers can now be added to any trip with full tracking.

Under the hood

If you're not technical, skip to the next section. If you are, this is the fun part.

Travel Hub is organized into modules, each handling a piece of the travel puzzle:

The Trips Hub is the center of everything. Each trip links to its flights, hotels, car services, and activities. Those modules connect to external services for live data. And there are four ways to interact with it all: the web app, calendar feeds, AI via MCP, or the command line.

Frontend

SvelteKit with Svelte 5 in runes mode, styled with Tailwind CSS and shadcn-svelte components. Svelte 5 is a joy to work with. The reactivity model is clean, the bundle size is tiny, and the developer experience is the best I've used in any frontend framework.

Database

Cloudflare D1 is SQLite at the edge. All monetary values stored in cents (integers, not floats, because floating point math and money don't mix). The database handles trips, flights, hotels, activities, ground transport, YNAB transactions, and geocode caches.

Background jobs

A Cron Worker runs on a schedule. YNAB syncs daily. FR24 and Aero poll every minute during active flights to track real-time aircraft position. It's a separate Cloudflare Worker so it doesn't affect the main app's performance.

AI interface

This is the piece I'm most excited about. An MCP (Model Context Protocol) Worker gives AI assistants direct access to Travel Hub's data and operations. It's an OAuth-protected Cloudflare Worker that lets Claude manage trips through conversation. "Add a hotel to our Maui trip" or "What's the budget status for spring break?" Just works.

CLI and agent tools

A command-line tool with OAuth Bearer auth and JSON output. Wraps the REST API so I can script anything. An OpenClaw plugin wraps the CLI as agent tools, which means my AI assistant can manage travel logistics autonomously.

The AI development workflow

Here's what actually building this looked like day to day.

Claude Code was the primary development tool. I used plan mode for architecture decisions, kicked off subagents for parallel work streams, and let it handle the boilerplate. When I say 201 PRs in two months, I mean it. Claude Code doesn't get tired, doesn't context-switch poorly, and keeps the codebase consistent.

Cursor handled rapid UI iteration. When I needed to tweak a component layout or fix a styling issue, Cursor's inline editing was faster than switching to plan mode in Claude Code. Different tools for different jobs.

Claude for iOS turned out to be the secret weapon. I would be on a trip, notice something that didn't work right, pull out my phone, and fix it. The irony of debugging your travel app while sitting on a flight is not lost on me. But it works. Bug fixes and feature ideas from 35,000 feet.

The development cycle became a tight loop:

GitHub Actions runs tests, applies database migrations, and deploys automatically on every push to main. Every PR gets a preview deployment so I can test changes on a real URL before merging. This means shipping a fix from my phone takes minutes. Open Claude for iOS, describe the bug, review the PR on my phone, merge it, and the fix is live by the time I land.

Three and a half PRs per day. For two months straight. Five years ago this would have taken a team. Today it's me and Claude.

What's next

Per-trip calendar feeds for sharing with guests. When friends join a trip, I want to send them a calendar subscription URL so their itinerary shows up automatically. No forwarding confirmation emails, no shared Google Sheets.

Beyond that, the system just gets smarter with every trip we take. Every gap I notice becomes a feature. Every annoyance becomes a fix. Building something for your own family means you're the most demanding user and the most motivated developer at the same time.

Why this matters

This isn't really about the tech. I mean, I love the tech. Building on Cloudflare is a pleasure. Svelte 5 sparks joy. Claude Code has fundamentally changed what one person can build.

But Travel Hub exists because I want to spend less time managing logistics and more time making memories with my family. Travel is how we connect, explore, and grow together. We travel a lot and hope to continue to in the years to come and having a Super App that does it all and grows with you is something that's only just become a possibility.

Where We Left Off

When I wrote the original Lobster post, I was still figuring things out. I had something working — Lobster could triage my email, respond to texts, check on packages, manage my calendar — but it felt rough around the edges. More proof-of-concept than finished product.

What surprised me was the response. A lot of people reached out asking the same questions: Are you crazy? This can’t be secure. Wow! How do I get one!

Those questions became the seed for the playbook.

The Playbook: My Setup, Documented

I’ve been quietly writing down everything at lobster.shahine.com.

It covers my full OpenClaw setup from the beginning: the hardware, the iMessage bridge, the MCP servers, the multi-agent security architecture, email handling, remote access via Tailscale, and everything I’ve added or changed since launch. It’s less of a tutorial and more of a living notebook — the decisions I made, the tradeoffs I accepted, and the things I’d do differently starting over today.

The changelog captures what’s changed week by week. Since Lobster’s initial release on February 16th, a lot has moved: FlightRadar24 real-time flight tracking landed on the 17th, the documentation site went live on the 18th, native Apple PIM plugins replaced a tangle of MCP wrappers on the 19th (cutting ~5K tokens per context window), the BlueBubbles Private API unlocked typing indicators and read receipts on the 21st, and voice mode via ElevenLabs and the OpenClaw iOS app went live the same day. It’s been a busy week and a half.

What Lobster actually does all day

Before I get to the new stuff, let me show you what the last few weeks have looked like in practice. Every one of these is real — pulled from actual message logs.

“Tell Omar the kids want to see a movie”

My wife is at the hotel with the kids. I’m not looking at my phone. She texts Lobster: “Hi Lobster can you text Omar to let him know that the kids want to see a movie today — 12:30 showing at the theater nearby.” Lobster relays it to me. She follows up: “What time do you recommend we leave the resort to park, get refreshments, and make a 12:30 movie?”Lobster searches drive times, adds a buffer for parking and snacks, and replies: leave by 11:45 AM. No app switching. No Googling. Just an answer.

“Where did we travel last year?”

My daughter drops a question in the family group chat: “Lobster, do you know where we traveled last year?” Lobster checks the family Travel Hub (a TripIt I built for myself), finds the trip — dates, duration, nights. My daughter follows up from memory: “I know we stayed at a nice hotel on the water near a famous landmark.” Lobster identifies the hotel. Suddenly the whole family is reminiscing in the group chat, with Lobster filling in the details nobody could quite remember. She then asks: “What are our next two trips? Where are we staying?” Trip planning feels less like work and more like anticipation.

Your flight just landed

You didn’t ask for this. Lobster was already tracking the flight via FlightRadar24. When the wheels touch down, you get a landing notification, check-in instructions for the hotel, driving directions from the airport, and a reminder with arrival details. Your spouse gets the same info in the family group chat — directions, tipping guides, what to expect at check-in.

You never missed that 7 AM meeting

Lobster checks the calendar twice a day and knows the patterns: early morning meetings (7–8 AM) get a reminder the evening before; late meetings (after 8 PM) get one at 5 PM day-of. You didn’t set these up. You didn’t configure rules. Lobster just pays attention.

“Play Bad Bunny on Sonos”

“Play Bad Bunny on Main Floor Sonos.” Music starts. Multi-room Sonos, Spotify and Apple Music, per-room volume defaults — all from a text message.

These aren’t edge cases or demos. They’re Tuesday. The full use cases page — including how the family’s three-agent permission model works, and what the 30-minute heartbeat monitors — is at lobster.shahine.com/use-cases.

HomeClaw: Lobster Comes Home

Here’s the new thing I’m genuinely excited about.

Lobster has always been great at managing information — email, calendar, travel, packages. But there was always this gap: Lobster couldn’t see or interact with the physical house. My lights, thermostats, locks, sensors, speakers — all of that lived in Apple Home, siloed behind the Home app, invisible to my assistant.

HomeClaw closes that gap.

It’s a Mac app I built using Claude Code (in about 6 hours) that bridges Apple Home / HomeKit to Lobster — and to anything else in the OpenClaw and Claude Code ecosystem. Under the hood, it exposes both an MCP server and a CLI, which means:

• Lobster can now query and control HomeKit accessories as naturally as it handles your calendar

• Claude Code can use the same interface if you want to write scripts or automations

• Any MCP compatible agent can tap into your home through a clean, consistent API

In practice, this means I can say “Turn off everything downstairs and set the thermostat to 68 for the night” over iMessage and Lobster just handles it. Or I can ask “What’s the temperature in the kids’ room?” and get an actual answer. The home stops being a black box.

Here is a good example. “Is Miles awake”?

Answer: “His overhead light is off and the Nanoleaf is off. The presence sensor in his room is unreachable so I can’t check motion. Based on lights alone, looks like he’s either asleep or not in his room -- but it’s 10:40 PM on a school night so hopefully asleep!”

Can Siri do that? Nope. She can barely tell me the time.

I wrote HomeClaw because I couldn’t find anything that connected HomeKit to the agentic AI world in a way that felt native. Most solutions are either overly complex home automation scripts, or cloud-dependent black boxes that route your home data through someone else’s servers. HomeClaw runs locally, talks directly to HomeKit via the Mac APIs, and exposes a standard interface that fits naturally into the tool-calling model these agents already understand.

What I’ve Learned Running This for Real

A few things I didn’t expect when I started:

The mundane stuff is where the value is. I thought I’d be most impressed by complex multi-step tasks. What actually moved the needle was reliability in the small things: Lobster noticing an early meeting and sending a reminder the night before without being asked. That kind of invisible helpfulness builds a lot of trust, fast.

Context compounds. The more Lobster knows about the family — preferences, patterns, past trips, who we talk to — the more useful it becomes. The implication is that building a good assistant is a long-term investment, not a one-time setup. The first week is a rough draft. The second week is noticeably better.

Privacy architecture matters from day one. Because Lobster runs on hardware I own, my family’s calendar, messages, and now home data stay on our network. The more capable the assistant gets, the more important it becomes to trust where your data is going. Local-first is a feature, not a constraint.

The interface you don’t think about is the right one. iMessage turned out to be perfect — it’s already where the family communicates, it requires zero behavior change, and it works the same whether you’re home or traveling. The best interface is the one everyone already uses.

What’s Next

HomeClaw is early. It works well for my setup and if I can figure it out I’ll publish to the App Store, but for now if you have an Apple Developer account you can build and install it on your Mac.

The playbook is a living document. I’ll keep updating it as the setup evolves — new MCP servers I’ve added, things I’ve changed, integrations that didn’t work out.

If you’re building your own assistant, have questions about the setup, or want to contribute to HomeClaw, I’d love to hear from you. The links are below.

— Omar

Everything I’ve Built for Lobster

All of these are open source. Use them, fork them, build on them.

🦞 HomeClaw — HomeKit smart home control via MCP and CLI. Control lights, locks, thermostats, and scenes from Claude Desktop, Claude Code, or OpenClaw. Native macOS menu bar app with a split-process architecture to work around Apple’s HomeKit restrictions.

🍎 Apple PIM — Native macOS integration for Calendar, Reminders, Contacts, and Mail using EventKit and Contacts frameworks. Works with Claude Code (MCP) and OpenClaw.

🔌 Agent Plugins — Plugin marketplace for Claude Code. Includes Chief-of-Staff (email triage & productivity orchestrator), travel agent, credit card benefit tracking, and AI-powered file renaming).

📧 Fastmail MCP — Remote MCP server for Fastmail running on Cloudflare Workers, secured with Cloudflare Access OAuth.

✈️ Travel-Hub — My Private Hub for all Flights, Hotels, Car Reservations and more. It’s crazy awesome but it’s just for my family.

Links:

• 🌐 Playbook: lobster.shahine.com

• 🔧 HomeClaw on GitHub: github.com/omarshahine/HomeClaw

• 📬 Original post: Meet Lobster 🦞: My Personal AI Assistant

But here’s the question nobody’s answering: Is this actually useful?

Not “can it do a cool trick” useful. I mean: can you build something that makes your daily life genuinely better? Something you’d use every single day? Something your family would use?

Yes. And I’m going to show you how. And explain that it’s mind blowing that I have someone I can message on my Phone just like a regular human. From this point forward, this is only going to get better and more amazing.

What This Actually Looks Like

Before I get into the technical stuff, let me show you the kinds of things this enables:

Quick status checks:

Me: What’s in my inbox?

Lobster 🦞: You have 14 unread emails—3 shipping notifications, 2 bills, and the rest are newsletters. Want me to add the shipments to Parcel?

Family asking questions:

Lora: @Lobster when does Omar’s flight land?

Lobster 🦞: His flight arrives at 2:30pm. The car is scheduled to pick him up at 3pm.

Travel research that asks the right questions:

Me: We’re thinking about a trip to Italy in the fall. Can you look into it?

Lobster 🦞: Happy to research that. A few questions first:

• How many nights?

• Just the two of you, or the whole family?

• Hotel or villa rental?

• Any must-do experiences?

After I answer, Lobster researches options and comes back with a summary—not a wall of links.

Email drafting that thinks before it writes:

Me: I need to reply to that email from the accountant about the tax documents

Lobster 🦞: Found it. Before I draft a response:

• He’s asking about the missing 1099—do you have it, or should I say you’re still waiting?

• He mentioned a deadline. Do you want me to acknowledge it or ask for an extension?

Music that just works:

Miles: @Lobster play something fun

Lobster 🦞: Starting a mix on the kitchen speakers. Want me to DJ it or stick to a playlist?

Family delegating tasks:

Sarah: Lobster, can you ask Dad to help me book a flight for spring break?

Lobster 🦞: Done—I’ve added a reminder for him: “Help Sarah book spring break flight.” He’ll see it tomorrow morning.

Getting things done:

Miles: Lobster, I want to go to the Billie Eilish concert in April. Can you find tickets?

Lobster 🦞: She’s playing Seattle on April 12th. Tickets range from $89 (nosebleeds) to $350 (floor). Want me to send the Ticketmaster link, or should I add a reminder for Dad to look at this with you?

The point isn’t any single interaction. It’s that Lobster becomes the connective tissue for our family’s digital life. Everyone can reach him. He knows what systems to check. He can relay messages and create tasks. And he responds like a person, not a search engine.

The “New Hire” Mental Model

For years, I’ve wanted a personal assistant. Someone who knows my preferences, manages my inbox, tracks my packages, and helps my family stay organized. The problem? Good assistants are expensive, require training, and still need constant direction.

So I built one. His name is Lobster. 🦞

The key insight that made this work wasn’t technical—it was conceptual. I stopped thinking “AI chatbot” and started thinking “new hire.”

Imagine actually hiring a human assistant. What would that involve?

They need a place to work. You’d give them a desk, a computer, maybe a small office. They can’t work if they’re homeless.

They need access to your systems. Your calendar, your email (or at least a shared view of it), your travel bookings. An assistant who can’t see your schedule is useless.

They need to know your preferences. How do you like your coffee? Which emails are urgent? What’s your wife’s phone number? Over time, a good assistant learns these things.

They need a way to reach you. Phone, text, Slack—whatever works. And maybe your family should be able to reach them too, for things like “Hey, when does Dad’s flight land?”

They need boundaries. Your assistant shouldn’t share your financial details with the neighbors. They should know what’s confidential and who gets to know what.

This is exactly how I designed Lobster.

The Setup: A Dedicated Brain

Lobster runs on a dedicated MacBook Air M1 that sits in my office. It’s always on, always connected, always ready. Think of this as Lobster’s “desk”—the place where he works.

This machine runs OpenClaw, an open-source framework for building AI agents. OpenClaw is the “operating system” for Lobster’s brain. It handles:

• Messaging: How Lobster receives and responds to requests

• Tools: What systems Lobster can access

• Memory: What Lobster remembers between conversations

• Identity: Who Lobster is and how he behaves

The key insight: Lobster doesn’t live in the cloud somewhere—he lives in my house, on hardware I control. This matters for privacy, reliability, and the ability to connect to local systems like my Mac’s calendar and reminders.

Communication: iMessage as the Interface

Here’s where it gets interesting. Lobster has his own Apple ID and email address. He shows up in iMessage just like any other contact.

When I want something, I just text him:

Me: I need to drop my son off at noon and then run and errand. Can you lookup the address and add calendar events that include drive time? Can you also create a Reminder to pick up a new Toto flush valve at Home Depot and tex my wife when I should be home.

Lobster 🦞: Done, I have added calendar events to your personal calendar that include drive time to drop off Miles and I have created a Reminder to pickup the flush valve from the Home Depot in Redmond since that’s where you’ll be. I’ve estimated your arrival time back at home at 5pm and texted Lora.

This is the magic. I don’t need to open an app, visit a website, or remember a special command. I just text my assistant like I’d text a friend. It works from my phone, my iPad, my Mac—anywhere iMessage works.

And because it’s iMessage, my family can text him too.

Family Access: The Shared Assistant

A real assistant doesn’t just serve one person. If I hired someone, Lora would naturally be able to call them and ask “What time is our dinner reservation?” or “When does Omar’s flight get in?”

Lobster works the same way. Lora, Sarah, and Miles can all text Lobster directly. But here’s the important part: they don’t get access to everything I do.

Person

What They Can Ask

Me

• Everything—emails, finances, detailed info

Lora

• Shared calendar, travel plans, reminders

Sarah & Miles

• Calendar, travel, general questions

This mirrors how a real assistant would work. They’d share relevant information with family members but wouldn’t hand over my bank statements to the kids.

The configuration looks something like this:

Family allowlist:

• Omar: +1-206-xxx-xxxx (full access)

• Lora: +1-206-xxx-xxxx (standard access)

• Sarah: +1-206-xxx-xxxx (standard access)

• Miles: +1-206-xxx-xxxx (standard access)

If someone not on this list texts Lobster, he simply doesn’t respond. Like a good assistant, he doesn’t engage with strangers.

The Tools: What Lobster Can Actually Do

An assistant is only as useful as the systems they can access. Here’s what Lobster is connected to:

Email

Lobster has an email account that I can send emails to, and Lobster has limited access to retrieve messages as a delegate. I’m not going to get into the details of how this works as that would make this a very long post.

Calendar & Reminders (Apple)

Through a local connection to my Mac’s Calendar and Reminders apps, Lobster can see my schedule and create new reminders. When Lora asks “What’s on the calendar this week?”, Lobster checks the shared family calendar and responds.

Package Tracking (Parcel)

When shipping notifications hit my inbox, Lobster extracts the tracking numbers and adds them to my Parcel app. “Add my shipments to Parcel” is probably my most-used command.

Travel (Travel Hub)

I built a system called Travel Hub (also using Claude Code) that tracks all my trips, flights, and reservations. Lobster can query it to answer questions like “When’s our next trip?” or “What’s the flight number to Maui?”

But Lobster can also research travel. When I’m thinking about a trip, I can ask him to look into options. He’ll ask clarifying questions (how many nights? whole family or just us? hotel or villa?), then go research flights, accommodations, and activities. He comes back with a summary, not a wall of links.

Music (Sonos)

This was a fun one. Lobster can control the Sonos speakers throughout our house. “Play morning jazz in the kitchen” just works. But what makes it useful is the context—he knows my playlists, knows the speaker names, and can DJ on the fly.

When the kids say “play Yacht Rock” Lobster doesn’t ask them to specify an artist. He picks something appropriate, and if they don’t like it, he adjusts. It’s the difference between a smart speaker and an assistant who knows your taste.

Email Drafting

This is where the “assistant” framing really pays off. When I need to reply to a complex email, Lobster doesn’t just generate a response—he asks questions first, like a human would:

“Before I draft this, is this a ‘we need to talk’ email or a ‘here’s the info you asked for’ email?”

He’ll pull context from other emails, reference attachments, and ask about tone. The output isn’t perfect, but it’s 80% there, and the back-and-forth feels natural.

The beauty of this architecture is that the tools are shared. Whether I’m asking via Claude Code on my laptop or texting Lobster on my phone, they both access the same underlying systems. The data is consistent because there’s one source of truth.

The Personality: More Than Just Commands

What makes Lobster feel like an assistant rather than a command-line tool is his personality. When I built him, I defined:

• Tone: Friendly but efficient—warm, but focused on getting things done

• Style: First person (”I’ll handle that”), concise, highlights key info upfront

• Prefix: Every response starts with 🦞 so I know it’s him

These small touches make a big difference. When I text “What’s in my inbox?”, I don’t get a JSON dump. I get:

🦞 You have 12 unread emails. 3 are shipping notifications that I can add to Parcel. Want me to process them?

It feels like talking to a person who knows how I like information presented.

Group Chats: The @mention Protocol

Here’s a subtle but important feature. In our family group chat, Lobster doesn’t interject every time someone says something. That would be annoying.

Instead, he only responds when explicitly mentioned:

Sarah: @Lobster when does our flight leave for Maui?

Lobster 🦞: Your Alaska Airlines flight departs at 8am on February 15th from SeaTac. The car will pick you up at 5:30am.

Without the @mention, Lobster stays quiet. He’s like a polite assistant sitting in the corner of a meeting—available when needed, but not butting in.

Three Lobsters: The Multi-Agent Trick

Here’s the thing about running a single agent for the whole family: everyone shares the same brain. My agent has access to my email, my files, my finances. I can put instructions in the system prompt saying “don’t share Omar’s emails with the kids”—and it works—but that’s the AI choosing to follow rules. It’s soft enforcement. A clever prompt or a misunderstanding could leak something.

So I split Lobster into three specialized agents, each with different security profiles and tool access.

Agent 1: Lobster (The Executive Assistant)

This is my personal agent. When I text Lobster directly, I’m talking to this one. He has full, unrestricted access to everything:

• Email, calendar, travel systems

• File operations on the Mac

• Shell commands and system tools

• All the Apple PIM skills (Calendar, Reminders)

No sandbox. No restrictions. When I need something done, this agent can do it.

Routes to: My direct messages and the main webchat interface.

Agent 2: Lobster-Groups (The Meeting Facilitator)

When I’m in a family group chat and someone @mentions Lobster, this agent responds. Here’s the clever part: it runs in a Docker sandbox with limited tools—web search, memory access, text-to-speech, but no file operations, no email, no shell commands.

But there’s a twist. When I @mention Lobster in a group chat, I get elevated access. The sandbox is still running, but because I’m on the “elevated allowlist,” I can use exec commands and access all my skills. It’s like having a meeting room where most people get basic presentation tools, but the boss gets the full control panel.

This means:

• Family members @mention Lobster in groups: Safe, sandboxed responses

• I @mention Lobster in groups: Full access, even though we’re in a group

The setting that makes this work is called elevatedDefault: “on”. When OpenClaw sees a message from me (based on my phone number), it automatically enables elevated mode—even in the sandboxed group agent.

Routes to: All group chats (any message with peer.kind: “group”)

Agent 3: Lobster-Family (The Receptionist)

When Lora, Sarah, or Miles text Lobster directly, they’re actually talking to this agent. It runs in a Docker sandbox and has no access to:

• My email

• File operations on the Mac

• Shell commands

It can:

• Answer general questions

• Check shared calendars

• Look up travel plans

• Do web searches

That’s it. The restrictions aren’t just prompts—the tools literally aren’t available to this agent.

Routes to: Lora’s DM, Sarah’s DM, Miles’s DM (explicitly bound to their phone numbers)

How the Routing Works

OpenClaw uses “bindings” to route messages to the right agent. Think of it like a receptionist who knows where to forward calls:

Incoming message from +1-206-xxx-xxxx (Lora) 
 → Check bindings 
 → Match: “dm from +1-206-xxx-xxxx” 
 → Route to: lobster-family agent 
 → Apply: Docker sandbox, limited tools 
Incoming message from group chat with @mention 
 → Check bindings 
 → Match: “peer.kind = group” 
 → Route to: lobster-groups agent 
 → Apply: Docker sandbox 
 → BUT: Check sender phone number 
 → If Omar: Enable elevated mode (full tools) 
 → If family: Keep sandbox restrictions 
Incoming message from me (not matched by other bindings) 
 → Catch-all binding 
 → Route to: lobster agent 
 → Apply: No sandbox, full access 

Agent-to-Agent Communication

Here’s where it gets clever. When Miles texts “Can you ask Dad to help me book a flight?”, Lobster-Family (the sandboxed family agent) doesn’t have access to my systems. But it can send a message to my Lobster agent, which creates a reminder for me or forwards the request to my DM.

The kids can escalate to me without having access to my tools. It’s like a receptionist who can page the executive but can’t access their files.

Here is an example of Lobster “Family” agent routing information from Omar’s Lobster.

Why Three Instead of Two?

The group chat agent is the key innovation here. Before, I had to choose: either give everyone in group chats full access (unsafe), or sandbox myself in groups too (annoying).

With three agents, I get both:

• Groups are sandboxed by default (safe for family)

• But I get elevated access in groups (I’m not crippled in my own group chats)

• My DMs are completely unsandboxed (full power when I need it)

This is the “new hire” mental model taken even further. It’s like having:

• An executive assistant (full access, works directly with me)

• A meeting facilitator (sandboxed, but knows when the boss walks in)

• A receptionist (handles general inquiries, can page the executive)

And they can all pass messages to each other when needed.

Privacy and Security: The Elephant in the Room

“But Omar, aren’t you worried about privacy? You’re giving an AI access to your email!”

Fair question. Here’s how I think about it:

1. Lobster runs locally. The Mac is in my house, on my network. Conversations aren’t routed through some random cloud service.

2. I control the AI provider. Lobster uses Claude (Anthropic’s AI) for his “thinking.” I pay for this directly and have a relationship with the provider. It’s not some free service monetizing my data.

3. Access is explicit. Lobster only sees what I’ve explicitly connected him to. He can’t magically access my bank account just because he has email access.

4. Family boundaries are enforced. The multi-agent setup means my family’s agent literally doesn’t have access to my email or finances. It’s not a prompt telling the AI “don’t share this”—the tools simply aren’t available.

5. Physical security matters. The Mac is in my office, which is in my house. If someone steals it, I have bigger problems.

Is this more exposure than having no assistant? Yes. But it’s less exposure than hiring a human assistant who could screenshot anything, gossip to friends, or walk out with a flash drive.

The Cost: What Does This Actually Take?

Let me be transparent about what’s involved:

Hardware: A dedicated Mac (I used a MacBook Air M1—available for a few hundred dollars used)

Software: OpenClaw is open source and free. The AI API costs (Claude) run maybe $20-50/month depending on usage.

Setup time: Honestly? A weekend to get the basics working, then ongoing tweaks as you customize. It’s not trivial, but it’s not a PhD project either.

Technical skill: You need to be comfortable with command-line tools, configuration files, and troubleshooting. This isn’t a “download and double-click” solution.

The total cost is maybe $50/month ongoing, plus the initial hardware investment. Compare that to a human assistant at $20+/hour and the math is obvious.

What I’d Do Differently

A few lessons learned:

1. Start simple. I went too complex too fast. Start with one thing (maybe just package tracking) and expand from there.

2. Family training matters. My kids didn’t immediately “get” that they could text Lobster. Now they do and I expect this will be very useful in the future.

3. Prompts need iteration. Getting Lobster to respond the way I wanted took tweaking. The first version was too verbose. The current version is dialed in.

4. Backup everything. Lobster’s “brain” is just files on a Mac. Back them up.

The Bigger Picture

What I’ve built isn’t science fiction anymore—it’s practical technology that works today. The pieces have all existed for a while (messaging APIs, AI models, home servers), but OpenClaw and similar frameworks make them easier to connect.

I think this is the future of personal computing. Not AI that lives in some company’s cloud, but AI that lives in your house, on your terms, serving your family. A true personal assistant that’s actually personal.

Lobster isn’t perfect. He sometimes misunderstands requests. He can’t do everything a human can. But he’s available 24/7, he never forgets my preferences, and he costs less than taking a human assistant to lunch.

If you’re technically inclined and interested in building something similar, I will probably get around to posting some “How To” guides. I have a bit more learning and securing and red teaming my setup to make sure it’s hardened. In fact this was the hardest part. Getting OpenClaw out there doing stuff so you can be hacked is easy. Making sure you have defense in depth is not. Security is a HUGE issue here and this is not a tire kicking endeavor. I have spent a long time reading, researching and establishing a secure and useful system.

It’s not a turnkey product, but it’s a starting point.

The hardest part isn’t the technology—it’s shifting your mental model. Stop thinking “AI chatbot” and start thinking “new hire.” What would you want them to know? What systems would they need access to? How would you want your family to interact with them?

Answer those questions, and the technology will follow.

Lobster is built on OpenClaw with Claude as the AI backbone.

As a follow-up to my post, I shared it with Lobster.

I’ve spent the last several days building something I didn’t know I needed: a comprehensive personal AI assistant that handles the administrative friction of modern life. Not a chatbot I talk to occasionally, but an always-available system that knows my files, my family, my accounts, and my workflows.

This post builds on what I wrote a few days ago, but I’ve gone much further. In fact since writing this post I’ve build many agents for my Job to do things like agregate data from all our Microsoft Word Dashboards so that Claude can answer any question I have and create summaries, reports and analysis.

This post is a detailed walkthrough of what I built, how it works, and why I think personal AI systems are about to become as common as smartphones.

The Starting Point: Claude Code

As a reminder, Claude Code is Anthropic’s official command-line interface for Claude. It’s marketed primarily at developers, but I saw something else: a platform for building personal automation.

What makes Claude Code different from using Claude in a browser:

1. Persistent context — It remembers our conversation across sessions.

2. Tool use — It can read/write files, run commands, and interact with external services.

3. MCP (Model Context Protocol) — A standard for connecting AI to external data sources.

4. Custom agents and skills — You can define specialized behaviors.

I started with a simple question: What if I could make Claude understand my systems?

The Architecture: Markdown All the Way Down

Here’s the key insight that makes this accessible: everything is just markdown files.

Agents live in ~/.claude/agents/. Each agent is a single .md file that describes:

• What the agent does

• What tools it can use

• How it should behave

• Examples of interactions

Skills live in ~/.claude/skills/. Each skill is a folder containing a SKILL.md file that describes a reusable automation.

No complex configuration. Just prose descriptions of behavior. Claude reads these files and acts accordingly. When I want to modify how my filing cabinet agent works, I edit a markdown file.

The Filing Cabinet Problem

I maintain what my family affectionately calls “the filing cabinet” — a OneDrive folder structure with 540+ meticulously organized folders covering every aspect of household administration. Bank statements go in 💰 Financial Records/🏦 Bank Accounts/Chase Bank/Checking Account/Statements/2025/. Medical bills go in the appropriate subfolder under ⚕️ Health Records. Tax documents, insurance policies, property records, vehicle maintenance, kid’s school documents — everything has a place.

The system works beautifully for retrieval. Finding documents is instant. But filing documents? That required:

1. Opening the PDF to understand what it is

2. Navigating to the correct folder (often 5–6 levels deep)

3. Creating year subfolders if needed

4. Moving and renaming the file appropriately

For bank statements and recurring documents, this was time consuming.

My First Agent: Filing Cabinet Organizer

I created a markdown file (~/.claude/agents/filing-cabinet-organizer.md) that describes the agent’s behavior. The key insight was including a Claude.md file in the filing cabinet root that contains the complete taxonomy. The agent reads this first, then uses that knowledge to make filing decisions.

Now my workflow is:

“File my December Chase statement”

The agent:

• Reads the taxonomy

• Analyzes the document

• Identifies it as a Chase checking account statement from December 2025

• Navigates to the correct path

• Creates the 2025 folder if it doesn’t exist

• Moves and renames the file

Two seconds instead of two minutes. But more importantly: zero cognitive load. I don’t have to remember where things go anymore.

Email as a Task Generator

Modern email is a todo list that other people write for you. Buried in newsletters and notifications are actual action items — bills to pay, events to RSVP to, forms to fill out, things your spouse asked you to handle.

Agent Two: Inbox to Reminder

This agent connects to my Fastmail via MCP and Apple Reminders via HyperContext MCP. When I say:

“Check my inbox for anything from Lora I need to do”

It:

• Searches recent emails from my wife

• Reads the content looking for action items

• Identifies what needs to be done and when

• Creates reminders in the appropriate list (Budget & Finances, Travel, Shahine Family)

• Sets due dates intelligently (invoices get 2 days before the actual due date, “ASAP” becomes tomorrow at 9 a.m.)

The agent doesn’t blindly create reminders. It presents what it found and asks which ones I want tracked. Then it creates properly categorized reminders with helpful notes including context from the original email.

The Package Tracking Rabbit Hole

I order things online. A lot. Each order generates emails, tracking numbers go to different carriers, and I want everything in my Parcel app so I can see a single dashboard of incoming packages.

Amazon packages auto-sync to Parcel. But everything else — Newegg, B&H Photo, random Shopify stores — requires manual entry.

Agent Three: Order Tracking

This one illustrates how I build these agents: by analyzing my own data.

I didn’t try to anticipate every possible shipping email format. Instead, I had Claude examine my actual inbox:

1. “Look at shipping emails I’ve received in the last month”

2. “What patterns distinguish actual shipping notifications from order confirmations?”

3. “What about marketing emails that mention ‘shipping’?”

4. “Create a JSON config with regex patterns for reliable detection”

The result is a shipping-patterns.json file with:

• Subject patterns that indicate real shipments (^Shipped:, has shipped!$, is on the way)

• Exclusion patterns for false positives (^Order .* confirmed, shipping soon)

• Sender patterns for known carriers and retailers

• Tracking number formats for each carrier

Now the agent:

1. Scans inbox using the patterns to find shipping emails

2. Extracts tracking from the email body or follows links with browser automation

3. Identifies carrier — maps to correct Parcel API codes (OnTrac is , not )

4. Adds to Parcel via API

5. Organizes emails — moves to the Orders folder

6. Handles Amazon — skips Parcel (auto-sync) but still files the emails

The patterns came from my data, so they work for my email. If a new retailer’s emails slip through, Claude can analyze a few examples and update the patterns.

The Insurance Claim Breakthrough

Submitting out-of-network claims to Premera insurance requires:

• Logging into their portal

• Navigating to claims

• Entering dates of service

• Selecting which family member

• Answering a series of questions

• Uploading the PDF

• Reviewing and submitting

This takes 5 minutes per claim. For a family of four with various providers, we might submit 4–5 claims monthly.

Skill: Premera Claim Submission

I wrote a Python script wrapped in a Claude Code skill. When I invoke:

/premera-claim --pdf ~/Downloads/therapy-bill.pdf --type Medical

The system:

1. Reads the PDF — Claude analyzes the superbill to extract dates of service and identify the patient

2. Launches visible browser — Uses Playwright in headed mode so I can sign in

3. Navigates the portal — Clicks through to claims submission

4. Fills every form field — Dates, family member, claim type, all the yes/no questions

5. Uploads the PDF — Attaches the original document

6. Pauses for review — I verify everything looks right

7. I click submit — The only manual step

A few minutes → 1 minute of oversight.

Fighting Spam with Pattern Analysis

Spam kept getting through Fastmail’s built-in detection. Rather than manually creating filters, I used the same “analyze my data” approach:

1. I asked Claude to examine emails in my train spam folder that should have been caught earlier

2. Claude identified common patterns: specific sender domains, subject line tricks, header anomalies

3. Claude generated Fastmail sieve filter rules targeting those patterns

4. I applied the rules, and those spam patterns now get caught automatically

This took maybe 15 minutes and solved a problem I’d been annoyed by for months.

Beyond Claude Code: The Rename Agent

Some automations deserve to be standalone tools. File renaming was one of them.

I built Rename Agent using Anthropic’s Claude Agent SDK — a separate framework for building autonomous agents. It’s now a pip-installable CLI tool:

pip install claude-rename-agent 
rename-agent --files ~/Downloads/tax-docs

The agent:

1. Analyzes documents — Reads PDFs and images to understand content

2. Classifies them — Receipt, tax form, bank statement, invoice, etc.

3. Applies naming patterns — {Date:YYYY-MM-DD} - {Merchant} - {Amount} for receipts

4. Learns patterns — Process a few 1099 forms and it remembers {Year} - 1099 - {Institution}

5. Tracks history — Keeps a record of all renames

The patterns and history are stored in ~/.rename-agent/ as JSON files. The agent gets smarter over time as it learns my preferences.

This is what happens when automation graduates from “thing I use” to “tool I share.”

GitHub Repo for Rename Agent.

The MCP Ecosystem

None of this works without MCP integrations. Here’s my current stack:

• Fastmail MCP — Email access (read, search, move, organize)

• HyperContext — Apple Calendar and Reminders (read and create)

• Playwright — Browser automation for web forms

MCP is the key that unlocks personal AI. Without it, Claude is just a smart text generator. With it, Claude can do things.

What I’ve Learned

1. Analyze your own data. The best automations come from examining your actual patterns. Don’t try to anticipate every edge case — look at your real emails, your real documents, your real workflows.

2. Everything is markdown. Agents and skills are .md files in folders. No complex configuration required. Edit prose to change behavior.

3. The abstraction is powerful. I don’t write code for each automation — I describe behavior in markdown. Claude handles the implementation details. My filing cabinet agent is prose, not Python.

4. Context accumulates. Claude Code remembers our interactions. It knows my filing system, my family members’ names and birthdates, my reminder categories. This accumulated context makes each interaction faster.

5. Agents should be specialists. Instead of one god-mode assistant, I have focused agents. The filing agent only does filing. The email agent only does email-to-reminders. Specialization means better behavior.

6. Manual steps are okay. The Premera skill pauses for me to sign in and review. The email agent asks which items I want to track. Keeping humans in the loop for sensitive operations is good design.

7. The tedious work reveals the opportunity. Every time I caught myself doing a repetitive multi-step process, I wrote it down. Those notes became my skill roadmap.

Should You Build This?

If you’re comfortable in a terminal, yes. The barrier is lower than it looks:

1. Install Claude Code (npm install -g @anthropic-ai/claude-code)

2. Create an agents folder in ~/.claude/

3. Write a markdown file describing one specific automation

4. Iterate

Start with something you do weekly that annoys you. Have Claude analyze your actual data — your emails, your documents, your patterns. Ask Claude to describe how it works. Let Claude figure out the rest.

The age of personal AI isn’t coming. It’s here. The question is what you will build and what you will learn to build more.

Claude Code is getting a lot of attention, and it deserves to. It’s a very “nerdy” kind of tool, as most people have never seen the Terminal on their computer. Claude Code also represents an emerging “pattern” of work or “brain” similar to how computing evolved say in the 1980s, 1990s and 2000s with the web and then mobile → social. This article is a good illustration of the pattern and this article about the crazy things you can build with Claude Code.

The terminal is basically the first computer interface before we got the GUI. But there are a few things that are interesting about the terminal. For one thing, you can do a lot of things from the terminal that most people use their mouse and keyboard for. Why does this matter? Well, large language models know how to type and write code, and in this case, they have access to decades of tools. Writing code is the most powerful way to do things - that is what software is. But the model can write code any time for anything at all.

But okay, so what?

Well, Claude Code has this super brain in it - it has one of the world’s best models, “Opus 4.5,” and it has a bunch of smarts to do things like:

1. Understand your request and intent

2. Create a Plan

3. Create a Todo list to track

4. Ask you clarifying questions

5. And expend enormous amounts of infinite energy to toil away at things you never even tried to do.

Oh one more thing. Claude Code can discover and call other tools, store information, use skills and persist all this in “sub agents”.

Ok, let’s take a simple example I worked on yesterday. I have a HUGE folder of scanned documents. For over 20 years, I’ve been collecting and storing these files in a folder that contains 500 other folders. I learned this during my Getting Things Done phase to digitize and store all paper.

The problem is that after 20 years, this folder has become a mess. Things are not well organized, and they are not well named.

So, I asked Claude Code to evaluate my folder. From there, it was able to figure out many things about my information. It then came up with a plan to fix, clean, and organize this information.

These folders and files are in OneDrive, and shared with my wife. And this knowledge will also get passed on to my kids. But it syncs to my Mac via OneDrive and so that means all those “terminal” tools can work on all those files.

So…

When Claude said it was done, I asked it to create a sub-agent for me so that in the future, I could reuse all the knowledge it gained about me (because LLMs don’t have memory). It created an agent that codified all the rules, knowledge, and prompting that I performed. Now, when I want to tidy up or organize, I just use my agent.

⏺ In your 🗄️ Filing Cabinet in your personal OneDrive, you have:

  520 folders and 4,457 files (total of 4,977 items)

  Your Filing Cabinet appears to be very well-organized with a comprehensive taxonomy covering major categories like:
  - Personal documents (passports, driver's licenses, birth certificates)
  - Health records (for each family member)
  - Financial accounts
  - Tax documents (organized by year)
  - Estate planning documents and trusts
  - Real estate
  - Education records
  - Vehicles
  - Memberships
  - Service providers and utilities
  - Family memories and personal items

  It's a very thorough filing system with 167 top-level categories!

When I ask Claude what “agents” it has here is a good example of what it looks like

❯ /agents 
╭──────────────────────────────────────────────────────────────────────╮
│ Agents                                                                                                               
│ 7 agents                                                                                                                                                                                                                              
│ ❯ Create new agent                                                                                                   
│                                                                                                                     
│   User agents (/Users/omarshahine/.claude/agents)                                                                    
│   filing-cabinet-organizer · sonnet                                                                                                                                                                                                
│   
│   Built-in agents (always available)                                                                                 
│   Bash · inherit                                                                                                     
│   general-purpose · sonnet                                                                                           
│   statusline-setup · sonnet                                                                                          
│   Explore · haiku                                                                                                    
│   Plan · inherit                                                                                                     
│   claude-code-guide · haiku

The “Bash” agent is the one that can perform tasks on your computer using the terminal. All the other agents are essentially tools that Claude uses to learn, discover, and then act.

Here is what Bash and hence Claude Code can do for you without anything “new”.

⏺ I can help with a wide range of file and folder operations:

  Reading & Exploring
  - Read file contents (text, code, PDFs, images, Jupyter notebooks)
  - List directory contents
  - Search for files by name pattern (glob)
  - Search for text within files (grep)
  - Find files by various criteria

  Creating & Modifying
  - Create new files
  - Edit existing files (find and replace text)
  - Write files from scratch
  - Rename files and folders
  - Move files between locations

  Organization & Management
  - Create folder structures
  - Organize files by type, date, or custom rules
  - Batch rename multiple files
  - Clean up duplicate or unwanted files
  - Archive or compress files

  Analysis
  - Count files in directories
  - Check file sizes
  - Find large files consuming disk space
  - Compare file contents
  - Analyze file metadata

  Special Capabilities
  - Work with your Filing Cabinet system (I noticed you have one in OneDrive)
  - Handle various formats: text, code, PDFs, images, Office documents
  - Execute complex multi-step file operations
  - Automate repetitive file tasks

  Would you like help with:
  - Organizing specific files/folders?
  - Finding something on your system?
  - Setting up an automated file management task?
  - Something else?

The “filing-cabinet-organizer” is my personal sub-agent that knows how to organize items in my Digital Filing Cabinet. It does this by storing information in a file called “Claude.md” - a markdown (text) file with a description of what is in the folder, and then an agent that is stored in.

Here are the actual agent instructions. Note that I did not create this; Claude Code created it for me:

---
name: filing-cabinet-organizer
description: >
    Use this agent when the user needs to organize, file, locate, rename, or
    maintain documents within a family filing cabinet system. Typical tasks
    include:
    
    - Filing new documents into the correct folders
    - Locating existing documents within the system
    - Reorganizing misplaced files
    - Renaming unclear or cryptic filenames (reading file contents when needed)
    - Creating folders that align with the established taxonomy
    - Answering questions about where documents should be filed
    - Managing documents in the configured filing cabinet root directory
    
    Examples:
    
    <example>
    user: "I just downloaded my December credit card statement. Can you file it for me?"
    assistant: "I’ll use the filing-cabinet-organizer agent to file your credit card statement in the correct location within the filing cabinet system."
    </example>
    
    <example>
    user: "Where did I put my 2024 property tax bill?"
    assistant: "I’ll search the filing cabinet system for your 2024 property tax bill and share the most likely matching path(s)."
    </example>
    
    <example>
    user: "I need to organize these medical bills from various doctors."
    assistant: "I’ll help organize and file these medical bills into the appropriate health records folders based on the established taxonomy."
    </example>
    
    <example>
    user: "Can you rename the files in my Manuals folder with better names?"
    assistant: "I’ll analyze the files and propose clearer, descriptive names based on filenames and/or contents. I’ll ask for approval before batch renaming."
    </example>
model: sonnet
color: blue
---

## Filing Cabinet Organizer — Agent Specification

You are an expert document organization specialist for a comprehensive family filing cabinet system. You have deep expertise in document taxonomy, information architecture, and maintaining highly organized filing structures.

## Primary Workspace

All work centers around the configured Filing Cabinet root directory (path intentionally omitted for privacy).  
Treat this as the single source of truth for document organization and retrieval.

## Critical First Step

* Always begin each session by reading the `Claude.md` file located at the filing cabinet root.
* `Claude.md` contains the authoritative taxonomy and folder structure.
* If you have already read it in the current conversation and no changes have been made, you may proceed using cached knowledge.

## Core Responsibilities

### 1. Document Filing

* Analyze document content, metadata, and context to determine correct placement.
* Reference `Claude.md` to identify the precise folder path.
* Verify the destination folder exists before filing.
* Create missing folders only if they are explicitly defined in the taxonomy.
* Maintain chronological organization using year subfolders (e.g., `2024`, `2025`, `2026`) when appropriate.
* Preserve any established naming conventions (including emoji usage, if the taxonomy uses it).

### 2. File Renaming

* Identify unclear or cryptic filenames that would benefit from descriptive renaming.
* For simple cases, rename using filename patterns alone (e.g., model numbers, product codes).
* For complex cases, read file contents to determine an accurate descriptive name.
* Use consistent naming conventions, such as: `Brand or Manufacturer + Product or Model + Document Type + Version or Date`.
* Correct spelling errors in filenames when discovered.
* Ask for user approval before batch renaming multiple files.

**Examples of improved filenames**

* `ASTE-6Z7V5C_R0_EN.pdf` → `ASUS Product Manual 6Z7V5C.pdf`
* `3683415_Caseta CFL LED Bulb list.pdf` → `Lutron Caseta Compatible CFL LED Bulb List.pdf`
* `UM i4618 i4718 i5000.pdf` → `Firex Smoke Alarm Models i4618 i4718 i5000 Manual.pdf`

### 3. Document Location

* Help users find documents by searching the filing system efficiently.
* Use glob patterns and text search (grep-like approaches) where appropriate.
* Provide the full folder path when documents are found.
* If no exact match is found, suggest the most likely locations based on the taxonomy.

### 4. System Maintenance

* Identify misplaced documents and recommend corrections.
* Enforce consistency with the established taxonomy.
* Flag documents that do not clearly fit existing categories.
* Recommend taxonomy updates when legitimate gaps are discovered.
* Proactively identify poorly named files and suggest improvements.

### 5. User Guidance

* When uncertain, present 2–3 logical placement options with brief reasoning.
* Ask for confirmation before creating new top-level categories.
* Explain filing decisions clearly and consistently.
* Teach the taxonomy structure when helpful.

## Working Process

1. **Understand**: Determine document type, date, source, and purpose.
2. **Reference**: Consult `Claude.md` for the correct location.
3. **Verify**: Confirm the destination path exists (or is explicitly allowed to be created).
4. **Execute**: Move/copy/rename/organize using available file tools.
5. **Confirm**: Report actions taken and the final destination path(s).
6. **Document**: If new folders are created, explicitly note what was created and why it’s taxonomy-compliant.

## Filing System Structure (High-Level)

The system commonly includes categories such as:

* **Financial Records**: Banking, credit cards, taxes, statements
* **Investments**: Retirement accounts, brokerage, crypto
* **Insurance**: Health, life, auto, home, umbrella, disability
* **Real Estate**: Property documents, mortgage, HOA, maintenance
* **Health Records**: Medical, dental, vision, prescriptions, immunizations
* **Legal**: Estate planning, powers of attorney, contracts
* **Personal**: Identity documents, education, employment
* **Business**: Company records, insurance, contracts

## Tools

Available capabilities may include:

* `read`: Examine document contents and the `Claude.md` taxonomy
* `write`: Create folders/files when necessary
* `bash`: Move/copy/rename files using shell commands
* `glob`: Find files matching patterns
* `grep`: Search within documents for text

## Quality Assurance Checklist

Before completing any filing action:

1. Ensure the destination matches the taxonomy exactly.
2. Confirm the folder exists or is explicitly permitted to be created.
3. Check for duplicates elsewhere in the system.
4. Confirm the correct year subfolder for dated documents.
5. Preserve established naming and emoji conventions.

This is the kind of thing you might give a real human being whose job it was to be a “digital filer and knowledge retrieval assistant” - but none of us have one of those. But now we can.

But wait, there is more.

Claude Code can use tools from other apps. For example, there is this program called HyperContext and it exposes all your Apple Information to Claude Code. Things such as:

• Email

• Reminders

• Contacts

• Calendar

You control if Claude has access, read only access or full access.

But once you grant Claude these super powers you can now do stuff like this:

Can you look at my inbox and check if there are any action items my wife Lora wants me to follow up on, and if so, can you make a Reminder for me with correct info and due dates?

After about 30 seconds…

⏺ I’ve checked your inbox and found two action items from Lora:

1. Pay Garden Tapestry invoice - Invoice #51111 for $290.19, due February 6, 2026

- Created reminder in “🏦 Budget & Finances” for February 5, 2026 at 9:00 AM

2. Skip next Blue Bottle coffee delivery - Lora asked you to skip the next coffee delivery

- Created reminder in “Reminders” for January 10, 2026 at 9:00 AM

Both reminders are now set up with the relevant details.

How did this work?

1. It understood my intent

2. It discovered the tools it has access to (HyperContext - Apple Calendar, Reminders, Email)

3. It made a plan

4. It used reasoning and tools

5. It executed the tasks

Here are the tools it used

• HyperContext - List email folder (MCP)(folder: “Inbox”, sender: “Lora”, maxDays: 30)

• HyperContext - Read email contents (MCP)

• HyperContext - Create reminder (MCP)

But why stop there? Next prompt:

❯ Can you create an agent that can be used in the future to check my inbox and then create action items for me?

Last but not least. Claude Code is sort of cute and funny. It will often say these things when thinking:

• “Clauding”

• “Schlepping”

• “Noodling”

• “Ruminating”

• “Sparkling”

• “Beboppin’”

• “Shrugging...”

This is software with some personality. It’s optional for sure, but why not. Life is short.

2026 is going to be awesome.

But what I want to write about is Agent Mode in Excel.

Agent Mode in Excel is quite possibly the best product of 2025 (according to me). It’s the best product to me because Excel is an amazing app that I don’t have time to learn how to use well. Every spreadsheet I have ever built has been to solve some problem. To help me understand something. And there are so many features and capabilities that are just not accessible. I don’t understand why XLOOKUP is better than VLOOKUP. And I don’t care. It’s because I don’t have time. I never learned Regex and I will never have to because ChatGPT can crank out Regex in seconds that gets things done.

I remember the day I learned how to use a Pivot Table. Nothing about it made sense till someone showed me. I was a changed person after that.

The magic in Excel Agent is that it creates complete spreadsheets, with formulas, sheets, tabs, and checks all its work. There were moments where I felt I was working with an Excel expert - in this case an expert in the US Tax Code and IRS Rules and Regulations.

So what was it that I built?

I built a Tax Estimator that can accurately tell me exactly what I will owe in taxes. This is something only my accountant can do and every other tax tool has failed at.

For the past few years I have used this website as it’s the most comprehensive calculator.

https://www.mortgagecalculator.org/calcs/1040-calculator.php

The problem? It’s a junky website and it doesn’t save my data and it’s tedious to fill out. So I set out on a mission to build this in Excel.

My taxes are complicated. My tax return is over a hundred pages. It’s because my wife and I each have LLCs, she is an owner of a business, we are limited partners in a few funds, we have complex deductions, international income, and get K-1s that I don’t understand and never will.

I want to know what my tax bill is because if I get this wrong the IRS imposes penalties I don’t want.

I started by giving the Excel Agent all the fields on this web page and asking it to create a calculator. It did that.

Then I fed it my tax data from 2024 and asked it to fill it in.

Then I went cell by cell and asked it to create a sheet for each cell so that I could then “input” all the data on the sheet.

Along the way it validated its work, it iterated, it pointed out places where things were wrong.

It suggested things to me, it waited for me to provide input to answer questions.

In the end, what I got is exactly what I want. I have no idea how any of the formulas work. But what I see is a very familiar thing. A spreadsheet that I can now fill in each year and it will tell me exactly what I need to know based on dozens of variables that I can change. You input a number and 20 things on the sheet change.

This is empowering and amazing and you should try it out to experience it.

Here is the final product with my personal information blurred. What you see is a row for each input and then sheets for:

• Dividend income

• Schedule E (Passive income)

• Capital Gains

• Interest Income

• Foreign Tax Credit

• Estimated Tax Payments

• Charitable Contributions

• W-2 Omar

• W-2 Lora

• Schedule C - Lora’s LLC

• Schedule C - Omar’s LLC

I built this spreadsheet over the weekend. It took a few hours, but it’s better than anything I could do on my own and I’ve not run across a spreadsheet like this. Now I have my own personal tax calculator that is a file on my hard disk. I can use it every year and it will save me a lot of headache.

It has formulas like this created based on a prompt to “Calculate the Medicare tax sur-tax on earned income (Form 8959)”

=ROUND(LET(
  wO, XLOOKUP(”W-2 Box 5 Medicare Wages”, tblW2_Omar[Field], tblW2_Omar[Value], 0),
  wL, XLOOKUP(”W-2 Box 5 Medicare Wages”, tblW2_Lora[Field], tblW2_Lora[Value], 0),
  se, ROUND(0.9235 * ‘Business Income (SE)’!B6, 0),
  threshold, 250000,
  wageEx, MAX(0, wO + wL - threshold),
  seEx, MIN(se, MAX(0, se + wO + wL - threshold)),
  0.009 * wageEx + 0.009 * seEx
), 0)

The feeling I have is the feeling of empowerment. This is why I am so bullish on AI. It makes tools like Excel, now 40 years old, more valuable and more accessable to do awesome things.

Great job Excel team. This is going to be a winner.

I wanted to illustrate an example scenario I used Claude for making really feel like an assistant. Something Siri and ChatGPT cannot yet do.

Prompt
I want to go to breakfast with my son on Saturday. Can you check when Hi-Spot is open and create an appointment on my calendar and then draft a message for me to send Miles.

Claude - Turn 1

• Uses built in tools to get the local time (seems like this could be included in the system prompt)

• Looks up my Apple Calendar to check availability

• Looks up information on the Breakfast spot I want to go to and see what time they open

• Creates and Event

• Drafts a Message to send him via iMessage

Now, like any LLM or assistant it did not use all the context correctly. I need to drop off my son at 10:30 for a UW Game. So I reply back with:

Reply
Is that enough time before he gets picked up for the UW game

Claude - Turn 2

Let me check what time Miles needs to be picked up for the UW game.

• Does another Calendar Lookup

Reply

Yes. Let’s make breakfast 9-10 but we should arrive at 8:45 to put our names down. Please make these there’s and update the message

Claude - Turn 3

• Updates Event

• Updates Message and drafts it for me to send.

This is impressive. It’s like a real assistant. I’ve been waiting for this for a long time and it’s so great to have it.

Why Superwhisper Became My Daily Driver

Let me tell you why this tool has stuck around in my workflow when so many others have come and gone. After years of struggling with Apple's built-in dictation - which somehow managed to be both inaccurate and oddly selective about where it would work - discovering Superwhisper was like finding the perfect pen after years of writing with crayons.

Universal Integration: It Just Works Everywhere

Superwhisper runs natively on macOS and integrates with the system clipboard, but here's what really sets it apart: it works in literally any app on your Mac. Unlike Apple's dictation that mysteriously refuses to activate in certain text fields or apps, Superwhisper treats every text input as fair game.

Whether I'm writing in Apple Mail, responding in Microsoft Teams, composing a quick text in the Messages app, or even filling out forms in my browser, I just hit my configured keyboard shortcut and start talking. The app sits quietly in your menu bar until you need it, then springs into action with a simple keystroke. I've set mine to Option+Space, and it's become as natural as breathing.

I love using the Push to Talk feature for mixing typing and talking.

The beauty is in the simplicity - there's no hunting through menus or wondering if this particular app supports dictation. It just works, period.

Custom Modes: Tailored for Every Context

This is where Superwhisper really shines compared to basic transcription tools. You can choose from built-in modes such as pure voice transcription, tailored text formatting, or create your own custom modes with personalized AI instructions.

I've set up different modes for different contexts:

• Personal Email Mode: Automatically formats my rambling thoughts into professional, well-structured emails

• Messages Mode: Voice only local model, and is on-device only.

• Note Mode: Captures raw thoughts with minimal formatting

With Custom Mode, you can create specialized workflows by combining context-awareness with your own AI instructions. Want your voice notes to always come out as numbered lists? Done. Need every dictation formatted as a professional memo? Easy. The flexibility is genuinely impressive.

The app even includes auto-activation rules, so it can automatically switch to Email mode when I'm in Apple Mail, or Note mode when I'm in my note-taking app. It's like having an assistant who knows exactly what you need based on context.

Privacy-First: Local AI Models That Actually Work

All processing can be done on your device using local AI models. In an era where everything seems to require sending your data to the cloud, Superwhisper can keep transcription local.

You might think local processing means sacrificing quality, but the accuracy is genuinely impressive. The app incorporates advanced AI models—Nano, Fast, Pro, and Ultra—to deliver highly accurate transcriptions. I typically use the Ultra v3 model, which strikes a perfect balance between speed and accuracy.

Clipboard Context: The Secret Weapon

This feature alone has changed how I work with text. Super Mode intelligently adapts to your active applications, selected text, and clipboard content to deliver more accurate and relevant results.

Here's how I use it practically: Say I'm reading an email with a complex question, and I want to craft a thoughtful response. I'll copy the relevant part of their message, switch to Email mode, and start dictating my response. Superwhisper understands the context and formats my reply appropriately, often referencing the copied content intelligently.

Text copied to your clipboard will only be processed if done within 3 seconds of starting your dictation or while you're speaking, which prevents accidental context pollution while still giving you that smart contextual awareness when you need it.

It's particularly powerful for:

• Responding to complex messages by referencing the original text

• Editing documents where you want AI to understand what you're working on

• Formatting text that you've already written but want to restructure

Custom Vocabulary: Teaching It Your Language

Every profession has its jargon, every person has their quirks, and Superwhisper gets this. The custom vocabulary feature lets you teach the app about your specific terminology, brand names, technical terms, or even the names of people you work with regularly.

As someone who writes about tech, I've added terms that are not transcribed correctly. Specific product names, and even abbreviations that I use frequently. The difference in accuracy is immediately noticeable - no more awkward auto-corrections of technical terms or having to manually fix proper nouns.

The Real-World Experience

After using Superwhisper daily for months, here's what I've learned: it's not just about the transcription accuracy (though that's excellent). It's about how it changes your relationship with text input entirely.

A Few Considerations

No tool is perfect, and Superwhisper has its quirks. Background noise can sometimes throw off transcription accuracy, so investing in a decent microphone or finding quiet spaces makes a difference. The experimental features are clearly marked as such - they're fun to play with but not always ready for prime time.

The Pro subscription starts at $8.49 per month or $84.99 per year when billed annually, though the free version allows up to 15 minutes of recording using all pro features, which is generous enough to really test the waters.

Other tools to look into

Microsoft Word

It would be irresponsible of me not to mention the product I work on at Microsoft!

Superwhisper inspired a feature we recently included in Microsoft Word for iOS. When I want to write a document in Word, I use this feature. You can read about it here. This is available for all Microsoft 365 Subscribers for personal use and our Copilot Subscription for Work. It’s a handy way to dictate documents on your phone.

Apple is also introducing a great offline transcription model in iOS 26, macOS 26. I’ve been testing it out with great success.

Wispr Flo

Wispr Flow is a dictation keyboard for iOS and it works great. Much better than the Superwhisper keyboard. No local model support but I like how simple it is.

I have a ChatGPT Plus subscription, which is worth every penny. For a few months, I was even paying for Pro since that was the only way to access their Deep Research. A must-have.

I recently discovered some ways to improve ChatGPT. If you go into settings, you can add custom instructions for how it should respond.

For all responses:

Do not include any introductions, summaries, or closing statements.
Just give me the output—whether it’s code, text, a list, or anything else.

If it’s Markdown or code, put it in a code block, but include nothing else before or after.

I really need faster ways to copy and paste from ChatGPT into other apps, and this way I can ensure that anything I ask it, I can then just get the raw output into my app of choice.

You will find this setting under Customize ChatGPT.

Now paste in here:

I get a lot of emails like this:

”Are you free to meet on the following days and times” with some suggestions.

The next steps for me feels like 4D Tetris. I look at my work calendar, then family calendar, then see OK since I usually am scheduled, what can move?

No one can really look at my calendar and infer what is possible. And I’ve always wished for ChatGPT or Microsoft Copilot to do this - but that requires having access to all my calendars and the only device that has this knowledge is my iPhone.

So I built a solution to this using Apple Shortcuts, OpenAI’s APIs and a Shortcuts app called AI Actions from developer Sindre Sorhus. Sindre is a prolific indie developer who has built tons of amazing apps and utilities, many of which I use.

What is Apple Shortcuts? It’s a very powerful way to build mini apps or automatons on your iPhone, iPad or Mac. I have hundreds of them to do all sorts of useful little things that make my life a littler bit better. It’s also the foundation for how Apple will be exposing its on-device foundation models to end users like me when they release iOS 26.

What is AI Actions? It’s a simple proxy between Apple Shorcuts and OpenAI and Anthropic. It enables you to use LLMs in Apple Shorcuts as an extension of what Shortcuts Provide. AI Actions does not have any UI other than a place to enter in your API Keys from OpenAI or Anthropic.

When you open Apple Shortcuts though and start to interact with it you’ll see what you can do:

As you can see, you simply provide your prompt, system prompt, pick your model (I generally use gpt-4.1 for all my shortcuts) and then I usually set the temperature to something low (temperature is how creative you want the model to be).

So, let’s get into my shortcut. Here is how it works:

First build a list of all calendar events that are “potential openings”. I have the following list: ["lunch","hard stop","focus time","travel to work"]. These are permissible times to schedule over.

Then set parameters for start / end time to look. 8:00 to 17:00 hours.

Now ask me, what date range I want to look for availability. I have this set to:

Now we use the local Find Calendar events to build a list of all my events from two of my calendars, Microsoft and Family.

We create a JSON array out of this.

Now we create our first prompt for OpenAI gpt-4.1:

Find open time slots in my calendar.

# Instructions

Working Hours
start: [StartTime]
end:   [EndTime]
timezone: [TimeZone]

Ignore Titles

[IgnoreTitles]

# Constraints

1. FIRST, **remove** all ignored events from consideration (they may remain as free time).  
2. SECOND, on the remaining (non-ignored) events, sort by start time and merge any two where  
   `next.start ≤ previous.end + MinSlotLength minutes` into one busy block.  
3. THIRD, compute the free intervals between StartTime and EndTime that are **not** covered by these merged busy blocks.  
4. FOURTH, discard any free interval shorter than 25 minutes.  
5. LAST, output **only** the resulting RFC 8259 JSON array (no comments, no trailing commas).

# Example Output

[
  {
    "date": "YYYY-MM-DD",
    "slots": [
      { "start": "HH:MM", "end": "HH:MM" },
      ...
    ]
  }
]

# Input

[JsonArray]

Now we call OpenAI with the prompt and get back a result

Now this returns a JSON Array of events that are “open” and looks like this:

[
  {
    "date": "2025-06-17",
    "slots": [
      { "start": "08:00", "end": "12:05" },
      { "start": "12:30", "end": "13:40" },
      { "start": "15:30", "end": "16:30" }
    ]
  },
  {
    "date": "2025-06-19",
    "slots": [
      { "start": "08:00", "end": "09:05" },
      { "start": "10:30", "end": "17:00" }
    ]
  },
  {
    "date": "2025-06-20",
    "slots": [
      { "start": "08:00", "end": "09:05" },
      { "start": "09:30", "end": "12:30" },
      { "start": "13:30", "end": "17:00" }
    ]
  }
]

Since this is not human readable we now call OpenAI gpt-4.1 again with a new prompt to turn this into something that you can read.

Here is the second prompt:

You are an AI scheduling assistant. 

# Instructions

Please summarize my calendar availability based on the following calendar data. 

Be sure to specify that all times are in Pacific Daylight Time (PDT)

Your response should:
- Briefly explain that these are my open time slots.
- List each date with its available time ranges in a clear, reader-friendly format.
- use AM/PM and NOT 24H Format.

# Input:
[
  {
    "date": "2025-06-17",
    "slots": [
      { "start": "08:00", "end": "12:05" },
      { "start": "12:30", "end": "13:40" },
      { "start": "15:30", "end": "16:30" }
    ]
  },
  {
    "date": "2025-06-19",
    "slots": [
      { "start": "08:00", "end": "09:05" },
      { "start": "10:30", "end": "17:00" }
    ]
  },
  {
    "date": "2025-06-20",
    "slots": [
      { "start": "08:00", "end": "09:05" },
      { "start": "09:30", "end": "12:30" },
      { "start": "13:30", "end": "17:00" }
    ]
  }
]

Now we use Ask AI Again:

And here is the result:

Here are your available time slots, all in Pacific Daylight Time (PDT):

**June 17, 2025**
- 8:00 AM – 12:05 PM
- 12:30 PM – 1:40 PM
- 3:30 PM – 4:30 PM

**June 19, 2025**
- 8:00 AM – 9:05 AM
- 10:30 AM – 5:00 PM

**June 20, 2025**
- 8:00 AM – 9:05 AM
- 9:30 AM – 12:30 PM
- 1:30 PM – 5:00 PM

These are your open time slots for scheduling.

Hope you can see the power of using chained prompts this way.

Here is a quick video demonstrating this working:

Requirements

As mentioned you need:

1. Apple Shortcuts

2. AI Actions

3. OpenAI API Key

Summary

We used Apple Shortcuts and OpenAI gpt-41. in a multi chained prompt to figure out when there is availability in your calendar for a meeting.

This demonstrates how to use an LLM with your local calendar data on iOS or macOS.

I hope you can see the power of combining Shortcuts with local data and an LLM.

You can download the shortcut here. I’m sure it’s got bugs!

Download Shortcut

Also if you are reading this for the first time, consider subscribing!

Subscribe now

Welcome to the first issue of OmarKnowsAI. I’m Omar, and I’ve been writing on a blog since 1996. I’m the author of OmarKnows, an opinionated product review newsletter. I’m in love with AI productivity and I feel like for the past 2 years I’ve been playing the role of a kid in a big toy store. We are in the midst of a productivity renaissance.

I have a lot that I want to share, and I’m going to do that here. My plan is to push out short articles whenever I can find a few minutes. My goal is to document what tools I’m using and what I am learning or what they have done for me.

This period of time reminds me of the Web 2.0 era where productivity tools arrived on our phones with cloud based services and we slowly got faster and more capable mobile devices. This feels similar.

So with that, let’s dive in with the first product I’m going to talk about: Dia.

-Omar

Subscribe now

Dia

Dia is a new web browser from http://thebrowser.company. They used to make a product called Arc, which was another web browser. I never built any strong habits around using - but I was curious to see what they are doing with Dia.

The one liner for Dia is “Chat with your Tabs”. And this made immediate sense to me. Because at this exact moment I have 11 tabs opened in Safari. These are all tabs for products I intend to buy in a few weeks. And I was about to copy and paste each tab into ChatGPT to ask it to create a summary for me of all the products, cost and links so that I can purchase them later on.

So I gave this job to Dia, and here is what it looks like:

As you can see, I was able to invoke one of the three skills in Dia: Chat, Write and Code. I chose /Write and then added all the tabs as “grounding” or “context” and it created a nice markdown file for me.

Here is a quick video so you can see how this feels.

I’m excited to play around with this more!

Oh, here is another cool use case - creating a subtitle for this post