Margaret

One-Line Summary

Margaret is a local-first macOS app that lets non-technical knowledge workers turn the tasks they repeat into small, private, reusable AI helpers — designed so people feel they can safely create one assistant for one job, not become operators of an automation platform.

Why This Project Exists

Most people use AI by hand. They paste the same context into a chat window, re-type a variation of yesterday's prompt, and hope the result comes out the same as last time. It rarely does.

The tools that promise to fix this — agent builders, automation platforms, workflow canvases — solve the repetition, but they move the cost somewhere else. They ask the user to become an operator: to think in nodes, triggers, and system prompts before they can automate a single Friday email.

So the gap isn't capability. The models are already good enough. The gap is the distance between "I keep doing this by hand" and "I'd have to learn a platform to stop." The question behind Margaret:

What would an agent tool look like if it assumed the user is a capable person with a repeatable job — not a systems designer who hasn't read the docs yet?

The Problem

Two things are true at once for the AI-curious knowledge worker — the solo consultant, the researcher, the coach, the freelancer.

AI genuinely helps with the work they repeat. And every existing path to making that help reliable feels built for someone else.

What they actually need:

To save the way they like a task done once, in plain English, and have it run the same way every time.
To not have to learn a builder, a node graph, or a prompt-engineering vocabulary first.
To know exactly what leaves their machine, and when — because the work is often client-confidential.
To keep their own files, on their own computer, without an account, a subscription, or a cloud they don't control.
To improve a helper when its output is slightly off — without starting from scratch.

The repetition is the surface problem. Underneath it are trust and ownership.

The Approach

Key Design Decisions

What I Built

The Helpers dashboard — the home surface, where a library of saved helpers lives and a new one starts from a single plain-English sentence.
Helper creation — three on-ramps (describe it, brief it, or set it up by hand) that all resolve into the same structured, reusable artifact.
Tune-up — the improvement loop: describe what's wrong, get specific suggested edits, apply them one at a time.
Workflows — multi-step sequences that chain helpers together for larger jobs.
Bundles — curated, installable packs of ready-made helpers for real roles (consultant, UX research, writing, small business, product strategy) so a new user runs something useful within minutes.
Local-first setup — keychain-stored key, a chosen helpers folder on disk, and a pre-run privacy view of exactly what gets sent.

Process & Architecture Snapshot

Design: positioning and the "helpers, not prompts" thesis first, then the surface — built around the non-technical user's mental model rather than an agent runtime.
Desktop app: Electron (macOS, universal binary), Anthropic Claude via the user's own API key (bring-your-own-key), helpers stored as plain Markdown files.
Marketing site: Next.js (App Router) · React · TypeScript · IBM Carbon design system · GSAP scroll motion · self-hosted type (Merriweather display, Red Hat Display interface).
Distribution: GitHub Releases for the app; Kit for email capture; deployed on Vercel.

What This Demonstrates

Product architecture for AI that meets non-technical users where they are — designing the mental model, not just the model call.
Reusability as the core abstraction: a saved, inspectable helper instead of a disposable prompt.
Trust designed into the surface — visible data flow, local ownership, deliberate control — rather than asserted in copy.
A coaching loop ("tell me what's wrong") that replaces prompt engineering for the people who'll never call it that.
End-to-end delivery: a shipped desktop app, a distribution path, and a marketing site that all hold one consistent voice.

What It Does Not Claim

Margaret is not an enterprise agent platform, and it isn't trying to be. It doesn't do unattended automation, cloud orchestration, or production system-building — those are a different product for a different user.

It is local-first, not magic: when a cloud model is used, the content for that run is sent to that provider, and the app says so before every run. The claim is narrow and honest — a calm, owned workbench for the jobs you already repeat.

Why It Matters

The next wave of AI adoption won't be won by the most capable agent runtime. It'll be won by whoever closes the gap between everyday knowledge work and reliable, repeatable help — without asking ordinary people to become engineers first.

That's a design problem before it's a technical one: make the powerful thing feel small, owned, and safe enough to actually use. Margaret is one answer to it.