Streamlining Remote Development: Using tfLink with Claude Code in SSH Sessions

The Remote Developer's Dilemma

Modern development often happens on remote servers accessed via SSH. Whether you're working on cloud instances, managing production environments, or developing inside Screen or tmux sessions, you've likely encountered this frustrating scenario:

Why This Matters

Claude Code excels at understanding visual context. It can:

• Analyze UI screenshots and generate matching code
• Debug errors by examining stack trace screenshots
• Implement designs from mockups and wireframes
• Reference documentation from PDF or image files
• Replicate layouts from existing interfaces

But in an SSH session, you're limited to text-only input. This creates a significant productivity gap.

"I was constantly switching between my local machine and SSH sessions, trying to describe screenshots in text. It was frustrating and slow. I needed a better way to share visual context with Claude Code without breaking my concentration." — Remote Developer Experience

Traditional Solutions and Their Limitations

Option 1: SCP/SFTP Upload

The traditional approach involves uploading files to the remote server:

# Upload screenshot to remote server
scp ~/Desktop/screenshot.png user@remote:/tmp/

# Then reference it in Claude Code
# But Claude Code needs to read the local file path...

Problems:

• Requires remembering server paths and credentials
• Files accumulate on the server, requiring manual cleanup
• Claude Code still needs to access the file via local path
• Breaks your development flow with context switching

Option 2: Git Commit + Push

Some developers resort to committing images to their repository:

# On local machine
git add screenshot.png
git commit -m "temp: add screenshot"
git push

# On remote server
git pull
# Now you can reference it...

Problems:

• Pollutes git history with temporary files
• Multi-step process (add, commit, push, pull)
• Requires internet access on both machines
• Not suitable for sensitive or temporary content

Option 3: Cloud Storage Services

Using Dropbox, Google Drive, or similar services:

Problems:

• Requires account creation and authentication
• Multiple steps: upload, generate link, copy link
• Permanent storage of temporary files
• May require installing additional tools on the server

The tfLink + Claude Code Workflow

tfLink provides an elegant solution that eliminates all these friction points. Here's the complete workflow:

Why This Works So Well

• No server setup required: Works with any SSH session immediately
• HTTPS URLs: Claude Code can fetch directly via WebFetch tool
• No authentication: Public links work instantly
• Automatic cleanup: Files expire after 7 days
• Zero context switching: Stay in your development flow
• Universal compatibility: Works with any file type

Practical Example

You: I need to implement this UI design
You: https://d.tmpfile.link/public/2025-10-26/abc123/design-mockup.png

Claude Code: [Downloads and analyzes the image]
Claude Code: I can see a dashboard layout with a sidebar navigation,
             top header bar, and a card-based main content area.
             Let me create the HTML and CSS structure for this...

# Claude Code proceeds to generate code matching the design

Real-World Use Cases

1. UI Implementation from Design Mockups

Scenario: Your designer sends you a Figma screenshot or UI mockup that needs to be implemented.

Traditional approach: Describe the design in text, go back and forth with clarifications.

With tfLink:

1. Save the mockup screenshot from Slack/Email
2. Paste into tmpfile.link
3. Share URL with Claude Code
4. Get pixel-perfect implementation code

2. Bug Fixing from Error Screenshots

Scenario: QA team reports a bug with a screenshot showing the error state.

3. API Documentation Reference

Scenario: You need to integrate with an API and have documentation as a PDF or screenshot.

With tfLink: Upload the API documentation page, share the URL, and ask Claude Code to generate the integration code based on the exact specifications shown.

4. Configuration File Templates

Scenario: You need to create a complex configuration file based on a template.

Upload the template (JSON, YAML, or even a screenshot of configuration), share the URL, and Claude Code can generate the customized version for your specific needs.

5. Mobile-First Development

Scenario: Testing on a mobile device and need to share screenshots with Claude Code.

Use tfLink's QR code feature:

• Take screenshot on your phone
• Open tmpfile.link on your phone
• Upload the screenshot
• Scan the QR code with your phone's camera
• The URL automatically opens in your browser
• Copy and paste into your SSH session

Quick Setup Guide

Getting Started (No Installation Required)

The beauty of tfLink is that there's nothing to install or configure. However, you can optimize your workflow with a few simple shortcuts.

Optional: Command-Line Upload Script

For power users who want to upload from the terminal on their local machine:

# Add to your ~/.bashrc or ~/.zshrc on your LOCAL machine
alias tfup='upload_to_tflink'

upload_to_tflink() {
    if [ -z "$1" ]; then
        echo "Usage: tfup "
        return 1
    fi

    echo "Uploading $1 to tfLink..."
    RESPONSE=$(curl -s -X POST -F "file=@$1" https://tmpfile.link/api/upload)
    DOWNLOAD_LINK=$(echo $RESPONSE | jq -r '.downloadLink')

    echo "✓ Upload complete!"
    echo "Download link: $DOWNLOAD_LINK"

    # Copy to clipboard (macOS)
    if command -v pbcopy >/dev/null 2>&1; then
        echo $DOWNLOAD_LINK | pbcopy
        echo "✓ Link copied to clipboard"
    # Copy to clipboard (Linux)
    elif command -v xclip >/dev/null 2>&1; then
        echo $DOWNLOAD_LINK | xclip -selection clipboard
        echo "✓ Link copied to clipboard"
    fi
}

# Usage example:
# tfup ~/Desktop/screenshot.png
# Link is automatically copied - just paste into SSH session!

First Time Usage

1. Bookmark tmpfile.link in your browser for quick access
2. Test the workflow: Upload a sample image and paste the URL to Claude Code
3. Set up the CLI alias (optional) for even faster uploads

Automation and Productivity Tips

Screenshot + Upload Workflow

On macOS, you can create a one-step screenshot → upload flow:

#!/bin/bash
# Save as ~/bin/screenshot-to-tflink.sh
# Make executable: chmod +x ~/bin/screenshot-to-tflink.sh

# Take screenshot and save to temp file
screencapture -i /tmp/screenshot.png

# Upload to tfLink
RESPONSE=$(curl -s -X POST -F "file=@/tmp/screenshot.png" \
    https://tmpfile.link/api/upload)
DOWNLOAD_LINK=$(echo $RESPONSE | jq -r '.downloadLink')

# Copy link to clipboard
echo $DOWNLOAD_LINK | pbcopy

# Show notification
osascript -e "display notification \"$DOWNLOAD_LINK\" \
    with title \"Screenshot uploaded to tfLink\" \
    sound name \"Glass\""

# Clean up
rm /tmp/screenshot.png

# Assign a keyboard shortcut using Automator or Alfred

Integration with Development Tools

VS Code Remote SSH

Even when using VS Code's Remote SSH extension, you can't paste images directly into the terminal. tfLink bridges this gap seamlessly.

tmux/Screen Sessions

When working in persistent terminal sessions, tfLink URLs remain accessible even after reconnecting, making it perfect for long-running development sessions.

Mobile Development Workflow

Testing on physical devices? Use tfLink's QR code feature to quickly share device screenshots with your SSH development environment.

Benefits and Time Savings

Quantified Productivity Gains

Key Advantages

1. Eliminates Workflow Interruptions

Stay in the zone. No need to switch between local machine, SSH session, git repositories, or cloud storage interfaces.

2. Works Everywhere

• Any SSH session (AWS, GCP, Azure, on-premises servers)
• Screen and tmux sessions
• Docker containers and Kubernetes pods
• WSL (Windows Subsystem for Linux)
• Bastion hosts and jump servers

3. No Infrastructure Required

Unlike self-hosted solutions or file servers, tfLink requires zero setup, configuration, or maintenance.

4. Security Through Expiration

Automatic 7-day file expiration means sensitive screenshots don't accumulate in permanent storage.

5. Supports Any File Type

While this guide focuses on images, tfLink works with any file up to 100MB:

• Log files for debugging
• Configuration templates
• Documentation PDFs
• Data samples for processing
• Small binary files

Best Practices and Recommendations

File Naming Conventions

Use descriptive filenames that provide context even when shared as URLs:

Good examples:
- dashboard-mockup-2025-10-26.png
- login-error-screenshot.png
- api-response-example.json
- nginx-config-template.conf

Less helpful:
- screenshot.png
- image1.png
- file.txt

When to Use tfLink

Perfect for:

• Temporary visual references (screenshots, mockups)
• One-time file transfers during development
• Sharing context with AI coding assistants
• Quick file exchanges during debugging sessions
• Mobile-to-desktop file transfers

Not recommended for:

• Long-term storage (files expire after 7 days)
• Highly sensitive data requiring encryption at rest
• Files larger than 100MB
• Production deployment artifacts

Security Considerations

• Link sharing: Only share URLs with authorized team members
• Sensitive data: Avoid uploading credentials or API keys
• Automatic expiration: Remember files are automatically deleted after 7 days
• Public links: Anyone with the URL can access the file

Tips for Maximum Efficiency

1. Bookmark tmpfile.link for instant access
2. Set up the CLI alias on your local machine for terminal uploads
3. Use QR codes for mobile-to-desktop transfers
4. Keep URLs in your terminal scrollback for reference during the session
5. Combine with Claude Code's context - paste the URL and provide additional instructions in the same message

Advanced Usage: Batch Operations

Upload multiple files and share all URLs with Claude Code in one message:

# On your local machine
tfup design1.png
tfup design2.png
tfup design3.png

# In your SSH session with Claude Code:
You: I need to implement these three designs:
1. https://d.tmpfile.link/.../design1.png
2. https://d.tmpfile.link/.../design2.png
3. https://d.tmpfile.link/.../design3.png

Please analyze all three and create a cohesive implementation.

Related Articles

• How IT Service Provider Boosted Efficiency 300% with Temporary File Sharing - Learn how IT professionals optimize server maintenance workflows
• API Integration Guide: Automating File Uploads - Automate your file sharing workflow with tfLink's API