DEV Community: Charles Ouimet

RangeLink 2.0.0: Bind first. Every R-* follows

Charles Ouimet — Sat, 13 Jun 2026 00:37:35 +0000

Hey folks! Yes, it's been a while. RangeLink v1.0.0 shipped in mid-December 2025, and here we are in mid-June with v2.0.0 finally out the door.

If you were wondering whether the project went quiet, it didn't. It got busy under the hood. In v1.0.0, destinations were the place R-L sent your link. In v2.0.0, destinations carry the whole keybinding family: the new R-F and R-G route through your destination, and R-V now sends terminal selections too. A richer right-click layer sits on top of all of it. And while we were in there, we stopped silently overwriting your system clipboard.

What's New in v2.0.0

Every R-* now routes through your destination

In v1.0.0, R-L was the star and R-V had just landed. R-L was destination-agnostic: it dropped the link on the clipboard whether or not you had a destination bound. In v2.0.0, every send-style R-* command (R-L, R-V, and R-F) sends to your bound destination. If nothing is bound yet, the destination picker opens and the operation finishes against whatever you pick. Right-click context menu entries work the same way, so you don't have to memorise a keybinding to get the same flow.

R-V grew up. It used to send editor selections to your bound destination. Now it also sends terminal selections. Highlight some shell output, press R-V, and it goes straight to your bound destination. No more clipboard juggling to get test output into a prompt.

R-F: Send File Path. R-F sends the current file's workspace-relative path to your bound destination. R-shift-F sends the absolute path. Tell your AI assistant "look at this file" without typing the path or dragging the tab.

R-G: Go to Link. R-G opens a prompt; paste any RangeLink (something like recipes/baking/chickenpie.ts#L3C14-L15C9) and you land at that exact spot. Useful for jumping to RangeLinks your AI hands back.

We stopped messing with your clipboard

Every prior version of RangeLink wrote to your system clipboard as a side effect of nearly every operation. Even when the clipboard was just the transport to a destination, whatever you had copied before was gone. Slack message in your clipboard and you press R-L? Replaced. Text you were about to paste somewhere else? Gone.

v2.0.0 introduces the rangelink.clipboard.preserve setting (default "always"). RangeLink now snapshots your clipboard before each transport operation and restores it afterward. Your clipboard only changes when you ask for it: R-C or R-shift-C. If you preferred the old behaviour, set the preference to "never".

One picker, one menu: R-D and R-M

In v1.0.0, binding meant running a separate command for each destination type ("Bind to Terminal," "Bind to Claude Code," "Bind to Cursor AI").

R-D: Bind to Destination. One keybinding opens a single picker showing every available destination: AI assistants (built-in and any custom ones you've configured), terminals, and open files. AI assistants appear in a fixed order. Terminals and open files follow — if one of those is bound, it's pinned to the top of its section.

R-M: RangeLink Menu. Groups jump-to-bound, unbind, go-to-link, and show-version into one menu. Open the menu from the keybinding or by clicking the RangeLink item in the status bar. That status bar item now reflects your bind state: prominent colour when bound, with a tooltip naming the destination.

Don't want to memorize both R-D and R-M? R-M alone gets you far — when nothing is bound, it also lists available destinations so you can bind right from the menu.

Bring Your Own AI

RangeLink already had BYOD (Bring Your Own Delimiters) for cross-config link compatibility. v2.0.0 adds BYOA (Bring Your Own AI): a universal connector that turns any focus-friendly VS Code or Cursor extension into a RangeLink destination.

A new rangelink.customAiAssistants setting lets you point RangeLink at any such extension. You name the extension, list its commands, and RangeLink wires it into the R-D picker. The setting supports three command tiers: direct text insert, focus plus auto-paste, or focus plus manual paste. The configured assistants are shape-validated at startup; the first time you use one, RangeLink picks the highest-priority tier whose commands are actually registered in your session.

A minimal config for a hypothetical extension acme.powerful-ai-extension that exposes a direct-insert command:

"rangelink.customAiAssistants": [
  {
    "extensionId": "acme.powerful-ai-extension",
    "extensionName": "Powerful AI",
    "insertCommands": ["powerfulAi.insertText"]
  }
]

If the extension exposes a focus-and-paste command instead of a direct insert, swap insertCommands for focusAndPasteCommands. If it only exposes a focus command, use focusCommands and RangeLink will handle the paste step itself. You can list all three on the same entry as fallbacks; RangeLink picks the highest tier whose commands are actually registered.

The same setting lets you override the built-in mappings for Claude Code, Gemini, Cursor AI, or Copilot. That matters less for the rare command rename and more for the case where an extension ships a new command RangeLink doesn't know about yet. You don't have to wait for a RangeLink release to start using it.

Gemini Code Assist, built in

The fourth built-in lands too. The full built-in lineup is now Claude Code, Gemini Code Assist, Cursor AI, and GitHub Copilot Chat. No setup beyond installing the Gemini extension itself, and it shows up in the R-D picker alongside the others.

Right-click works everywhere now

New context menus in Explorer, Editor Tab, Editor Content, Terminal Tab, and Terminal Content. Each menu shows the actions that make sense for what you right-clicked: Send RangeLink, Send Portable Link, Send Selected Text, Send File Path, Bind Here, Unbind.

One worth singling out: right-click any file in the Explorer, pick "Send Relative File Path" (or "Send File Path" for the absolute version), and it goes straight to your bound destination. The file doesn't have to be open. R-F covers the current file; the Explorer entry covers any file in your workspace. Bind RangeLink to your preferred AI tool and you can dump file paths into your prompt about as fast as you can right-click.

You'll know when there's a new version

VS Code itself shows a "What's New" tab for editor releases, but extensions auto-update silently in the background. RangeLink v2.0.0 closes that gap with a once-per-upgrade toast: "What's New" opens the release notes, "Skip for this version" silences it for the current release. Dismiss without acting and it quietly reappears next time the extension activates, until you actually click one of the buttons. No nagging.

The R-Keybinding Family in v2.0.0

Keybinding	Letter	Uses bound destination	Does
R-L	L for Link	✓	Generate a RangeLink at the current selection
R-V	V for paste	✓	Send selected text from editor or terminal
R-F	F for File	✓	Send the current file's path
R-C	C for Clipboard	—	Copy a RangeLink to clipboard only
R-D	D for Destination	binds it	Open the destination picker
R-M	M for Menu	acts on it	Open the RangeLink menu (jump, unbind, go to link, version)
R-J	J for Jump	focuses it	Focus your currently bound destination
R-G	G for Go to link	independent	Paste a RangeLink and jump straight to it
R-U	U for Unbind	unbinds it	Unbind the current destination

Upgrading from v1.0.0

A few things to know:

Your clipboard is no longer collateral damage. Anything you copied before pressing R-L, R-F, or R-V is still there afterwards. Set rangelink.clipboard.preserve to "never" if you preferred the old behaviour.
Every R-* command now routes through your bound destination. R-L, R-V, and R-F all send to whatever you've bound. If nothing is bound when you press one, RangeLink prompts you to pick a destination instead of writing silently to the clipboard.
Binding gets a keybinding: R-D. In v1.0.0, binding was only available through the command palette. R-D opens a unified destination picker so you can bind without hunting through menus.

Try it out

Install:

VS Code: VS Code Marketplace
Cursor: Open VSX Registry
Project home: ouimet.info/projects/rangelink-extension.html

Quick start:

Press R-D and pick a destination from the list
Select some code, press R-L, and your RangeLink lands in the destination
Press R-F to send the current file's path
Highlight some terminal output and press R-V to send it
Right-click any file in the Explorer and pick "Send Relative File Path" (no need to open it first)

So why did it take six months?

Every feature above touches foundational layers. R-D pulled the separate bind commands into a single picker and made every R-* (except R-C) demand a bound destination instead of falling through to the clipboard. BYOA changed the command-dispatch path that most of the existing tests already ran through, which meant a lot of assertions had to be retraced. And clipboard preservation touched every R-* command that used the clipboard as a transport step. The unit tests that carried v1.0.0 were solid, but they were not going to catch a regression in any of those.

So I built a real integration-test harness first. Over 290 integration tests across more than 30 suite files, all running inside an actual VS Code host with live terminals, editor groups in different layouts, and AI extensions pre-installed for the runner (Claude Code, Gemini Code Assist). Roughly two-thirds are fully automated, another third are human-in-the-loop "assisted" tests for flows VS Code's automation API can't drive on its own, and a handful are still manual.

It's the testing harness I wish I'd had when v1.0.0 shipped. It's also the reason I kept pushing the release date out: I wanted to be able to look at the v2.0.0 release notes and trust them.

That's what I've been cooking. It's finally yours.

Happy (Range) Linking!

If RangeLink is useful to you, star the GitHub repo and report issues or ideas via GitHub Issues.

Links:

About the author — Charles Ouimet is a Principal Software Developer in Montréal. He builds tools like RangeLink to fix the annoyances he runs into himself, balancing distributed systems by day with questionable side-project decisions by night. If something here helped you, coffee's always appreciated.

Correlation ID vs Request ID: A Practical Guide

Charles Ouimet — Wed, 10 Jun 2026 02:00:42 +0000

A request hits your API. Your service calls two others. One of them calls two more. The first downstream call times out, so you retry. Something fails. You open the logs.

Can you trace the full journey end-to-end? Can you tell which entries are the retry?

Two identifiers answer these questions.

Correlation ID links everything across an end-to-end flow. It stays the same from the first inbound request through every downstream call. Request ID identifies a single hop. Each outbound call gets its own. Retry a call, and you get the same correlation ID under a new request ID.

They complement each other, and understanding the distinction is the difference between logs that help and logs that taunt.

I've built this pattern more than once. Each time, I went looking for one good article to send the team and came up short -- every piece I liked either stayed in reference-doc weeds or pivoted straight to OpenTelemetry traces. None reached for the analogy that made it click for me. So I wrote the one I wish I'd had.

The kitchen

Picture a kitchen brigade:

Chef -- gets the ticket, calls SousChef and LineCook
SousChef -- handles recipes, delegates to PrepCook and DishWasher
LineCook -- executes the dish
PrepCook -- prepares ingredients
DishWasher -- provides clean plates

The ticket and the shout

The table ticket is your correlation ID. Table 4's ticket stays pinned to the rail from the moment the waiter clips it there until the dish goes out. Every station reads the same ticket number. PrepCook knows it's for table 4. LineCook knows it's for table 4. Nobody asks which table is this for? because the ticket never changes hands.

Each shout between stations is a request ID. When Chef shouts "Fire table 4, two salmon!", that shout gets its own identifier. If LineCook doesn't respond, Chef shouts again -- same ticket, new shout.

Mise en place

In a kitchen, mise en place means prepping and organizing every ingredient before the first pan hits the flame. When service starts, you reach for what you need without thinking. Our code needs the same.

CorrelationId and RequestId are Value Objects: tiny, immutable wrappers. Pass a ticket ID where a shout ID belongs and the compiler stops you.

class CorrelationId {
  private constructor(private readonly value: string) {}
  static create(): CorrelationId { return new CorrelationId(uuid()); }
  static fromString(value: string): CorrelationId { return new CorrelationId(value); }
  toString(): string { return this.value; }
}

class RequestId {
  private constructor(private readonly value: string) {}
  static create(): RequestId { return new RequestId(uuid()); }
  static fromString(value: string): RequestId { return new RequestId(value); }
  toString(): string { return this.value; }
}

The other half of mise en place is making these available everywhere without passing them around. The middleware at the boundary pushes them into two places:

Async-local context: OpenTelemetry's AsyncLocalStorageContextManager wraps execution so ExecutionContext.correlationId and ExecutionContext.requestId behave like globals within the async call chain. (It's the modern successor to AsyncHooksContextManager and requires a recent Node runtime.) At the boundary, a call to ExecutionContext.run(...) populates the context; any code downstream reads from it without needing the IDs passed explicitly.
The logging tooling: The logger is ExecutionContext-aware: every log entry automatically carries correlationId and requestId. In the examples below, log.info() only passes extra context like fn or url -- the core IDs are added automatically, as the inline comment notes.

Business code rarely touches ExecutionContext directly. It just logs what it's doing. The IDs are present on every entry, searchable and filterable, without a single explicit reference in the business logic.

The examples below use UUID v4. Whether that's the right format for your system is a separate question — Hilton's article on microservice correlation IDs covers the tradeoffs.

Tickets from the front of house (your public API)

A request lands at your public API. You generate both IDs yourself. Accepting an external caller's correlation ID or request ID means relaying uncontrolled data into your internal logs. A buggy client sending x-correlation-id: foo for every request pollutes every downstream service's logs with the same value. Same goes for x-request-id.

// Public API middleware
app.use('/api/public', (req, res, next) => {
  const externalCorrelationId = req.headers['x-correlation-id']; // remembered, not used
  const externalRequestId = req.headers['x-request-id']; // remembered, not used
  const correlationId = CorrelationId.create().toString(); // our table ticket
  const requestId = RequestId.create().toString(); // our shout

  res.setHeader('x-correlation-id', externalCorrelationId || correlationId); // echo back theirs
  res.setHeader('x-request-id', externalRequestId || requestId);

  ExecutionContext.run({ correlationId, requestId }, () => {
    // correlationId and requestId are automatically added to every log entry by the logging tooling
    log.info({ fn: 'publicApiMiddleware' }, 'request received');
    next();
  });
});

Echoing the caller's original IDs back on the response is a nicety: they get their IDs back for their own tracing, but your logs stay clean. You can also add x-correlation-id-internal and x-request-id-internal response headers with the IDs you used internally so callers can reference them when reporting issues. The tradeoff: this exposes internal identifiers, which some organizations consider a data leak.

Your own crew (your internal API)

When all your callers are your own kitchen stations, accepting their request ID lets them grep your logs when SousChef asks why the steak showed up instead of the salmon (debugging a failed request), when the manager wants to know why the salmon went out cold (latency investigation), or when the health inspector wants the full ticket timeline (audit).

// Internal API middleware
app.use('/api/internal', (req, res, next) => {
  const correlationId = req.headers['x-correlation-id'] || CorrelationId.create().toString();
  const requestId = req.headers['x-request-id'] || RequestId.create().toString(); // trust the crew's shout

  res.setHeader('x-correlation-id', correlationId);
  res.setHeader('x-request-id', requestId);

  ExecutionContext.run({ correlationId, requestId }, () => {
    // correlationId and requestId are automatically added to every log entry by the logging tooling
    log.info({ fn: 'internalApiMiddleware' }, 'request received');
    next();
  });
});

Both middlewares fit in the same app, each scoped to its own route group. The boundary between internal and external is already in your route registration.

The table ticket (correlation ID) is the cross-station link. The trust decision is structural -- once you've drawn the line in your route registration, you don't make it again at every request.

Shouts across the stations (your internal outbound calls)

Every time Chef calls out to another station, the table ticket (correlation ID) gets forwarded but the shout (request ID) is always new -- generated before the call goes out so you have an ID to log against even if the call times out. Because ExecutionContext.run(...) was called at the inbound boundary, the correlation ID is globally available -- the interceptor reads it without needing req in scope.

// Axios outbound interceptor
axios.interceptors.request.use((config) => {
  const correlationId = ExecutionContext.correlationId?.toString() || CorrelationId.create().toString(); // same table ticket, or a fresh one if no inbound context
  const outboundRequestId = RequestId.create().toString(); // new shout, local to this hop

  // The auto-added requestId is still the INBOUND one (the logger pulls from
  // ExecutionContext); log outboundRequestId explicitly so this hop is traceable.
  log.info({ fn: 'outboundInterceptor', url: config.url, outboundRequestId }, 'outbound call');

  config.headers['x-correlation-id'] = correlationId;
  config.headers['x-request-id'] = outboundRequestId;

  return config;
});

One subtle thing about the log line above: log.info() auto-injects the requestId from ExecutionContext, which is still the inbound request ID (the inbound call hasn't finished yet -- we're mid-flight). The new outbound ID lives only in this function's local scope, so passing it as requestId would get overridden by the logger's auto-injection. Log it under a different key (outboundRequestId above) and it sits alongside the auto-injected fields without colliding. From the downstream service's perspective the same ID lands as x-request-id on the wire and becomes their inbound requestId -- the "outbound" qualifier is only meaningful here, on the caller side.

Chef clips ticket-4 to the rail. "Fire table 4, two salmon!" LineCook is buried under a stack of tickets, three pans going. No response. Chef shouts again, louder. Still nothing. Third call, LineCook finally yells back "Heard!" Each shout lands in the log under the same ticket number (correlation ID) with a fresh shout ID (request ID).

Shout IDs above are numbered from 1 for clarity. In the full trace at the end of the article, they follow the global sequence across all five stations.

Orders to the suppliers (your external outbound calls)

Sometimes Chef needs ingredients the kitchen doesn't make. The bread comes from the bakery, the fish from the fishmonger, the produce from the market. When Chef calls the fishmonger to order 5 lbs of salmon by 10am, the kitchen's internal table ticket is irrelevant to the fishmonger -- and forwarding it would tell them more about your operation than they need to know.

The same applies to outbound HTTP calls to third-party APIs (payment processors, mapping services, vendor integrations). Forwarding your internal x-correlation-id and x-request-id headers to an external service leaks information about your request flow into a system that doesn't need it, and may store it in their logs indefinitely. Scope the outbound interceptor to your internal HTTP clients only, or add a URL allowlist that excludes external hosts.

If the third-party returns its own correlation or request ID on the response, record it on your side. It's the thread that ties your logs to theirs when you need to debug a cross-system issue.

Takeout orders (async messaging)

The pattern above is HTTP-shaped, but the boundary is the only thing that matters. A Kafka consumer, SQS handler, or Kinesis processor pulls the correlation ID out of message headers or record metadata, calls ExecutionContext.run(...), and from there the rest of the code is identical. The transport changes; the approach doesn't.

One trace, one picture

Five stations, one table ticket. The correlation ID is the value that doesn't change. The request ID is the value that does -- every shout from Chef to a station gets its own, every retry gets a fresh one, every downstream call too. Read the trace by following the correlation ID down the page; read the retries by spotting the request IDs that bunch up under the same correlation ID.

When this stops being enough

This pattern -- correlation ID at the boundary, request ID per hop, both on every log line -- holds up until your system grows in complexity. When the debugging question becomes where in this 14-service flow did 80% of the latency get spent?, you've outgrown correlation IDs and you want OpenTelemetry traces. Last9's piece on correlation ID vs trace ID (in References below) is the right next read for that step -- it goes deeper into trace IDs than this article wanted to.

Same name, different recipe

x-correlation-id is used differently across the industry. This article treats it as a trace ID -- fresh per inbound boundary entry, propagated across downstream calls. Adobe's API uses it as an idempotency key instead -- a stable identifier the client reuses across retries of the same business intent so the server can return the cached response. The two uses are incompatible. If you're integrating with a service that enforces idempotency on x-correlation-id, pick a different header (or namespace your own) for the trace ID described here. Stripe's Idempotency-Key is the cleaner pattern -- a dedicated header for idempotency, no collision with tracing.

Start with the paring knife

Two value objects, one async-local context, an ExecutionContext-aware logger, a couple of middlewares, one interceptor. Reach for the cleaver when the system asks for it, not before. This is what worked in real systems -- search correlation_id in my career changelog to see where.

Open the logs. Filter by correlation ID and you have the journey. Filter by request ID and you have the one retry, alone, no noise.

References

Fix: "There's an issue with the selected model (deepseek-v4-pro)" in Claude CLI

Charles Ouimet — Fri, 05 Jun 2026 03:59:10 +0000

If you landed here from a search engine, here's the error you saw:

There's an issue with the selected model (deepseek-v4-pro). It may not exist or you may not have access to it. Run /model to pick a different model.

You had the eight env vars from my previous article set. You opened a fresh terminal, typed claude, and got that. Same.

A quick glossary for this article: claude-code is the brew package. claude is the command you type in your terminal.

I thought Anthropic was on to me

I'll admit where my brain went first: Anthropic had patched claude-code to block non-Anthropic API keys. DeepSeek built a fully backwards-compatible API: same endpoints, same request shape, same response format. Anthropic ships a new claude-code version, I run brew upgrade without thinking, and suddenly my DeepSeek setup breaks. The timing was too clean.

And here's the really self-absorbed part of this theory: my article explaining the DeepSeek setup had been live on dev.to for a couple weeks. It was getting reads. What if someone at Anthropic saw it and that was their "alright, that's enough" moment? A human being in San Francisco read my post, opened a Jira ticket, and a week later the validation shipped.

Classic Coyote: draw the plan, check the ground later. Anthropic, a company with thousands of employees building frontier AI, was not reacting to my dev.to post. They probably have bigger things to worry about than one person's $10 DeepSeek bill. But the theory felt good, and the error message didn't give me much else to work with.

I also googled the exact error string. Zero English results. A few forum posts, all written in 中文. That vacuum didn't help. When nobody in English is talking about an error, your brain writes its own screenplay. Mine went full Wile E. Coyote, sketching elaborate traps that weren't there.

What was actually happening

claude wasn't contacting DeepSeek at all. It was talking to Anthropic.

The reason was a missing newline in my setup script. After publishing the original article, I'd moved the eight export lines into ~/point-to-deepseek.sh so I could source the file instead of pasting the block into my terminal. API keys are like underwear: you don't share them, and pasting one into a terminal left it sitting in my scrollback for anyone to see.

In that file, two lines had merged into one. The line starting with export ANTHROPIC_BASE_URL=... had the export ANTHROPIC_AUTH_TOKEN=... line glued to its end, with no newline between them. The shell saw one corrupt line. ANTHROPIC_AUTH_TOKEN never got exported. ANTHROPIC_BASE_URL got set to nonsense.

Coyote looked down.

# what the shell saw (broken)
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic export ANTHROPIC_AUTH_TOKEN=sk-xxx

# what it should look like (fixed)
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=sk-xxx

A related edge case: resuming a DeepSeek session in an Anthropic context

I said my panic was a false alarm, but one thing has actually changed since I wrote the original setup guide. When I first published it, I was routinely starting sessions on one provider and resuming them on the other — mostly DeepSeek sessions that I'd pick back up on Anthropic after my 5-hour quota reset. That stopped working about a week or two ago.

If you start a claude session pointed at DeepSeek, /exit, then try to /resume it from a claude instance pointed at Anthropic, you get:

API Error: 400 messages.1.content.0: Invalid `signature` in `thinking` block

The reverse still works. I resume Anthropic sessions on DeepSeek every day with no issues. So it's not a two-way wall — it's a one-way door, and it only catches you going in one direction.

Whether it's a deliberate countermeasure or a format mismatch between two implementations of the same API is unconfirmed. But unlike my imaginary claude-code patch, this one is real.

Why I'm really writing this

I said zero English results. That vacuum is the real reason this article exists. Somebody is going to hit this error, google it, and land here. That's the bet.

And now I'm publishing a second article about a missing newline, SEO-optimized around an error message, hoping Google indexes it before the next person loses time to this.

I'd spent half an hour convinced I was the protagonist in a David-and-Goliath story about API compatibility. Anthropic had noticed my workaround. They'd shipped a countermeasure. I was drafting the exposé in my head. Classic Coyote.

The eight env vars still work. I'm still using them.

If you got here from the error message, I hope this saved you the 30 minutes I lost. Never saw the original setup? It's here.

My friend Joel, after I shared a recent article on LinkedIn: "You can't teach old dogs new tricks, but you can force them to become LinkedIn influencers!" I am now publishing a second one about a missing newline. Yeah, I'm looking at you, dear Joel. 😉

I sold you on /scratchpad. Then I migrated to /note.

Charles Ouimet — Thu, 21 May 2026 13:21:14 +0000

This is the third post in a series that started with vibe guiding and continued with an efficiency audit. Two months ago I laid out the four-skill loop: /start-issue writes a /scratchpad, /tackle-scratchpad-block executes one step at a time, status flags transition from pending to done, and /finish-issue reads what shipped and writes the PR title + description.

Why I changed my mind

The driver was token consumption. My employer gave each team dashboards of our AI tool usage and I was always the top consumer on mine — fairly high on the department chart too. That's when I started to suspect it was not what I was building but how I was working with the tools.

/scratchpad's JSON step block and /tackle-scratchpad-block chain meant every task paid the same ceremony tax: status flags to transition, JSON to validate, a fenced block to parse. Useful scaffolding for multi-hour work. Overhead I was paying on every session. If my process was the reason I topped the dashboard, revisiting it was the cheapest experiment I could run.

Once I started looking, the redundancy wasn't only scratchpad-vs-note. The templates the composite skills were generating — what /start-issue, /start-side-quest, /tackle-pr-comment, and /finish-issue wrote into their output documents — carried weight they didn't need. A few examples from the audit that led to PR 130:

## Files to Modify re-grouped information the Plan steps already named, just organized by file.
## Documentation & Discoverability was a pre-populated checklist that /finish-issue already re-derived systematically at wrap-up time.
## Acceptance Criteria had Claude copy criteria verbatim from the issue body it already had in context.
## Why Split This Out was three hardcoded bullets that matched every side-quest ever created.

Each of these was small on its own. Cumulatively they were a per-session surtax, paid every time a skill fired. Defaulting to /note instead of /scratchpad was the biggest single cut, but the pattern of the change was wider: stop having the LLM write the same information twice, in different shapes, into different documents.

Claude was changing too

The other thing that shifted in those months was Claude itself. When I first wrote about this, the hard stops at every step made sense for the Claude that was around then. By the time PR 130 landed, Claude had gotten noticeably better at multi-step self-organization across an issue. I could lower my guard a bit. The control-freak posture I had started with was no longer needed. If I wanted an explicit checkpoint to manually review and commit, I could simply add a step in the generated /note.

Parallelism shifted too. Claude gained the ability to fan out workers and run agents in parallel within a single session, which meant on issues with independent pieces Claude could organize its own throughput faster than I could shepherd it through the /tackle-scratchpad-block chain. The gates that had once added safety started adding latency. By gating with /tackle-scratchpad-block, I was slowing Claude down by asking for more control.

What `/note` looks like

A /scratchpad's ## Implementation Plan section is a fenced JSON block with status fields, dependency arrays, and task lists:

{
  "finish_issue_on_complete": false,
  "steps": [
    {
      "id": "S001",
      "title": "Swap the token library",
      "status": "pending",
      "done_when": "Old lib removed from package.json, new one imported and passing existing tests",
      "depends_on": [],
      "files": ["package.json", "src/auth/token.ts"],
      "tasks": [
        "npm install new-token-lib, npm remove old-token-lib",
        "Update src/auth/token.ts imports",
        "Run the token test suite"
      ]
    },
    {
      "id": "S002",
      "title": "Update callers to match new token API",
      "status": "pending",
      "depends_on": ["S001"],
      "files": ["src/middleware/auth.ts", "src/routes/login.ts"],
      "tasks": [
        "Update verifyToken() call sites to new API shape",
        "Run full test suite"
      ]
    }
  ]
}

A /note's ## Plan section is the same information without the scaffolding:

1. Swap the token library — npm install new-token-lib, update imports, run the token test suite
2. Update callers to match the new token API — verifyToken() call sites, full test suite

No fenced JSON block. No status: pending. The plan says what to do and in what order; the LLM organizes its own execution in-session. The hard stops from the original workflow are still there: I read the plan before saying "go ahead", I review the diff, I commit when I'm satisfied. The commit lands at the end of the note, not after every step. If I want an earlier checkpoint, I add an explicit gate in the plan.

/scratchpad is still there. You opt in two ways: pass --scratchpad to the invoking skill, or use one of the natural-language triggers the skill watches for ("use a scratchpad", "with step tracking", "formal plan", "track steps"). I still reach for it when I'm working through a larger GitHub issue and want a commit after each step instead of one at the end. This is especially helpful when I'm juggling two or three worktrees on the same project — iterative commits and step tracking keep me oriented when my attention is split across parallel branches.

What I am taking away

The /note flow still stops for plan review before anything happens, then gives the LLM more autonomy to fan out and move faster. The /scratchpad flow is still powerful — but you don't always need a bazooka to kill a fly. Most days the lighter tool is enough, ending on a high note.

If you already use these skills

Pull the latest from the repo and run ./setup.sh to symlink the updated set. /start-issue will produce a /note on your next invocation. Nothing else changes — the rest of the loop carries on. If you want the old behavior, type --scratchpad.

Written using the same skills it describes, starting from issue #139. The plan was a note this time.

Eight env vars and Claude Code stops eating my paycheck

Charles Ouimet — Tue, 12 May 2026 13:19:32 +0000

Update (2026-06-04): Running into model errors with this setup? Read the investigation here.

DeepSeek's quick-start page has been live for months. I'm late to it.

I love what Anthropic ships. Opus 4.7 is the best coding model I've used. I also can't run it all day on a family budget, and Pro's 5-hour quota wall stopped my flow more times than I want to count. So a few days ago I exported eight env vars, pointed Claude Code at DeepSeek, and went back to building rangeLink. Since then I've only spent $4 and haven't seen a rate limit.

The eight env vars

export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=<your-deepseek-key>
export ANTHROPIC_MODEL=deepseek-v4-pro
export ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-v4-pro
export ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-v4-pro
export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-v4-flash
export CLAUDE_CODE_SUBAGENT_MODEL=deepseek-v4-flash
export CLAUDE_CODE_EFFORT_LEVEL=max

Run that block in your terminal, then invoke claude-code.

What's going on in there

The subagent model points to deepseek-v4-flash instead of v4-pro. Claude Code spawns subagents for grep-and-summarize work, and there's no reason to pay pro rates for "find the file that has this string." Flash is good enough for that, and it returns faster.

CLAUDE_CODE_EFFORT_LEVEL=max keeps the quality slider cranked on the cheap path. The flag exists; you may as well use it.

Anthropic's three tiers (Opus, Sonnet, Haiku) get collapsed onto DeepSeek's two. Opus and Sonnet both map to v4-pro because that's the strongest model DeepSeek serves. Haiku goes to v4-flash because nothing about Haiku-class work needs more than that.

Why I'm still using this a week later

Cost. I bought $10 of deepseek-v4-pro credits last week. After five days of 3-6 hours a day on rangeLink, $6 is still on the meter. I stopped checking the balance after day three because it wasn't going anywhere fast.

No 5-hour quota wall. Anthropic Pro's quota window resets on a 5-hour cycle, and hitting it mid-task is the worst kind of interruption. You've built up context, you're in the middle of something, and now you're either waiting or paying for top-up. Since I switched: zero waits. Not "fewer." Zero.

The second one matters more than I expected. Going in, I was solving for cost. I figured rate limits were a nice-to-have.

The catch I hit

Pasted images in the terminal don't make it through to DeepSeek's API. If your workflow leans on screenshots — "look at this dev-tools error" or "match this design" — this swap will hurt.

Community work is happening here. I'm not going to recommend anything I haven't fully tested.

Same trick, different provider

A friend was already running DeepSeek with OpenClaw and happy with it, so I copied his pick when I made the switch. Two worth a look as of May 2026:

Moonshot Kimi K2.5 — ANTHROPIC_BASE_URL=https://api.moonshot.ai/anthropic, model kimi-k2.5. Moonshot's Claude Code setup docs.
Z.ai GLM-5.1 — ANTHROPIC_BASE_URL=https://api.z.ai/api/anthropic, model glm-5.1. Z.AI Claude Code docs.

If you've run Kimi or GLM with Claude Code, I'd be curious how it went.

A note on privacy

Your prompts go to DeepSeek's servers. Fine for my public-repo work. Pick a provider whose data policy matches your repos' sensitivity.

Five days, $4 spent, zero rate-limit walls.

If your employer foots the Anthropic bill, or your wallet can swing a Max plan, by all means — Opus 4.7 is still the best at the top end. If that's not you, eight env vars.

Co-Authored-By: Claude <noreply@anthropic.com> (running on deepseek-v4-pro)

I thought I was DRY-ing. I may have been double-paying.

Charles Ouimet — Tue, 21 Apr 2026 12:30:29 +0000

Update (2026-05-21): I've kept iterating since this post. See the move to /note for the May 2026 shift.

Something was off

A few weeks after publishing From Vide Coding to Supercharged Vibe Guiding, I landed pull/121 — a follow-up refactor that made /scratchpad, /question, and /commit-msg "self-contained" by inlining a foundation skill's logic into each of them. I was expecting lighter sessions afterwards. I couldn't tell if I got them. The next refactor on my list was "inline more of these foundations" and I caught myself about to make the same bet twice — without ever having checked whether the first one paid off.

My theory at that point, the one driving both refactors, was that the foundation skills were what cost too much. /code-ref for code-link format, /github-ref for issue-URL format, /issue-context for figuring out which directory a scratchpad should go in — all auto-consulted by Claude constantly. The working assumption was that the cross-references themselves were the tax. Inline the rules, kill the foundations, buy the tokens back.

My hypothesis may have had the cost in the wrong place. At least, an independent audit thought it did.

So I let another Claude run the audit

Doing the audit myself would have confirmed my bias. So I opened a fresh Claude Code session, told it explicitly not to run my own /audit-efficiency skill, not to read my README or CHANGELOG, and asked six specific questions:

Where is token budget being spent unnecessarily?
How often is each overhead paid (once per session, once per invocation, once per skill type)?
Rank the findings with your own labels. Don't use the HIGH/MEDIUM/LOW my existing audit skill uses.
For each top finding, propose at least two fixes including "do nothing."
Separately, flag anti-patterns about reliability and maintainability, not just efficiency.
End with: "What question would you have asked me before starting this audit if you could?"

The full prompt, verbatim, with a short note on its design rationale, lives in the repo at docs/run-an-audit.md.

Claude dropped a timestamped report in /tmp/. I read it cold. The executive summary opened with:

The largest recurring cost in this collection is a self-inflicted duplication of branch-parsing + filename logic inlined into scratchpad, question, and commit-msg.

The day before, I'd refactored those three skills to make them "self-contained" — taken about 35 lines of branch-parsing Markdown out of a shared foundation and pasted the same block into each caller. The idea was to stop paying for the foundation's auto-consultation. What actually happened: the foundation kept auto-consulting anyway (its description line advertised itself for exactly that workflow), the same logic was now sitting in three places, and the copies had already started drifting. The foundation's examples list didn't match the inlined copies and I hadn't noticed. So I had two copies of drifting logic and, if the audit's cost model is right, was paying for both.

My hypothesis was backwards

I'd gone in assuming DRY-via-cross-references was the tax. The audit's sharper version was more like: half-finished migrations can cost tokens, and deterministic logic in Markdown tends to cost tokens whether it's DRY or not. That's a working theory, not a measurement — but it's a theory I was already primed to believe once the drift was in front of me.

The audit pointed at two skills it thought were well-shaped — /auto-number and /ensure-gitignore. Both are foundation skills whose SKILL.md just documents a shell-script contract. The script does the work. Claude calls it and reads one line of stdout. Zero reasoning burned per invocation.

That was the pattern I should have been trying to extend. With the audit in hand, pull/121 looks like the wrong direction — it added more Markdown where, in retrospect, a shell script fits better.

What the audit found

Findings in my paraphrase of the audit, ranked by how often it thought the cost was paid:

F1, per-invocation bleed. The branch-parsing + filename block inlined into /scratchpad, /question, and /commit-msg. Paid every time any of them fires, plus transitively when /start-issue, /tackle-scratchpad-block, /finish-issue, and /tackle-pr-comment invoke them.

F2, per-session surtax. A three-line "Output Format" epilogue (hard-wrap rule, code-reference rule, GitHub-URL rule) copy-pasted into 11 skills. Two existing foundations (/code-ref, /github-ref) already covered the same rules.

F3, structural debt. /issue-context was in a halfway state. Its content had drifted from the inlined copies. A direction had to be picked and finished.

F4, per-session surtax. The two longest skill descriptions (/scratchpad at 316 chars, /tackle-scratchpad-block at 275) loaded into the catalog on every session, even when neither was invoked.

F5, structural debt verging on bleed. The step-JSON schema redrawn in five places instead of once.

The pivot

Before any edits, I worked through six scoping questions in a /question file and had the Claude session read them back. One question carried most of the weight: pick delete-and-script, delete-and-inline-more, restore-the-foundation, or status quo for /issue-context.

I picked the script route. I'd already done it twice. /auto-number collapses "scan this directory, find the highest number, add one, zero-pad it" into one Bash call. /ensure-gitignore collapses "read the file, check for the sentinel, append if missing" the same way. "Read the branch, extract the issue ID, decide where the file goes, slugify the description, and auto-number it" is the same shape of problem.

I called it target-path.sh. One call, one line of stdout:

skills/issue-context/target-path.sh --type scratchpads --description "audit follow-up"
# → .claude-work/issues/120/scratchpads/0003-audit-follow-up.txt

Each of /scratchpad, /question, and /commit-msg dropped from a roughly 45-line Step 1 block to this:

Run these two commands as parallel tool calls. They are independent.

- skills/issue-context/target-path.sh --type <type> --description "$ARGUMENTS"
- skills/ensure-gitignore/ensure-gitignore.sh

Use the stdout of the first command as the full file path.

The /issue-context foundation went from 118 lines of branch-parsing prose to 30 lines that just document the script's contract.

For F2, I folded the hard-wrap rule plus the two reference-format rules into a single new /prose-style foundation. Then I deleted the epilogues from all 11 callers and replaced each with a one-line pointer: Formatting: see /prose-style. The standalone /code-ref and /github-ref foundations got folded into /prose-style too, then deleted. Side effect: a dangling symlink at ~/.claude/skills/prose-style that had been pointing at a non-existent directory for months finally had something to point at. I hadn't noticed it was broken.

F4 (descriptions) and F5 (JSON schema redrawn) were one-shot edits. Shrink two descriptions. Replace three inline JSON blocks with references to the authoritative schema in /scratchpad.

What this might save in tokens

Counting SKILL.md content only, the before state was roughly 25,600 tokens and the after state is roughly 21,500. About 4,100 tokens lighter, call it 16%. Treat every token count here as a ~4-chars-per-token ballpark, not a microbenchmark.

The static diff is the part I can actually count. Everything beyond that is arithmetic on the audit's cost model, not a measurement — token consumption is hard to predict when you're not deep in how these systems load context. So take what follows as "if the audit is roughly right, this is what the math would look like."

On a typical full-time coding day I run this loop 25+ times: plan via /scratchpad, surface a design question via /question when something needs one, tackle a block, draft a /commit-msg. That's only about three cycles an hour. When I'm iterating on small pieces, I easily hit 10 cycles an hour. By lunchtime I've already blown past what used to feel like a full day's worth of context.

If the audit's model holds, each cycle was spending around 140 tokens of branch-parsing Markdown re-reasoned per /scratchpad call, the same pattern on /question and /commit-msg, plus the /issue-context foundation body pulled in by description match whenever any of them fired. Call it 500 to 1,000 tokens per cycle in duplicated logic.

Multiply by 25 cycles and the refactor might buy back somewhere in the tens of thousands of tokens a day. Double that on a heavy iteration day. The 4,100 tokens I shaved off the static diff is the boring headline; the number that might actually change my workday is closer to 25,000 to 50,000 tokens not being burned on the same deterministic logic over and over. Would I have noticed that in practice? Honestly, I don't know. The real move — the one I should have started with — is to measure often and keep optimizing for whatever actually shows up.

What I'm taking away

"DRY is good" and "DRY costs tokens" feel like slogans that don't quite capture what I ran into. What I'm starting to think matters more is whether the logic you're trying to deduplicate is deterministic. When it is, my bet is Markdown's the wrong container — a script that returns one line of stdout fits the shape better, and lets Claude spend its reasoning on the parts that need it. The three scripts carrying the load here (auto-number.sh, ensure-gitignore.sh, and now target-path.sh) all fit that shape.

The halfway migration is the one the audit saved me from. My previous refactor inlined three skills and left the foundation in place, and I'd have kept maintaining both without realizing the shape was broken. Committing to either direction would probably have been cheaper than the in-between state I shipped.

One more thing about the audit itself. If I'd run it myself I'd have confirmed my hypothesis and doubled down on inlining — the same move that caused the problem in the first place. Pointing a fresh Claude session explicitly at what not to look at was the cheapest way I had to step outside my own framing. Obvious in hindsight. Wasn't at the time.

Which leads to the last decision in this refactor: I deleted my own /audit-efficiency skill. Once the cold audit clearly produced a stronger report, keeping the biased version around made it likely I'd reach for it next time. The prompt from this post replaces it at docs/run-an-audit.md — a file you paste from, not a skill you invoke. That's the whole operational artifact now.

If you want to try this

The prompt lives in the repo at docs/run-an-audit.md. Copy it and paste it into a fresh Claude Code session.

Written alongside the refactor PR itself using the same skills it describes.

From Vide Coding to Supercharged Vibe Guiding

Charles Ouimet — Mon, 16 Mar 2026 13:52:14 +0000

Update (2026-05-21): I've kept iterating on this workflow since publishing. See the audit pivot for what changed in April 2026, and the move to /note for the May 2026 shift.

It's Not a Typo

"Vide" means empty in French. And that's exactly what unstructured AI coding produces when the vibes run out.

I run multiple Claude Code agents in parallel across git worktrees every day. I'm not here to tell you to stop using AI for development. But when a SaaStr founder lost his production database to an AI coding agent in July 2025, it confirmed something I'd already learned: vibes alone aren't enough.

The answer isn't less AI. It's more guidance.

The Missing Piece: Guidance

Claude Code is powerful, but out-of-the-box sessions are ephemeral — context evaporates between tasks, there's no trail of decisions, and commits happen whenever the AI feels like it.

So I built a set of custom skills — portable markdown instructions that Claude follows when you type /skill-name in Claude Code (skills are a standard Claude Code extension mechanism). They live in ~/.claude/skills/ — install once, use everywhere. They encode a simple contract:

Questions go to files, not chat. /question creates a structured document I edit directly — not a conversation that scrolls away.
Never implement before the plan is approved. /scratchpad saves plans to files I control. I iterate until I'm satisfied, and every block the AI tackles comes from a plan I've reviewed.
Never auto-commit. /commit-msg writes a draft file. I review and commit manually.

These aren't complicated rules. But they're the difference between vide coding and what I call vibe guiding — you steer the AI through a structured workflow instead of hoping it gets the next thing right.

Optional but useful: I also use RangeLink to navigate scratchpads with precise line references — it makes reviewing plans faster, but the skills work perfectly without it.

What This Looks Like in Practice

Skills keep evolving — see the latest workflow on GitHub.

I documented a full issue lifecycle — every artifact real, nothing fabricated. Here's the compressed version:

1. /start-issue — I point Claude at a GitHub issue. It fetches the details, creates a branch, explores the codebase, and writes an implementation plan via /scratchpad with concrete steps — each with its own status and defined interdependencies. Then it stops and waits.

2. I review the plan. Sometimes I adjust scope. Sometimes I use /question to surface design decisions in a structured file. The plan lives in a file I can read, edit, and come back to — not buried in a chat transcript.

3. /tackle-scratchpad-block — I point Claude at one step or a set of steps from the plan. It executes them, runs tests, updates each step's status in the scratchpad, and writes a commit message draft. It does not commit. I review the diff, review the message, and commit when I'm satisfied.

4. Repeat until all steps are done. Because steps have explicit interdependencies, independent ones can be tackled by parallel agents within the same worktree for faster throughput. One caveat: parallel agents may touch the same files across different tasks, so hand-picking staged blocks for truly atomic commits gets tricky — the practical trade-off is to embrace the parallelism and accept slightly larger commits.

The scratchpad evolves as I iterate — I might spin off a new /scratchpad with pros and cons to evaluate an approach, then integrate the decision back into the main plan. The thought process lives in files, not in my head.

5. /finish-issue — Claude runs verification (lint, tests), checks if documentation needs updating, and generates a PR description. It does not create the PR. I review and submit.

At every stage, I'm in the loop. The AI does the heavy lifting. I do the steering.

Why This Works

Skills are workflow steps with hard stops built in. Every skill produces a file I review before anything becomes permanent — plans, questions, commit messages, PR descriptions. Nothing reaches the repo without passing through my eyes first. That's what makes it vibe guiding: the AI brings the force, the workflow lets me guide it.

Try It

The skills are open source and designed to be portable — they work in any project via symlinks:

git clone git@github.com:couimet/my-claude-skills.git ~/src/my-claude-skills
~/src/my-claude-skills/install.sh

For the full "show the work" follow-along: ouimet.info/follow-alongs/my-claude-skills-issues-10

Vide → Vibe Guiding

Vibe coding is fun until the vibes run out. When they do, you're left with duplicated code instead of refactored, missing dependency injection, and untestable first drafts.

But here's what I've found: once you give the AI proper guidance through structured skills, it continues with that quality. Guide it toward dependency injection once, and it keeps using the pattern. Set up testable architecture in the first step, and every subsequent step follows suit.

That's supercharged vibe guiding. You're not fighting the AI or replacing it. You're giving it rails to run on — and then it runs far.

Inspired by Boris Tane's workflow article, this post was built with the same skills it describes — starting from issue #20. Over or under 10 skill invocations to go from blank file to what you're reading? Leave your guess below.

About RangeLink

RangeLink is an extension I built to create precise code references for AI assistants. One keybinding. Any AI, any tool. Character-level precision. Available for VS Code and Cursor.

RangeLink v1.0.0: Perfected AI Workflows + The R-Keybinding Family

Charles Ouimet — Tue, 16 Dec 2025 01:52:33 +0000

Update (2026-06-12): RangeLink 2.0.0 has shipped. Read the v2.0.0 release post.

Hey folks! RangeLink v1.0.0 is here, and this feels like a real milestone.

If you've been following along since v0.3.0, you know RangeLink brings character-level precision to code references and seamless paste destinations for AI workflows — all with one keybinding that works regardless of which AI assistant you're using. v1.0.0 perfects that experience by eliminating a major v0.3.0 pain point and expanding your choices with new features.

This isn't just a version bump — it's a commitment that RangeLink is mature, reliable, and ready for your daily workflow.

What's New in v1.0.0

🎯 Perfected Paste Destinations (Major UX Improvement)

Claude Code Extension and Cursor AI now fully automatic — no more manual Cmd+V paste!
In v0.3.0, these destinations required you to manually paste after RangeLink copied the link. That workflow interruption is gone.
All AI chat destinations now provide identical seamless UX: select code → link appears → keep typing.
Remember "One Keybinding to Rule Them All"? In v1.0.0, it truly does.

🤖 GitHub Copilot Chat Integration (3rd AI Chat Option)

Paste destination for GitHub Copilot Chat
Expands your AI choices: Claude, Cursor AI, or Copilot — your preference, your workflow

⌨️ Complete R-Keybinding Family (New Commands)

R-C: Clipboard-only RangeLink generation (cross-project sharing with absolute paths, no destination unbind needed)
R-V: Paste selected text directly to destination (not just links!)
R-J: Jump to bound destination (no more tab hunting)

🔄 Smart Bind with Confirmation (QoL)

Quick switching between destinations without manual unbind
QuickPick dialog confirms before replacing

Feature Deep-Dives

The v0.3.0 → v1.0.0 Evolution: Fully Automatic AI Chats

The problem in v0.3.0:

Claude Code Extension and Cursor AI destinations worked like this:

Select code → Cmd+R Cmd+L
RangeLink copied link to clipboard and opened chat panel
You manually pasted with Cmd+V ← workflow interruption
Continue typing

It worked, but that manual paste step broke the flow. Terminal and Text Editor destinations were already fully automatic, so the inconsistency was frustrating.

The solution in v1.0.0:

All destinations now fully automatic:

Select code → Cmd+R Cmd+L
Link appears in chat automatically
Continue typing immediately

How I did it (the technical bit):

The lightbulb moment came from PR #136 when improving the Terminal destination. I realized executeCommand() could programmatically trigger actions in VSCode extensions. For Claude Code and Cursor AI (which don't expose text insertion APIs), RangeLink could:

Set focus to the chat panel (RangeLink was already doing this)
Copy link to clipboard
Add a small delay (50-150ms) to ensure focus is ready
Execute the paste command programmatically

It's a clipboard-based workaround, but from the user's perspective it's indistinguishable from true API-based insertion. The workflow is seamless, and that's what matters.

Result: Claude Code, Cursor AI, and Copilot Chat all provide identical automatic paste UX. Choose your AI based on preference, not workflow limitations. The v0.3.0 promise of "One Keybinding to Rule Them All" is now fully delivered.

The R-Keybinding Family: R-C, R-V, R-J

All RangeLink commands start with Cmd+R (for Range*L*ink), creating a memorable pattern. v1.0.0 completes the R-family with three new commands (R-C, R-V, R-J):

Keybinding	Not About...	Actually Does
R-L	Rocket League 🎮	Generate RangeLink at current selection
R-C	Radio Control 📻	Copy RangeLink to Clipboard only (skip destination)
R-V	Recreational Vehicle 🚐	Paste selected text directly to destination (like V for paste)
R-J	Roger Junior	Jump to your currently bound destination

R-C: RangeLink Clipboard-Only Mode

Sometimes you need a RangeLink but don't want it auto-pasting to your bound destination:

Sharing links across projects or IDE instances
Pasting into Slack, documentation, etc
Validating references before sending to AI

Cmd+R Cmd+C generates a formatted RangeLink (e.g., src/auth.ts#L42C10-L58C25) directly to clipboard, bypassing your bound destination entirely.

Key benefit: No need to unbind your destination first. Generate clipboard-only links on demand while keeping your paste destination active.

Supports both relative paths (same project) and absolute paths (cross-project sharing). Use Cmd+R Cmd+Shift+C for absolute paths when sharing links across different projects or IDE instances.

R-V: Paste Text, Not Just Links 🚐

You've bound RangeLink to your terminal or AI chat, and now you want to send actual code — not a link, but the selected text itself.

Cmd+R Cmd+V sends your selected text directly to your bound destination. Same seamless workflow: select code → R-V → text appears → destination auto-focuses → keep typing.

Why the RV emoji? Well, R-V is literally a Recreational Vehicle. I couldn't resist. 🚐

Pro tip: Works with all destinations (Claude Code Extension, Cursor AI, GitHub Copilot Chat, Terminal, Text Editor) and handles multi-selection by concatenating with newlines. Perfect for quickly sharing code snippets with AI assistants — even if your current AI tool doesn't offer this feature natively.

R-J: Jump to Destination

You've bound a terminal or text editor as your paste destination, but it's buried under other tabs or panes. Instead of hunting for it, hit Cmd+R Cmd+J to instantly jump to (and focus) your bound destination.

Not about Roger Junior. Just a quick jump to where your links are going. 🎯

GitHub Copilot Chat: Your 3rd AI Chat Option

v1.0.0 adds GitHub Copilot Chat support as a paste destination, giving you three AI chat options:

Claude Code Extension — Anthropic's official extension (works in VSCode and Cursor)
Cursor AI — Built into Cursor IDE
GitHub Copilot Chat — GitHub's AI coding assistant

All three provide identical automatic paste UX. Choose based on your AI preference, not workflow constraints.

Bind via Command Palette → "Bind RangeLink to GitHub Copilot Chat Destination"

Smart Bind with Confirmation

Switching between destinations is now frictionless. Run any "Bind to..." command when already bound, and RangeLink shows a QuickPick dialog confirming the switch:

Currently bound to: Terminal
Switch to: Claude Code Chat?
[Yes] [No]

No need to unbind first—just quick switching with confirmation as your workflow demands.

Why RangeLink Matters

Built-in AI features are convenient, but they lock you into one AI model, one workflow, and usually only line-level precision. RangeLink gives you:

Character-level precision — Highlight exactly the function signature, the problematic condition, that one sneaky semicolon. Not the whole block. Most AI code-sharing tools only work at line-level.
Any AI assistant — Claude, GPT, Gemini, Copilot, whatever you prefer. No vendor lock-in.
One keybinding memory — Switch between Claude, Copilot, Cursor, or terminal assistants without relearning shortcuts. Cmd+R Cmd+L works the same everywhere. Your muscle memory stays constant even as your AI toolkit evolves.
Features your AI doesn't have — Cmd+R Cmd+V sends selected text directly to any AI chat. Even if your current tool doesn't offer this natively, RangeLink does.
Flexible workflows — Terminal for quick questions, scratchpad for complex prompts, direct AI chat integrations. All with the same seamless UX.
Universal format — GitHub-style links that work everywhere (PRs, Slack, docs, teammates without RangeLink). RangeLinks aren't proprietary.

And with v1.0.0, the workflow is just as seamless as integrated tools — arguably better, because you're not limited to one AI vendor or workflow pattern.

Try It Out

Install RangeLink:

VS Code: VS Code Marketplace
Cursor: Open VSX Registry

Quick start:

Command Palette → "Bind RangeLink to [your preferred destination]"
Select code → Try the R-keybindings:
- Cmd+R Cmd+L — Generate RangeLink (auto-pastes to destination)
- Cmd+R Cmd+C — Clipboard-only copy (no destination paste)
- Cmd+R Cmd+V — Paste selected text directly
- Cmd+R Cmd+J — Jump to bound destination
Cmd+Click any RangeLink in terminal or editor to navigate

The text editor destination with a split-screen scratchpad is still my favorite for complex AI prompts — lets you iterate on context before sending. Give it a try!

How Are You Using RangeLink?

RangeLink v1.0.0 is feature-complete and stable. The core vision is realized: character-level precision, seamless AI workflows, flexible paste destinations.

I'd love to hear about your usage patterns:

Which destinations do you use most? (Terminal? Scratchpad? AI chat?)
How are the R-keybindings fitting into your workflow?
Any rough edges or unexpected behaviors?

Your feedback shapes priorities. If you're interested in contributing—code, docs, ideas—check out GitHub Issues or open a discussion. The codebase is TypeScript with comprehensive test coverage, and PRs are always welcome.

Built something cool with RangeLink? Share it! Always fun to see how people are using the tool.

Get Involved

If RangeLink is useful for you:

⭐ Star the repo on GitHub
🐛 Report issues or share ideas via GitHub Issues
🤝 Contribute — TypeScript codebase with comprehensive test coverage, PRs welcome
💬 Share your workflows — Drop a comment below or open a discussion

Links:

RangeLink v0.3.0: One Keybinding to Rule Them All

Charles Ouimet — Wed, 12 Nov 2025 04:00:54 +0000

Update (2026-06-12): RangeLink 2.0.0 has shipped. Read the v2.0.0 release post.

Hey folks! Just shipped RangeLink v0.3.0, and I'm genuinely excited about this one.

If you caught my previous post about v0.2.1, you know RangeLink started as a way to share precise code references with AI assistants in the terminal. That's still there, but v0.3.0 takes it further: one keybinding (Cmd+R Cmd+L) now sends your code references anywhere you need them.

The Evolution

v0.2.0 launched with terminal binding — auto-send links to your integrated terminal where AI assistants can see them — plus clickable navigation to jump back to code.

v0.3.0 introduces Paste Destinations — a unified system that lets you bind RangeLink to wherever you're working: Claude Code Extension, Cursor AI, your terminal, or even a scratchpad file for drafting complex AI prompts.

Same keybinding. Different destinations. Your choice.

Why This Matters

Here's the thing about built-in AI features in editors: they're convenient, but they lock you into one AI model, one workflow, and usually only line-level precision. RangeLink gives you:

Character-level precision — Not just line 42, but #L42C10-L58C25 (that exact function signature, that specific condition)
Any AI assistant — Claude, GPT, Gemini, whatever you prefer. No vendor lock-in.
Flexible workflows — Terminal for quick questions, scratchpad for complex prompts, direct AI chat integrations
Universal format — GitHub-style links that work everywhere (PRs, Slack, docs, teammates without RangeLink)

The best part? You don't give up any convenience. Select code, hit Cmd+R Cmd+L, and your link appears exactly where you need it — with the same character-level precision that makes RangeLink special.

What's New in v0.3.0

Paste Destinations (The Big One)

Bind RangeLink to one destination at a time:

Claude Code Extension — Links open Claude's chat panel (works in VSCode and Cursor)*
Cursor AI — Links open Cursor's AI chat*
Terminal — Auto-paste links for terminal-based AI assistants
Text Editor — Draft complex prompts in any file (markdown, untitled, whatever)

All destinations share the same seamless UX: select code → Cmd+R Cmd+L → link appears at your cursor position → destination auto-focuses → keep typing.

(*) FULL DISCLAIMER: Claude Code Extension and Cursor AI destinations use a clipboard-based workaround because their APIs don't support programmatic text insertion yet (as of Nov 2025). RangeLink copies the link and opens the chat panel, but you need to paste (Cmd+V / Ctrl+V) yourself. Terminal and Text Editor destinations fully auto-paste without manual intervention.

Editor Link Navigation

Any RangeLink in any editor file (markdown, code, untitled) is now clickable. Hover to preview, Cmd+Click to navigate.

Use case: You're drafting a prompt in a scratchpad file with multiple code references. Before sending to your AI assistant, you can validate each link by clicking it — makes sure you're sharing the right context.

The "One Keybinding" Philosophy

Every AI tool has its own way to share code — different shortcuts, different formats, different workflows.

RangeLink unifies it: Cmd+R Cmd+L works everywhere, with character-level precision everywhere, and connects to any AI assistant.

One keybinding to rule them all.

Why I'm Excited

This release makes RangeLink competitive with integrated AI features without sacrificing its core strengths:

You're not locked into one AI model
You get more precision (characters, not just lines)
Links work universally (paste them anywhere, share with anyone)
The workflow is just as seamless as built-in tools

And honestly? The paste destinations architecture feels like the right foundation for whatever comes next.

Behind the Scenes: Working with AI on RangeLink

One thing I've been experimenting with: using AI assistants to help build RangeLink itself. I've progressively added instructions to CLAUDE.md to guide how Claude Code helps me develop.

A pattern I really like is the questions template. When Claude needs design decisions before implementing a feature, instead of asking questions in the terminal (which gets messy), it:

Saves questions to a .txt file in .claude-questions/
Pre-fills recommended answers when it has context
I edit the file with my decisions
Claude reads my answers and proceeds

This keeps the workflow clean and creates a record of design decisions. The questions file becomes documentation.

If you're working with AI on your projects, this pattern might be worth trying!

Try It Out

Install RangeLink:

VS Code: VS Code Marketplace
Cursor: Open VSX Registry

Quick start:

Command Palette → "Bind RangeLink to [your preferred destination]"
Select code → Cmd+R Cmd+L (or Command Palette → "Copy Range Link" if you have keybinding conflicts)
Your link is ready where you need it

Try the text editor destination with a split-screen scratchpad — it's a game-changer for complex AI prompts.

Would love to hear your feedback, especially if you're bouncing between different AI assistants!

Get Involved

If you find RangeLink useful, I'd love your support:

⭐ Star the repo on GitHub — it helps others discover it
🐛 Report bugs or request features via GitHub Issues — I've started adding ideas there, not yet organized into a roadmap but wanted to share visibility on what's on my mind
🤝 Contribute — the codebase is well-documented and PR-friendly
🗣️ Share your feedback — I'm actively iterating based on what the community needs

For vim/neovim users interested in building a plugin: the core library is platform-agnostic and designed for multi-editor support. Would love to collaborate!

Links:

GitHub Repository

I Built a VS Code Extension to Stop the Copy-Paste Madness

Charles Ouimet — Sat, 08 Nov 2025 22:46:36 +0000

Update (2026-06-12): RangeLink 2.0.0 has shipped. Read the v2.0.0 release post.

Hey devs! I just shipped v0.2.1 of RangeLink, a VS Code/Cursor extension that fixes something that's been driving me (and probably you) crazy.

The Problem

I use Claude Code running in a terminal inside Cursor daily. And the constant copy-pasting between terminal and editor? Exhausting.

One day, after the hundredth copy-paste, I got frustrated and just tried something: I sent Claude a link like src/path/file.rb#L42C10-L58C25 pointing to a specific code snippet.

It just worked. No explanation needed. Claude understood immediately.

That was the lightbulb moment: precise code references should be universal. Not just for AI assistants, but for code reviews, documentation, team collaboration — anywhere developers share code.

What RangeLink Does

Create precise code references in one keystroke.

Select some code in VS Code/Cursor
Press Cmd+R Cmd+L (Mac) or Ctrl+R Ctrl+L (Windows/Linux)
Done! Link is in your clipboard: src/path/file.rb#L42C10-L58C25

The notation is GitHub-inspired, so your teammates already know it. They don't even need RangeLink installed to understand your links.

The Killer Feature (v0.2.1)

Auto-paste to terminal — this is where it gets good for Claude Code users (or any terminal-based workflow).

One-time setup: bind your Claude Code terminal to RangeLink (Command Palette → "Bind Terminal"). Now every RangeLink you generate automatically appears in that terminal. No copy-paste needed. Zero. None.

Select code → hit the keybinding → the link is instantly in your terminal prompt, ready to send to Claude (or any AI assistant).

The copy-paste workflow? Gone. You stay in flow. Even if you switch between multiple terminals, links always go to your bound terminal.

Bonus: You can also Cmd+Click (Mac) or Ctrl+Click (Windows/Linux) any RangeLink in your terminal to jump straight back to that code. No more "wait, which file was that?" moments.

Why You'll Love It

No more "around line 42" — Share exact ranges with column precision
Works everywhere — Claude Code, VS Code, Cursor, GitHub, Slack, PRs
One keystroke — Cmd+R Cmd+L → link copied, done
Flexible paths — Workspace-relative or absolute paths, your choice

Perfect for:

Code reviews ("The bug is in api/routes.ts#L215C8-L223C45")
AI assistants (multi-file context in one prompt)
Team collaboration (universal format everyone can use)

About the Logo

Ever notice the chicken in the logo? That's a free-range chicken. Because your code should roam free across editors, tools, and teams.

The chains represent links — connections between developers, tools, and ideas.

Look at the numbers in the range, precision matters.

Try It Out

Install RangeLink:

VS Code: VS Code Marketplace
Cursor: Open VSX Registry

Select some code, hit Cmd+R Cmd+L (or Command Palette → "Copy Range Link" if you have keybinding conflicts), and paste the link into Claude Code or Slack. See how it feels to never say "around line X" again.

Get Involved

If you find RangeLink useful, I'd love your support:

⭐ Star the repo on GitHub — it helps others discover it
🐛 Report bugs or request features via GitHub Issues
🤝 Contribute — the codebase is well-documented and PR-friendly
🗣️ Share your feedback — I'm actively iterating based on what the community needs

For vim/neovim users interested in building a plugin: the core library is platform-agnostic and designed for multi-editor support. Would love to collaborate!

Curious about the implementation? Browse the source code on GitHub or reach out — I'm happy to chat about the architecture and design decisions.

Links:

DEV Community: Charles Ouimet

RangeLink 2.0.0: Bind first. Every R-* follows

What's New in v2.0.0

Every R-* now routes through your destination

We stopped messing with your clipboard

One picker, one menu: R-D and R-M

Bring Your Own AI

Gemini Code Assist, built in

Right-click works everywhere now

You'll know when there's a new version

The R-Keybinding Family in v2.0.0

Upgrading from v1.0.0

Try it out

So why did it take six months?

Happy (Range) Linking!

Correlation ID vs Request ID: A Practical Guide

The kitchen

The ticket and the shout

Mise en place

Tickets from the front of house (your public API)

Your own crew (your internal API)

Shouts across the stations (your internal outbound calls)

Orders to the suppliers (your external outbound calls)

Takeout orders (async messaging)

One trace, one picture

When this stops being enough

Same name, different recipe

Start with the paring knife

References

Fix: "There's an issue with the selected model (deepseek-v4-pro)" in Claude CLI

I thought Anthropic was on to me

What was actually happening

A related edge case: resuming a DeepSeek session in an Anthropic context

Why I'm really writing this

I sold you on /scratchpad. Then I migrated to /note.

Why I changed my mind

Claude was changing too

What /note looks like

What I am taking away

If you already use these skills

Eight env vars and Claude Code stops eating my paycheck

The eight env vars

What's going on in there

Why I'm still using this a week later

The catch I hit

Same trick, different provider

A note on privacy

I thought I was DRY-ing. I may have been double-paying.

Something was off

So I let another Claude run the audit

My hypothesis was backwards

What the audit found

The pivot

What this might save in tokens

What I'm taking away

If you want to try this

From Vide Coding to Supercharged Vibe Guiding

It's Not a Typo

The Missing Piece: Guidance

What This Looks Like in Practice

Why This Works

Try It

Vide → Vibe Guiding

About RangeLink

RangeLink v1.0.0: Perfected AI Workflows + The R-Keybinding Family

What's New in v1.0.0

Feature Deep-Dives

The v0.3.0 → v1.0.0 Evolution: Fully Automatic AI Chats

The R-Keybinding Family: R-C, R-V, R-J

R-C: RangeLink Clipboard-Only Mode

R-V: Paste Text, Not Just Links 🚐

R-J: Jump to Destination

GitHub Copilot Chat: Your 3rd AI Chat Option

Smart Bind with Confirmation

Why RangeLink Matters

Try It Out

How Are You Using RangeLink?

Get Involved

RangeLink v0.3.0: One Keybinding to Rule Them All

The Evolution

What `/note` looks like