Posted on Oct 26 AI-assisted

tackline: Backseat driving for your coding agent.

#ai #coding #productivity #tools

Coding agents got good at writing code. Telling them exactly what to change is still clumsy, so I built a small tool for that part: tackline.

Most of my day with Claude Code isn't typing prompts from scratch. It's reading what the agent just did, spotting what's off, and sending it back for another pass. That loop is where the friction lives.

The problem: prompts full of paths and line numbers

You review a diff and see five things. The loop in the matcher should be an iterator chain. That helper already exists, use it. Don't touch the public function signature. And so on.

Then you turn those thoughts into a prompt. You copy a file path, look up the line numbers, paste a snippet so the agent knows which loop you mean, and write the instruction. Five times. By the third one, you're writing "also the thing in utils" and hoping the agent guesses right.

The information you need is all on your screen while you're reading the code. The prompt is just a worse copy of it, assembled by hand.

What tackline does

tackline is a terminal app that lets you point at code and write what the agent should do there. It turns all those notes into one prompt.

Run tackline (or tack) in a repository. It opens on the git diff if you have uncommitted changes, otherwise on a file browser.
Select a line or a block of code with V, v, Shift+arrows or the mouse, and press c.
Write the instruction and press Enter. Notes collect in a named session.
Press 3 to see the session, then y to copy it.

What you paste into your agent looks like this:

# Search speedup

1. `src/matcher.rs:3-7`
   ```rs
       for item in items {
           if item.contains(query) {
               out.push(item.clone());
           }
       }
   ```
   replace the loop with an iterator chain

Every note carries its file, its lines and the code as it is right now. The agent doesn't have to guess which loop you meant, and you never typed a path.

Before you copy, the Session view shows every note with its code in prompt order. You can reorder, edit or drop notes before the agent sees them.

Notes follow the code

Steering an agent happens in rounds: you note things, the agent edits the files, you look again and note more. Line numbers break the moment the agent touches a file.

So each note remembers the code it was attached to, not just its line numbers. When lines are inserted above it, or the code moves within the file, the note moves with it. If the code is gone entirely, the note is marked stale and left out of the prompt, with a warning so you know.

Sessions are saved as you go, in readable JSON files in the repo. Close the app, come back tomorrow, and your notes are still there.

In the editor, noted code is tinted, with a marker in the gutter. You can see at a glance what you've already flagged, and press Enter on a noted line to read the whole note.

Works with any agent

The output is plain Markdown, so tackline doesn't care which agent you use. Press y to copy it, or hand it over from the shell:

Agent	Hand over the prompt
Claude Code	`tackline export \
Codex	{% raw %}`codex exec "$(tackline export)"`
opencode	`opencode run "$(tackline export)"`
aider	`aider --message "$(tackline export)"`
Cursor	paste it into the chat, or `agent -p "$(tackline export)"`

For Claude Code there's an extra: a small skill file turns your active session into a /tackline slash command, so the agent reads your notes itself.

And if you'd rather click than learn keys, tackline serve opens the same tool in your browser, on localhost only, working on the same files.

Steering, not reviewing

I first tried code review tools for this, and they didn't fit. Review tools are built around verdicts: approve, request changes, resolve the thread. That's the wrong shape for working with an agent.

A tackline note is an instruction. "Make this async." "Use this helper instead." "This is the pattern to follow." "Don't touch this signature." Some notes are about code the agent wrote, others point at existing code it should read first. Together they're a brief, not a review.

That's also why it works before a task, not only after one. Browse a codebase, pin the places that matter, and give the agent a prompt that already knows where to look. If you work on a fork, tackline --base upstream/main shows only your changes, so you can annotate exactly what differs.

Try it

tackline is free and MIT licensed, with prebuilt binaries for macOS, Linux and Windows. No Rust needed:

# macOS and Linux
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/terminalkitten/tackline/releases/latest/download/tackline-installer.sh | sh

# Homebrew
brew tap terminalkitten/tackline https://github.com/terminalkitten/tackline
brew install terminalkitten/tackline/tackline

# Windows (PowerShell)
powershell -ExecutionPolicy Bypass -c "irm https://github.com/terminalkitten/tackline/releases/latest/download/tackline-installer.ps1 | iex"

# With Rust
cargo install tackline

Then run tack in any repository, select some code and press c.

Docs: terminalkitten.github.io/tackline
Code: github.com/terminalkitten/tackline
Crate: crates.io/crates/tackline

It's a young project, so I'd love to hear how you steer your agents and what's missing. Open an issue, or tell me where it got in your way.

DEV Community