Stet: Shotgunning an Editor My Agents Can Drive

An example of building personal software.

I built a markdown editor with about an hour of my own time. It's heavily inspired by iaWriter with my own preferences baked in. It's called Stet, it's open source (free!), and I'm writing this post in it. Claude is in here too: it wrote this draft into an open tab through Stet's agent interface.

I wrote this post to share two building techniques:

1. Shotgun prompting. I didn't engineer prompts. I fired off what I wanted, fast and loose, in whatever words came out, and kept firing until I was satisfied. You could also call this dumb prompting.

2. A mechanism that lets the agent drive. Stet has an interface that lets an agent read, edit, operate and screenshot the editor. That's what let Claude check its own work, and what lets it write alongside me now.

Here's every prompt I typed, in order, with timing:

Every prompt that built Stet, in order, on a clock of my hands-on time: 72 short, typo-ridden messages adding up to about 56 minutes.

What it is

Stet is the proofreader's mark for "let it stand". You write it next to a correction you want ignored, and put dots under the original words. It felt right for an editor built around reviewing suggestions.

1. It's fast. The core is Rust and the text is drawn on the GPU. A keystroke reaches a finished frame in 0.07 ms on a small note and 0.6 ms on a one-megabyte document with 1,800 suggestions in it.

2. It shows your source. Markdown keeps its markers, dimmed so the words come first. There's no preview pane.

3. It has real vim. Registers, macros, block visual, :s.

4. Review is built in. Suggestions are CriticMarkup in the text, so they survive git, email and every other tool.

5. It has a margin. Every document gets a scratch pane for research notes, and a note can be pinned beside the paragraph it's about.

6. Agents work beside you. More on this below.

1. Shotgun prompting

Here is the first prompt for making Stet:

I want a beautiful/minimal/x-platform markdown writer similar to ia writer just with the core written in rust, any platform os stuff abstracted away (should run windowed), support for vim key bindings, images, etc. all markdown features. also support for suggestion mode (see the archdev task epic for this on firstlanding). should also be themable (see themes on archdev). needs to be fast as hell and reliable.

After that I didn't write specs. I just kept asking:

1. "make it faster"

2. "yes, do it"

3. "give it a better fucking name and branding"

4. "you can't manipulate things with your ctl skill?"

5. "make sure you can test this shit"

6. "jdone"

7. "try again"

8. "make it public and lock it down"

"make it faster" took a one-megabyte document from 5.1 ms per keystroke to 0.6 ms. "jdone" was me trying to type "done" after pasting the wrong Substack cookie. "try again" produced a live Substack draft.

By the numbers:

|                                                                             |                        |
| --------------------------------------------------------------------------- | ---------------------- |
| Prompts                                                                     | 72                     |
| My hands-on time                                                            | about 56 minutes       |
| Claude's working time                                                       | about 4 hours          |
| Median prompt                                                               | about 56 characters    |
| Words I typed, in total                                                     | 1,083                  |
| Lines of Rust                                                               | 27,241                 |
| Tests                                                                       | 170                    |
| My time to v0.2.0 (Mac app, DMG, CI on three OSes, the rebrand, the margin) | 22 minutes, 29 prompts |
| Times I typed "commit and push"                                             | 7                      |
|                                                                             |                        |

Shotgun prompting means I spend shots; thought is all implicit or the “thinking fast” kind. There's no role-play, no XML, no rubric, no fancy skills, and no 2,000-word plan. Each prompt is the next thing I want or the next thing that's wrong, typed the way I'd say it to an engineer sitting next to me (well maybe with less cursing). If the result is off, I say so and go again. Working this way on these types of tools lets me multi-task and focus my real attention on other work that matters.

2. Building the system that lets the agent drive

The reason I built Stet at all was one prompt, eight minutes in:

i need to basically have a skill that lets my agents communciate and manipulate the markdown file without fucking up my flow

Every editor I tried broke when an agent touched the document. Or even worse, the agent could never touch the document. Some editing tools build in their own agents and those agents often suck. I very much believe that the future of software is designing it to be used by agents more so than humans. I even tried using vim with an agent just editing the markdown file on disk. Even if I did get an editor to work with my agent of choice, the experience wasn't good: text jumps around and I have no idea what the agent changed.

So Stet has stet ctl, a small command-line interface to the running window:

stet ctl read                                   # the live, unsaved text
stet ctl suggest --old "teh" --new "the"        # a suggestion I accept or reject
stet ctl edit --margin --at end --text "..."    # research notes into the margin
stet ctl wait --name Claude                     # take requests I send from inside the editor

None of it moves my cursor, changes my mode or steals focus. Suggestions show up inline, and I accept them or let the original stand:

That was the plan, but it required a few more shotgun blasts to get right. The best part came from two annoyed questions, 17 minutes in:

1. "why can't you see stuff?" Claude couldn't drive my desktop. It had no Accessibility permission, and the screen was locked.

2. "you can't manipulate things with your ctl skill?" By my next prompt, stet ctl had grown keys, type, click and shot.

stet ctl keys "<D-/>"          # press keys, in vim notation
stet ctl click 320 200         # click in the window
stet ctl shot /tmp/stet.png    # see exactly what the window shows

From then on, Claude (or choose your own agent) could open a menu, click a table, take a screenshot and look at it. The app tests itself through its own agent interface. That's what makes shotgun prompting work: a miss stays cheap when the agent checks where it landed. When I said "make sure you can test this shit", Claude didn't hand me a checklist. It drove the real window, checked the result and fixed what it saw. I didn't have to spend time checking the work.

It's paid off for writing as much as building:

1. This post. Claude read my earlier posts for voice, wrote the draft into an open tab with stet ctl edit, and pinned its sources in the margin beside the paragraphs they support. I only had to edit.

2. My last essay. Claude found the video, my tweets and the framework images and put them in while I kept writing.

3. Requests from inside the editor. I select a sentence, press a shortcut, type "tighter", and a suggestion comes back.

An agent editing your document is only useful if it keeps its hands off your cursor, and an agent building your software is only useful if it can see what it built. stet ctl does both.

A few more things it does

One menu for everything. ⌘/ lists every command with its shortcut, the markdown you can insert and the vim keys.

Retouch pictures in place. Crop, draw arrows, boxes and text, or redact. Agents get the same tools through stet ctl annotate.

Tables as a grid. Pipes become rules and the columns line up, but every character is still the source.

Publish to Substack. :publish makes a draft with your pictures uploaded. Substack has no public API, so a subagent worked out the one behind its editor.

Code in about 200 languages, in fifteen themes. This is stet-ink, the dark house theme.

The video was shotgunned too

The film at the top was made with Clapper, our open-source framework for making videos in React. The score is code as well: sampled upright piano, bass and drums, written as notes in TypeScript.

1. "use clapper to animate the prompting to get to stet"

2. "make sure the music / sound is not fucking stupid"

3. "get rid of the commit part of the video - show all the prompts"

4. "update the video to reflect wall time"

Back to personal software

A month ago I wrote Personal Software: My New Bad Habit: instead of adopting tools, I build exactly the one I need. Stet is the clearest example of that habit so far.

1. I can. It took an hour of my time.

2. It's useful. I write in it every day, and so do my agents.

3. It's fun. I got to poke at GPU text rendering, vim's stranger corners and what Substack's editor actually sends over the wire.

4. It's personal. Nobody else asked for a Substack button. There's a fish command, blog, that opens a new post in Stet because that's how I start writing.

The objections from that post hold up too. On maintenance: today's v0.3.0 release failed its own checks on six new security advisories in the TLS libraries. Claude patched them, re-ran the checks and shipped, and all I typed was "and do the latest release". On triviality: an hour of my time bought 27,000 lines of Rust, 170 tests, CI on three operating systems and signed build provenance. That isn't trivial to me.

Personal software used to be limited by how much time you had. With shotgun prompting, the limit is how fast you can say what you want and whether the agent can see when it's wrong. The first part is up to you. For the second part, build the agent a way in.

Try it

curl -fsSL https://raw.githubusercontent.com/ArchAstro/stet/main/install.sh | sh

1. Source: github.com/ArchAstro/stet, MIT

2. Downloads: v0.3.0 for macOS, Linux and Windows

3. The agent skill: the installer adds a skill so Claude can use stet ctl for you

4. The video framework: github.com/ArchAstro/clapper

If you find a bug, open an issue. My agents will probably fix it.