Skip to content

Settings

Settings live under agentTypewriter.* in VS Code’s settings. A repository can also set any of them for everyone who opens it with a repository settings file.

Set Playback Speed… also offers a session multiplier (0.5x to 5x) on top of the base speed.

This list is generated from the extension’s manifest, so it always matches the version these docs describe.

39 settings in version 0.6.0.

agentTypewriter.autoStart

Type: booleanDefault: false

Start watching automatically when a workspace opens.

agentTypewriter.include

Type: arrayDefault: ["**/*"]

Workspace-relative globs to watch. A pattern without a slash (like *.ts) matches the file name anywhere.

agentTypewriter.exclude

Type: arrayDefault: ["**/.git/**","**/node_modules/**","**/dist/**","**/out/**","**/build/**","**/target/**","**/.gradle/**","**/.idea/**","**/*.lock","**/package-lock.json","**/*.log"]

Workspace-relative globs to ignore. Exclude wins over include.

agentTypewriter.extensions

Type: arrayDefault: []

Only watch these file extensions (for example ["ts", "java", "md"]). Empty means any extension that passes include/exclude.

agentTypewriter.respectGitignore

Type: booleanDefault: false

Also skip paths git ignores (.gitignore files, .git/info/exclude, and your global excludes). Files git tracks are never skipped. Has no effect without git or outside a git repository.

agentTypewriter.profiles

Type: objectDefault: {}

Named filter sets, for example { "docs": { "include": ["docs/**"], "extensions": ["md"] } }. Profiles merge by name with those in .agent-typewriter.json. Switch with Switch Filter Profile....

agentTypewriter.activeProfile

Type: stringDefault: ""

Name of the active filter profile. Its filters override the repository settings file and user settings; workspace settings still override it. Empty means no profile.

agentTypewriter.charsPerMinute

Type: numberDefault: 1000Range: at least 1

Base typing speed in characters per minute.

agentTypewriter.charsPerSecondDeprecated

Type: numberRange: at least 1

Use charsPerMinute instead. A value here still applies, times 60, where charsPerMinute is not set.

agentTypewriter.languageSpeeds

Type: objectDefault: {}

Base typing speed per language, in characters per minute, keyed by VS Code language ID (for example { "markdown": 1500, "json": 1200 }). Language IDs are case-sensitive; find them in the language picker in the status bar. Languages not listed use charsPerMinute.

agentTypewriter.jitter

Type: numberDefault: 0.6Range: 0 to 1

How uneven the typing rhythm is. 0 is perfectly even, 1 is very uneven.

agentTypewriter.catchUpFactor

Type: numberDefault: 0.5Range: at least 0

Extra speed per queued change, so playback accelerates when the agent gets ahead. Speed = base x (1 + factor x queued), capped at maxSpeedup.

agentTypewriter.maxSpeedup

Type: numberDefault: 8Range: at least 1

Upper bound on the automatic catch-up multiplier.

agentTypewriter.maxAnimatedChars

Type: numberDefault: 6000

Changes that add more characters than this are applied instantly instead of typed (big generated files, formatter runs).

agentTypewriter.fileSwitchDelayMs

Type: numberDefault: 1000Range: 0 to 15000

Pause on the new file's mirror before its first edit, so the switch reads like a person changing tabs. Divided by the playback speed.

agentTypewriter.smoothScroll

Type: booleanDefault: true

Scroll to the next edit in the same file instead of jumping there. Edits already in view only move the caret.

agentTypewriter.readPauseSeconds

Type: numberDefault: 1.5Range: 0 to 15

Time to read what was just typed before the view leaves it, for an off-screen edit in the same file or a switch to another file. Counts from the last edit, so idle time counts. Divided by the playback speed; 0 turns it off.

agentTypewriter.scrollPauseMsDeprecated

Type: numberRange: at least 0

Use readPauseSeconds instead. A value here still applies, divided by 1000, where readPauseSeconds is not set.

agentTypewriter.scrollLinesPerSecond

Type: numberDefault: 60Range: at least 1

How fast the view scrolls to the next edit in the same file. A scroll takes at most one second at 1x; far edits jump most of the way first.

agentTypewriter.arrowNavigation

Type: booleanDefault: true

Walk the caret to the next edit with arrow keys (a line at a time, then by words) when it is close by and in view, instead of clicking there.

agentTypewriter.arrowKeysPerSecond

Type: numberDefault: 15Range: at least 1

Arrow key presses per second when walking the caret to the next edit. Multiplied by the playback speed.

agentTypewriter.naturalOrder

Type: booleanDefault: true

Type each change the way a person writes it: a block's closing line right after its opening line, then the body between, and a signature before its body. Off types every change top to bottom.

agentTypewriter.debounceMs

Type: numberDefault: 200

Writes to the same file within this window are merged into one change.

agentTypewriter.reorderWindowMs

Type: string or numberDefault: "auto"

How long each change is held so changes reach the timeline in the order files were written, even when the file watcher reports them late. "auto" uses 2500 ms on Windows and 250 ms elsewhere. 0 adds changes as soon as they are read.

agentTypewriter.maxFileSizeKB

Type: numberDefault: 512

Files larger than this are ignored.

agentTypewriter.gitBaselines

Type: booleanDefault: true

For files git reports as tracked and unmodified, read the first change's before text from git instead of keeping a copy in memory. Needs the git command; turns itself off when git is not available. The watched repository is only read, never changed.

agentTypewriter.baselineBudgetMB

Type: numberDefault: 256Range: at least 0

Memory budget for in-memory baselines (files not covered by git). Most recently modified files are covered first; a file without a baseline has its first change captured only as a baseline.

agentTypewriter.historyLimit

Type: numberDefault: 500Range: at least 10

How many changes to keep in the buffer for replay. Oldest are dropped first. The buffer also keeps at most historySizeMB of change text.

agentTypewriter.historySizeMB

Type: numberDefault: 64Range: at least 1

Megabytes of change text (before and after text, a character counted as a byte) to keep in the buffer for replay. Oldest changes are dropped first, and the newest is always kept. With persistHistory on, this is also about what the saved history takes on disk.

agentTypewriter.persistHistory

Type: booleanDefault: true

Keep the recorded changes across window reloads and restarts, in VS Code's storage for this workspace (never in the workspace itself). Saved change text is read back when it is needed rather than kept in memory. Turning this off deletes the saved history.

agentTypewriter.ignoreOwnSaves

Type: booleanDefault: true

Do not replay changes you saved from a VS Code editor yourself. Saves are matched by content: if something else writes the file right after your save, that write is still replayed. Turn off if your agent edits VS Code's editor buffers and then saves them.

agentTypewriter.ignoreGitOperations

Type: booleanDefault: true

Do not replay files that git rewrites when you merge, pull, switch branches, rebase, cherry-pick, revert, reset to another commit, or stash and pop. Conflict resolutions, edits made during the operation, git restore and git stash apply are still replayed. Needs the git command; the repository is only read.

agentTypewriter.viewColumn

Type: stringDefault: "beside"Values: "beside", "active"

Where the replay editor opens: in a column beside your current editor, or in the active column.

agentTypewriter.mirrorStatusRow

Type: booleanDefault: true

Show a row of playback controls and status above the first line of the replay editor. Turn off to keep it out of screen recordings. Hidden anyway when editor.codeLens is off.

agentTypewriter.highlightAdditions

Type: booleanDefault: true

Keep text that replay added highlighted, like a git diff, until highlights are cleared. When off, each typed edit only flashes briefly.

agentTypewriter.markDeletions

Type: booleanDefault: true

Show text in red with a strikethrough just before replay deletes it, and mark where text was removed with a gutter marker whose hover shows the removed text.

agentTypewriter.autoRecordWorktrees

Type: stringDefault: "off"Values: "off", "fill", "rotate"

Give each worktree added while recording to a recorded repository its own lane, once something is written there. Until its first change it is watched but has no lane, doesn't count toward the 5, and can't be followed, so a worktree a tool checks out and removes without writing leaves no lane; at most 5 wait like this at once. At that first change, fill gives it a lane while fewer than 5 checkouts record, and otherwise records neither that change nor the worktree. rotate also makes room when all 5 are taken, by stopping the lane idle longest (never the followed one, and only after 2 minutes without a change). off records a new worktree only when you add it.

  • "off": A new worktree records only when you add it.
  • "fill": A new worktree gets its own lane at its first change, while fewer than 5 checkouts record.
  • "rotate": Like fill, and when all 5 are taken the lane idle longest stops to make room.
agentTypewriter.autoIgnoreWorktrees

Type: arrayDefault: []

Glob patterns for worktrees that auto-record never gives a lane and auto-follow never moves to, such as review or other throwaway checkouts. A pattern without a slash matches the worktree's directory name (review-*); one with a slash matches its full path as git reports it, with symlinks resolved, so start it with **/ (**/T/tmp.*). A pattern starting with branch: matches its branch instead (branch:review/*); a detached worktree has no branch. A lane auto-record added since recording started stops once it matches, unless it is its folder's last, and a new worktree still waiting for its first change is no longer watched. The folder's own checkout never matches, and you can still record a matching worktree by hand.

agentTypewriter.autoFollow

Type: booleanDefault: false

Once the followed lane is caught up and nothing has been typed for 3 seconds, follow the lane whose oldest queued change was recorded first. It never switches lanes in the middle of a change.

A save is skipped only when the file on disk holds exactly what your editor saved. If something else writes the file right after your save, as the Claude Code VS Code extension does when it saves your unsaved edits before applying its own, only that later write is replayed, starting from the text you saved.

Claude Code in a terminal writes straight to disk, which is what this extension expects. If an agent instead edits VS Code’s own editor buffers and then saves them, those saves look like yours and get skipped. Turn ignoreOwnSaves off in that case.

When you merge, pull, switch branches, rebase, cherry-pick, revert, reset to another commit, or stash and pop, git rewrites files, and those writes are not replayed. A file counts as git’s only when git itself shows it: the operation changed that file in the index, and the file on disk matches what git left there. The text git wrote becomes the file’s new starting point, so the next real edit replays from it, and the Agent Typewriter output channel says how many files each operation skipped. To watch a branch’s work typed out, use Replaying git history instead.

These are still replayed:

  • Conflict resolutions. The conflict markers git writes are skipped; the resolved file replays from them. Picking a side with git checkout --ours or --theirs counts as resolving. A resolution you save from an editor follows ignoreOwnSaves.
  • Edits made while an operation runs, and edits committed right after, unless git wrote that same file with that same text.
  • git restore, git checkout -- <path>, git reset --hard to the current commit, and git stash apply. Git leaves nothing that tells them apart from an agent writing a file back to its committed text.

Commands that all finish within the debounce time (debounceMs) are read as one operation. For example, git stash && git merge feature && git stash pop run together replays the popped edits. A git stash -u or git stash pop that moves thousands of untracked files (hundreds on Windows) can also go unrecognized, and then its files are replayed.