Copy File Path for AI Coding: How to Share Screenshots with Claude Code

The Friction Everyone Is Hacking Around

If you want to copy file path for AI coding in a way Claude Code actually understands, the fastest path is a single hotkey that copies the file path along with the app name, window title, URL, and annotation summary — as plain text. A bare file path alone forces the AI to guess which file, URL, or UI element the screenshot came from. Stash binds this context-aware copy to ⌘⌃P and ships the full metadata string to the clipboard.

You know the moment. You're deep in a Claude Code session. It's been productive — refactoring components, fixing edge cases, iterating on your UI. Then you hit something visual. A button renders 4 pixels too low. A modal overlaps the nav bar. A gradient looks wrong on the checkout page.

You can see the problem. It's right there on your screen. Claude Code cannot. So you do what you always do: start typing a description of the thing you're literally staring at.

The Claude Code GitHub issues are full of this frustration. Issue #2204, filed in mid-2025, puts it bluntly: "A screenshot (Cmd Shift 4) should be able to be pasted directly into Claude Code. Today, I need to save this to desktop and then drag the image in.... Very awkward." Issue #12644 asks for the same thing months later. The thread is full of people nodding along.

Claude Code is multimodal. It can read images. It can analyze screenshots, identify UI bugs, interpret layouts. But it lives in the terminal, and the terminal doesn't speak pixels — it speaks file paths. It speaks text. There's a gap: your eyes see the bug, the AI can understand the bug, and there's no clean way to get from one to the other.

How Vibe Coders Are Doing It Now

The community has built an impressive collection of duct tape to bridge this gap. If you're reading this, you're probably using one of them.

The Ctrl+V method

• What it is: Take a screenshot with ⌘⌃⇧4 (copies to clipboard), switch to Claude Code, press Ctrl+V — not Cmd+V, because Claude Code's terminal input handling uses a different keybinding.
• What works: It's native, two steps, and the closest thing to frictionless that exists.
• What it misses: Claude gets raw pixels. No app name, no file name, no URL, no annotation summary. You still end up typing "this is the checkout page in Safari, the button in the lower right is the problem."

Drag-and-drop from Finder

• What it is: Take a screenshot with ⌘⇧4 (saves to Desktop), find it in Finder, drag it into the terminal. Some emulators need Shift-held dragging to reference the file instead of opening it in a tab.
• What works: It works.
• What it misses: The context switch — terminal → Finder → locate → drag → terminal — breaks your flow every time.

The fswatch + pbcopy shell script

• What it is: Hwee-Boon Yar published a fish shell function that runs fswatch against ~/Desktop, pattern-matches on macOS screenshot filenames, and pipes the path to pbcopy. Keep it running and the path of every new screenshot lands on your clipboard.
• What works: Clever, simple, effective for the author's stated reason: "It's tedious" and "Step 3 has gotten worse with macOS Tahoe where the desktop seems to take longer to refresh."
• What it misses: You get a bare path — /Users/you/Desktop/Screenshot 2026-02-09 at 14.30.00.png — with no metadata. And you need a dedicated terminal window running a background process.

The Hammerspoon Lua automation

• What it is: Quobix wired a Hammerspoon script that binds Cmd+Shift+6, runs screencapture -c -s -x, waits 100ms, then programmatically pastes into Ghostty. His motivation: "I take a lot of screenshots to show Claude just how far off the rails it has run. It is slow and annoying to drag and drop images into my terminals."
• What works: No file on Desktop. No Finder step.
• What it misses: Hardcoded to Ghostty. Requires Accessibility permissions for Hammerspoon. Gives Claude the same context-free pixels as Ctrl+V.

Remote server uploaders

• What it is: If you run Claude Code on a remote server, clipboard paste doesn't work. claude-screenshot-uploader monitors a local folder with fswatch, uploads via rsync over SSH, and copies the remote path to your clipboard. Runs as a launchd service.
• What works: Solves the remote case.
• What it misses: SSH keys, config file, reattach-to-user-namespace install, and you still get a bare remote path with no context.

Custom Linux utilities

• What it is: A developer named Cuong built gshot-copy, a dedicated screenshot utility for Linux, because drag-and-drop to Claude Code was "still too cumbersome." Claude wrote most of the code for it.
• What works: Solves the Linux case.
• What it misses: People are now using Claude Code to build tools to make it easier to share screenshots with Claude Code. That's the state of things.

Just describing the bug in words

The silent majority. People who hit the friction and just type it out. The AI is multimodal, capable of understanding exactly what's on screen, and you're describing it in English because the plumbing isn't there.

What These Workarounds All Miss

Every one of these solutions — from the simplest Ctrl+V to the most elaborate launchd service — shares the same limitation: they transfer pixels without context.

A file path tells Claude Code where to find an image. It does not tell it:

• What app the screenshot came from. Was this Xcode? Safari? Figma? The AI has to guess from pixels alone.
• What file or page was open. A screenshot of a code editor looks identical whether it's AppDelegate.swift or ViewController.swift — unless the window title bar is visible, and even then, Claude has to OCR it from the image.
• What URL was loaded. A rendered webpage is just pixels. Without the URL, the AI can't cross-reference against your codebase, look up the route, or identify which component renders that view.
• What you were pointing at. If you annotated the screenshot — drew an arrow, circled something — the AI sees the annotation visually, but doesn't know to prioritize the annotated areas unless you say so.

The window title is the most valuable piece of context, and it's the one thing a multimodal AI cannot reliably extract from the image alone. Two screenshots of VS Code look the same if the tab bar is cropped. The window title resolves the ambiguity instantly.

Even the best existing workaround — take screenshot, auto-copy path, paste — still leaves you typing context: "this is the checkout page," "this is AppDelegate.swift," "look at the thing I circled in the upper right."

What a Context-Aware Copy Path Produces

Here's the raw output. You press ⌘⌃P. This is what lands on NSPasteboard:

Screenshot from Safari | Window: "Pull Request #42 - GitHub"
| https://github.com/org/repo/pull/42 | 2026-02-09 at 14:30
Annotations: 2 arrows, 1 rectangle
/Users/chris/Desktop/Screenshot 2026-02-09 at 14.30.00.png

App name. Window title. URL. Timestamp. Annotation summary. Absolute file path. Plain text. It pastes into iTerm, Ghostty, Kitty, the VS Code terminal, vim, whatever you're running Claude Code in.

The full workflow looks like this:

⌘⌃S  →  select region  →  draw arrow  →  ⌘⌃P  →  paste

No Finder. No drag. No typing "this is the checkout page in Safari, the button in the lower right."

The ⌘⌃S part is Stash's built-in screenshot capture — it lives in the menu bar and does region select, annotation (arrows, rectangles, ellipses), and auto-save. If you already use a screenshot tool you like, Stash watches your macOS screenshot folder and picks up anything you capture natively. Either way, ⌘⌃P operates on the most recent image in your history.

Why This Changes the AI's First Response

This isn't theoretical. Here's the difference in practice. You screenshot a SwiftUI view with a layout bug. You draw an arrow at the misaligned element.

Without context — bare file path:

> Look at /Users/chris/Desktop/Screenshot 2026-02-09 at 14.30.00.png
> The element I arrowed is misaligned. Fix it.

Claude Code opens the image. It sees code in an editor with an arrow drawn on it. It doesn't know which file. It asks:

I can see the arrow pointing at a VStack with incorrect spacing.
Which file is this? I'll need to open it to make the fix.

You check the tab bar. You type the filename. Claude opens it, finds the view, generates a fix. Three turns minimum.

With context — ⌘⌃P output:

> Screenshot from Xcode | Window: "ContentView.swift"
> | Annotations: 1 arrow
> /Users/chris/Desktop/Screenshot 2026-02-09 at 14.30.00.png
>
> Fix the element I arrowed.

Claude Code reads the metadata, opens ContentView.swift directly, correlates the arrow with the layout code, and responds:

I can see the arrow pointing at the VStack spacing in ContentView.swift.
The issue is on line 47 — the padding modifier is applied before the
frame modifier, causing the offset. Here's the fix:

One turn. The window title did the work that three rounds of back-and-forth used to do.

GIF Captures for Animation Bugs

Static screenshots can't capture animation bugs. Transitions that fire in the wrong order. Race conditions that cause UI flicker. Scroll jank. Hover states that don't trigger. You can't draw an arrow at "the thing that happens between frame 12 and frame 15."

⌘⌃G starts a GIF capture. Do the thing that's broken. Press ⌘⌃G again to stop. Stash records the screen, tracks your clicks, keystrokes, and scroll events, and extracts full-resolution key frames at each moment of interaction.

Press ⌘⌃P and Stash exports this to your Desktop:

GIF Capture 2026-02-09 at 14.30.00/
├── frame_01.png       # click on "Submit" button
├── frame_02.png       # modal appears with wrong z-index
├── frame_03.png       # scroll reveals clipped content
└── capture_report.md

Here's what capture_report.md contains:

# GIF Capture Report

**App:** Safari
**Window:** localhost:3000/checkout
**URL:** http://localhost:3000/checkout
**Duration:** 5.2s
**Recorded:** 2026-02-09 at 14:30:22

## Interaction Timeline

| Time  | Action         | Target / Detail                    |
|-------|----------------|------------------------------------|
| 0.0s  | recording_start| —                                  |
| 1.1s  | click          | (482, 310) — "Submit" button area  |
| 2.3s  | click          | (150, 200) — modal backdrop        |
| 3.8s  | scroll         | down, 3 ticks                      |
| 5.2s  | recording_stop | —                                  |

## Key Frames

| Frame       | Timestamp | Trigger | Path                                                                 |
|-------------|-----------|---------|----------------------------------------------------------------------|
| frame_01    | 1.1s      | click   | /Users/chris/Desktop/GIF Capture 2026-02-09 at 14.30.00/frame_01.png |
| frame_02    | 2.3s      | click   | /Users/chris/Desktop/GIF Capture 2026-02-09 at 14.30.00/frame_02.png |
| frame_03    | 3.8s      | scroll  | /Users/chris/Desktop/GIF Capture 2026-02-09 at 14.30.00/frame_03.png |

What lands on your clipboard:

GIF capture from Safari | Window: localhost:3000/checkout
| http://localhost:3000/checkout | 5.2s, 3 key frames, 2 clicks
| 2026-02-09 at 14:30
/Users/chris/Desktop/GIF Capture 2026-02-09 at 14.30.00/capture_report.md

Paste that into Claude Code. It reads the report, gets the full timeline, opens whichever frames it needs. One paste gives the AI a structured debugging session — timestamps, interaction sequence, frame-by-frame visuals, and the URL so it can cross-reference your codebase.

None of the shell scripts, Hammerspoon configs, or drag-and-drop workflows handle GIF recordings. None of them extract key frames. None of them generate reports a terminal AI can parse.

Comparison of Screenshot-to-Terminal Workflows

A second example to make the payoff concrete. The "Place Order" button is enabled when the email field is empty. It shouldn't be.

Press ⌘⌃S, select the region around the form, draw one arrow at the empty email field and another at the enabled button. Press ⌘⌃P. Switch to Claude Code. Paste:

> Screenshot from Chrome | Window: "Checkout - localhost:3000"
> | http://localhost:3000/checkout | 2026-02-09 at 14:45
> Annotations: 2 arrows
> /Users/chris/Desktop/Screenshot 2026-02-09 at 14.45.00.png
>
> The button I arrowed should be disabled when the email
> field I arrowed is empty.

Claude Code sees the image, reads the arrows, knows the URL maps to your /checkout route, and opens the right component. First response is the fix. No "which file is this?" No "can you share the URL?"

Technical Details

• Scope: ⌘⌃P operates on the most recent image or GIF capture in Stash's history.
• Requirement: Auto-save must be enabled in Preferences. The feature needs a file on disk to provide a path to.
• Failure mode: If auto-save is off or the most recent item is text, Stash plays a system beep — no disruptive error dialog.
• Path capture: The file path is captured at save time, not computed later.
• Metadata capture: App name, window title, and URL are captured at screenshot time via macOS accessibility APIs.
• Annotations: Tracked in Stash's local database and summarized in the context string (e.g., "2 arrows, 1 rectangle").
• GIF exports: The folder with key frames and capture_report.md is generated on-demand when ⌘⌃P is pressed, not on every recording.
• Clipboard format: Plain text on NSPasteboard. No binary data. No special format. Pastes into any terminal, text field, or editor.