Stet — PR/FAQ
An Amazon-style PR/FAQ: a mock press release describing the product as if it had shipped, followed by the hard questions. It is a thinking document, not a commitment — every answer is grounded in the Architecture Decision Records.
Press Release
Stet turns code review inside out: you read, it writes
A native Mac app for a world where the code is already written by AI. The human's job is editorial — read, mark up, and direct. Stet does the typing.
SEATTLE — July 2026 — Today Stet launched a different kind of code tool. Not an editor. A viewer. Stet assumes what is quickly becoming true — that nearly all code is now written by AI — and asks the obvious next question: if you are no longer typing the code, what should the tool in front of you actually do?
The problem. Every code tool ever built assumes a person authors source character by character. As AI writes more of the code, developers have quietly become reviewers — but they are still using tools built for typists. Reading AI-written changes is tedious, the reasoning behind them is invisible, and directing a fix means dropping back into an editor and doing the work by hand.
The solution. Stet is a beautiful, native macOS app that is a code viewer and a direction surface. You read AI-written code and prose rendered the way they should be. You mark them up — comments, emoji reactions, spoken notes, a strike-through gesture. When you submit your feedback, Stet dispatches a sandboxed AI agent locally, on your own Mac, which does the work and opens a pull request. You review the result — guided by a walkthrough the agent is required to write — and either stet it (let it stand) or send it back with more feedback.
"The keyboard should be for opinions, not code," said Joe Stump, Stet's creator. "We spent forty years perfecting tools for people who type. That era is ending. Stet is the first tool built for the person whose actual job is judgment — and it treats that judgment as the most valuable thing in the room."
How it works. Sign in with GitHub or Gitea. Point Stet at any OpenAI-compatible model — a frontier API or a model running on your own machine. Read a pull request in the canvas; the Tour rail walks you through it in the right order. Mark it up. Submit. A local container spins up, an open agent harness (OpenHands, Crush, or Pi) does the work against a throwaway checkout, and a PR appears. Over time, Stet learns: every run is recorded as a versioned trajectory, and recurring lessons are distilled into reusable skills committed back into the repository — so the project's agents get better the more you use them.
"It changed what my mornings look like," said an early user. "I read, I react, I go get coffee. By the time I'm back there are pull requests waiting, each with a tour that tells me where to look first. I haven't opened my editor in a week."
Getting started. Stet requires a Mac running macOS 26 (Tahoe) on Apple silicon. Download it, sign in with your forge, connect a model, and open your first pull request.
Stet — you read, it writes.
FAQ
What exactly is Stet?
A native macOS application that is a code viewer and direction surface, not an editor. You read AI-written code and prose, mark them up, and submit feedback; Stet dispatches a sandboxed local AI agent that makes the change and opens a pull request. See ADR-0002.
Why run the agents locally instead of in the cloud?
Privacy, cost, and control. Your code, your machine, your model, your choice of
harness. Each dispatch runs in a fresh, isolated container with its own git worktree
and a branch-scoped credential that is revoked when it's done. Stet supports two
first-class runtimes behind one abstraction — Apple's container framework and Docker.
See ADR-0003.
Why macOS 26 and Apple silicon only?
It's a deliberate, opinionated floor. Targeting the newest stack unlocks the Liquid Glass design language and Apple's in-process container framework, and keeps the team on one modern toolchain. It excludes Intel and older macOS on purpose. See ADR-0001.
Can I bring my own model?
Yes — that's the point. Any OpenAI-compatible endpoint via OPENAI_BASE_URL /
OPENAI_API_KEY: a frontier API, a gateway like LiteLLM or OpenRouter, or a local
model. The agent harness is pluggable too — OpenHands, Crush, and Pi behind one
adapter. See ADR-0004.
How do I actually give feedback?
You mark up the galley: anchored comments, emoji verbs (🐛 investigate, 🎨 refactor-ugly, ❓ explain, 🔥 delete), spoken notes, and strike-through/scribble suggestions. Nothing dispatches until you Submit, at which point your whole review compiles into one coherent brief — one review, one pull request. See ADR-0006.
What's a "tour"?
Because the agent authors the PR, Stet requires it to also author a walkthrough: an ordered set of stops, each with a location, a "why," and a risk flag. The Tour rail plays the diff in the right reading order and doubles as the review skeleton. See ADR-0008.
What is a trajectory, and why is it in my repo?
A trajectory is the full, versioned record of how a change was made — the brief, the agent's reasoning, its tool calls, the diffs, the cost. Stet commits it inside the repository, as the branch's final commit, so provenance travels with the code and can be reviewed like any file. A deterministic secret-scanner and redaction gate runs before anything is written. See ADR-0011.
What is skill distillation?
Over time, your feedback plus trajectories plus outcomes reveal patterns. Stet distills them into reusable skills, proposes each as a pull request (reviewed through the normal loop), and injects them into future dispatches — so the project's agents measurably improve. See ADR-0012.
Is Stet single-player?
No. The forge (GitHub/Gitea) is the social backbone — identity and baseline comments/reactions that even non-Stet teammates see. Richer markup, threads, and votes live in an embedded, versioned Dolt store that syncs to the forge or your own instance. And both humans and agents vote on changes, skills, and trajectories — humans decide, agents advise, with diversity and anti-gaming weighting. See ADR-0013 and ADR-0014.
How is configuration shared across a team?
Three primitives — Agents, Skills, and Verbs — are versioned across a three-level
.stet topology: $USER/.stet, $ORG/.stet, and a project's .stet/ directory,
following the familiar .github convention. Definitions resolve most-specific-wins;
precedence is a setting, and a higher tier can pin a definition so it can't be
overridden — mandated, auditable governance. See
ADR-0015 and
ADR-0016.
Can I build on someone else's setup?
Yes. Configs are YAML, and a .stet can import other .stet repos — friends base
theirs on yours, orgs import vendor packs. Imports pin to a ref, and downstream policy
can require that ref be GPG-signed by an allowed signer. Because importing means
importing executable intent, adding or bumping an import is itself a reviewed, voted
change. See ADR-0017.
Who is Stet for?
Developers, reviewers, and teams whose code is increasingly written by AI and who want to stay in the loop as editors and directors rather than typists — without shipping their code to someone else's cloud.
What's the longer-term vision?
A world where reading and directing is the craft, provenance is a first-class artifact, and every team's agents compound in capability over time — with a governed, signed ecosystem of shareable configuration underneath it all.