Slipstream Practice

Draft behind your AI agent. The agent writes the code in your project as usual; you retype its changes yourself in a practice folder, with what's left to type shown as ghost text. You end up with the same code, but you wrote it, and you understand it.

Tab and Shift+Tab only take over while a Slipstream ghost is showing; otherwise they indent and outdent as usual. There's deliberately no key to accept a whole block: the point is to type it.

No agent? Replay any repository's git history and retype it commit by commit.

Pre-release. Slipstream 0.3.0 is on the Marketplace's pre-release channel: on its page, choose Switch to Pre-Release Version. Feedback and issues: https://github.com/ednihs-yahska/slipstream/issues.

Practice modes

Slipstream: Choose Practice Mode… (or the eye button in the Steps view):

In every mode, Tab / Shift+Tab still fill in a word / line: a peek when you're stuck.

Requirements: VS Code 1.100 or later, in a trusted workspace. Git, for starting from a commit, replays, remote targets, and .gitignore support. Works with any coding agent; extra setup is available for Claude Code.

Use it on your own project

1. Let the agent make its changes in your project.
2. Run Slipstream: Start Practice…
   • Where: inside this project (.slipstream/practice/) or somewhere else on disk.
   • Start from: the last commit (your project before the agent's uncommitted changes), an earlier commit picked from the history (you retype everything since, in one go), or empty.
3. Open the Slipstream view in the activity bar and work through the steps.

Typing speed and time left

Slipstream measures how fast you actually type: real keystrokes only. Tab and Shift+Tab never count, nor do undo/redo, pastes or autocomplete. Pauses longer than five seconds aren't counted as typing time.

• Status bar: 3 changes left · 42 wpm · ~12 min left. The speed is your last minute of typing.
• Steps view: time left per practice folder. The tooltip has your speed now, this session and overall, how many keys were corrections, active typing time, and estimates for the session and the whole project (for a range replay, the commits still to come).
• Slipstream: Show Practice Stats: the same for every practice folder, grouped by project.

Estimates are characters still to type (indentation excluded), less the share you usually fill with Tab, at your speed. Until you've typed enough they say "about…" and use 40 wpm. Turn it all off with slipstream.showTypingSpeed.

Working with your agent

Run Slipstream: Set Up Agent… (also offered after Start Practice). It shows a preview of every change before writing it:

• Instructions for the agent, in CLAUDE.local.md (just you), CLAUDE.md (your team) or AGENTS.md (other agents). They say a human will retype the changes, so: keep diffs focused, leave a plan, and stay out of .slipstream/. Re-running updates the section in place.
• Claude Code deny rules in .claude/settings.local.json, so Claude can't read or edit your practice folders.

Personal files are kept out of git through .git/info/exclude.

The plan file

With the instructions in place, the agent writes .slipstream/plan.md in your project:

# Plan: Add greeting options
1. `src/types.ts`: add `GreetOptions`, used by `greet()`
2. `src/greet.ts`: accept options; add the excited variant
3. `src/legacy.ts`: delete, replaced by the options

The Steps view then follows that order, shows each reason beside its step, and uses the title as the session's name. Files the plan doesn't mention come after. Edits to the plan show up immediately.

Without a plan, steps follow the imports: a file comes after the files it imports (JavaScript/TypeScript and Python), so you write what's needed before what uses it. Each step says what it adds, e.g. adds GreetOptions, greet.

Connect your agent (MCP)

Slipstream: Connect Your Agent (MCP)… gives your agent read-only tools to see your practice:

• slipstream_progress: the steps you have left, in order, with reasons and the names each adds
• slipstream_read_practice_file: what you've typed so far in a practice file
• slipstream_list_practice_folders: your practice folders for a project

So you can ask "why does step 3 need that?" or "is my version of greet OK?" and the agent knows where you are. The command gives you the Claude Code line to run (it never runs it for you); any other agent can run the same script as a stdio MCP server. The tools only read; they never change your files.

Replay git history

Practise on code that's already written: yours, your team's, or an open-source project's.

• Slipstream: Replay a Commit…: pick a commit; you get a practice folder at its parent (.slipstream/replay/ or anywhere) and retype exactly what that commit changed.
• Slipstream: Replay a Range of Commits…: pick the oldest and newest commits; you retype them one after another. When a commit is done, choose Next Commit.
• After the last replayed commit, Continue to Current Files (offered when there's more) carries on to the project as it is now: later commits and uncommitted changes.

Two ways to start from an earlier commit, then:

Both pickers list recent commits and also take any revision (a branch, tag, HEAD~5, a hash).

The target is read straight from git, so your checkout (and any uncommitted work) is never touched. Project files open read-only. When you finish, you get a summary: time taken, and how much you typed yourself versus filled in with Tab.

Take your practice anywhere

A practice folder can be its own git repository. Start Practice offers to create one; push it like any other repository. Clone it onto another machine with Slipstream: Clone a Practice Repository…, and it finds its project:

1. A local checkout you point it at: Use a Local Checkout of the Project… writes .slipstream/link.local.json, which stays on this machine and out of git.
2. The path it was created with, if that folder exists here and is a checkout of the project.
3. The project's git remote: Start Practice records origin, and Slipstream fetches it into a cache (~/.cache/slipstream/remotes, or %LOCALAPPDATA%\slipstream\remotes on Windows). It follows the branch, fetching when a session starts, every slipstream.remoteFetchMinutes minutes, and on Fetch Remote Targets.

Progress (done steps, typed versus Tab) normally stays on each machine. Store Progress in the Practice Folder keeps it in .slipstream/progress.json instead, so it travels with the repository. If two machines practise at once, the last write wins.

How the practice folder finds its target

A practice folder contains .slipstream/link.json:

{ "target": "../.." }

target is the project, either absolute or relative to the practice folder (~ works). Replays add "ref" (the commit being typed) and "replay": { "commits": [...], "index": 0 }. A practice folder can also carry "remote": { "url": "…", "ref": "main", "path": "app" }: the project's git URL, the branch to follow, and the project's folder inside the repository (see above). A practice file at src/a.ts is typed towards <target>/src/a.ts. Because the link sits in the practice folder, it works inside the project, elsewhere on disk, or with the practice folder open in its own window. Link an Existing Folder as Practice Folder… writes this file for any two folders.

Want it the other way round, typing in the project while the agent writes to a copy? Put { "target": ".slipstream/shadow" } in <project>/.slipstream/link.json and point the agent at .slipstream/shadow/.

An in-project practice folder is kept out of the way:

• Git: the project's whole .slipstream/ folder (practice and replay folders, the agent's plan) is added to .git/info/exclude (local, never committed), so git and git-aware tools ignore it.
• VS Code search: **/.slipstream/** is added to search.exclude in your user settings, so Find in Files and Quick Open (Cmd+P) only show project files. The Explorer still shows the practice folder, so open practice files from there. Nothing is written to the project's .vscode/settings.json. Turn this off with slipstream.hideFromSearch.

The Steps view

The Slipstream icon in the activity bar lists, per practice folder, what's left to do:

Done steps stay at the bottom, ticked. The status bar shows N changes left · done/total steps. Right-click a step for Show Diff with Project, Open Project File, or Copy from Project (skip typing).

Project files are listed with git, so .gitignore is respected and the agent's new, uncommitted files count. Files in the practice folder that the project ignores (e.g. dist/) aren't listed as deletes.

In the editor

• Ghost text at the cursor: the code still to type here.
• ▸ markers: other places with code to type (hover to preview it).
• Strikethrough: code the target no longer has. Delete it yourself, or bind slipstream.deleteMarked to a key. A typo is struck through too, and the ghost stays after it: Backspace, or Tab to replace it with the right word.
• New lines above existing code: Slipstream opens a blank line for them first, so what you type never glues to the code below.
• Status bar: changes left; click to jump to the next one.
• A hint where the ghost would be, when there's nothing to type at the cursor: ◂ next change on line 42 · Alt+], or the next step, e.g. ◂ next: create src/util/math.ts (and its folder src/util/) · Alt+Shift+] creates it, a move, delete or copy, or ◂ all steps done ✓. It only appears at the end of a line, and Tab never types it. Turn it off with slipstream.guidanceHints.

Whitespace-only differences (indentation, spacing, blank lines) are ignored by default, so your formatter can't get in the way. Set slipstream.whitespace to exact to require every character. If the editor auto-indents deeper than the target, the ghost still shows and Tab types over the extra spaces.

When you write something different on purpose

Your version can become the real code. Either edit the project file by hand (the ghost text follows), or put the cursor on the difference in your practice file and press Cmd/Ctrl+.:

• Use my version in the project: writes your version of that change into the project file (also Add my text… / Remove this from the project when one side is empty).
• Open in project to edit by hand: opens the project file beside you with that spot selected.

Settings

Errors and (at debug level) scan timings go to the Slipstream output channel.

Commands

Known limitations

• Ghost text appears only when the cursor is where the missing code starts (spaces/tabs before the cursor are tolerated). Use Alt+] to get there.
• Search hiding covers practice folders under .slipstream/. A custom in-project location relies on .git/info/exclude alone.
• An in-project practice folder may be picked up by project tooling that ignores git (e.g. a tsconfig.json including **/*). Use a folder outside the project if that bites.
• Other inline-completion providers (e.g. Copilot) can show suggestions at the same time: VS Code has no API to silence them. A one-time notice offers Copilot's settings; Tab always types Slipstream's ghost.
• Without a plan file, steps follow imports for JavaScript/TypeScript and Python; other languages fall back to path order.
• Within a file, changes go top to bottom; ordering by what depends on what is file-level only.