DEV Community: Charles Ouimet

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

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

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

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

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

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

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: