[FEATURE] Send completion report from Claude Code to Claude Desktop with optional comment

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

The Problem

Many Claude Code users (especially non-engineers like web producers, designers,
and project managers) use Claude Desktop and Claude Code together as a workflow:

• Claude Desktop: Strategic discussions, design decisions, instruction drafting
• Claude Code: Actual implementation, file edits, builds, commits

The typical workflow is:

1. Discuss with Claude Desktop → generate detailed instruction document
2. Copy-paste instructions into Claude Code
3. Claude Code executes the task and produces a completion report
4. Copy-paste the completion report back into Claude Desktop for review
5. Claude Desktop reviews the report, advises on next steps

The friction is in step 4. Currently, transferring Claude Code's completion
reports back to Claude Desktop requires:

• Manual selection of report text in Claude Code panel
• Copying to clipboard
• Switching to browser/Claude Desktop app
• Pasting into chat
• Markdown formatting often breaks (tables collapse, code blocks lose

fidelity, indentation gets lost)

• No way to add user comments alongside the report
• Repeated dozens of times per project

This friction discourages thorough back-and-forth review, which degrades
the quality of AI-assisted development workflows.

Why this matters

For users who treat Claude Desktop as a "senior reviewer" and Claude Code
as the "implementer," the broken transfer experience creates unnecessary
cognitive overhead. Every transfer is a context-switch tax.

In a single project session, I personally transfer 10-30 completion reports
back to Desktop. Each transfer costs ~30 seconds of mental friction plus
formatting cleanup. That's 5-15 minutes per session of pure overhead.

Proposed Solution

Proposed Solution

Add a "Send to Claude Desktop" button to the completion report UI in
Claude Code (VS Code extension).

User Flow

[Claude Code completion report]
✓ Task completed: Header visibility improvement

Modified files: ...
Build verification: passed
...

[📋 Copy] [📤 Send to Claude Desktop] ← NEW BUTTON
↓ Clicking "Send to Claude Desktop":
┌──────────────────────────────────────┐
│ 📤 Send completion report │
│ │
│ Add a comment (optional): │
│ ┌──────────────────────────────────┐ │
│ │ Looks great, but the SP version │ │
│ │ feels slightly cramped... │ │
│ └──────────────────────────────────┘ │
│ │
│ Target: [Current Desktop chat ▾] │
│ │
│ [Cancel] [Send] │
└──────────────────────────────────────┘
↓ Clicking "Send":
The completion report (with full markdown fidelity preserved) plus the
user's comment is automatically posted to the active Claude Desktop chat.

Technical considerations

• Use existing Anthropic auth tokens to identify which Desktop chat to post to
• Preserve markdown formatting (tables, code blocks, headers)
• Optional: detect the "linked" Desktop chat based on session metadata

(e.g., the chat that produced the original instruction)

• Optional: configurable destination (current chat, specific chat, new chat)

Why a button + modal pattern?

• The button keeps the action discoverable but unobtrusive
• The modal allows users to add context-specific comments without losing

the report content

• This mirrors familiar share patterns (email forward + add note, Slack

forward + comment)

Alternative Solutions

Alternatives Considered

Alternative 1: Markdown file output to a known location

Claude Code writes completion reports to a designated file
(e.g., tmp/last-report.md), and users manually attach the file in Desktop.

Pros: Possible to implement with current capabilities (just convention)
Cons: Still requires manual file handling, doesn't solve the comment-attachment problem

Alternative 2: Clipboard with automatic markdown preservation

A "Copy as formatted markdown" button that pre-processes the output for
clean clipboard paste.

Pros: Simpler implementation
Cons: Doesn't solve cross-app context switching, no comment attachment

Alternative 3: Browser extension acting as a bridge

A separate extension that detects Claude Code output and pipes it to
Desktop.

Pros: Decoupled from main product
Cons: Fragmented experience, duplicate auth, harder to discover

Why the proposed solution wins

The integrated button + modal pattern is:

• Discoverable: appears in the natural workflow location
• Self-contained: no external dependencies
• Comment-friendly: solves the biggest gap in current workflow
• Future-proof: foundation for richer Claude Code ↔ Desktop integration

(e.g., bidirectional task handoff)

Priority

Medium - Would be very helpful

Feature Category

Developer tools/SDK

Use Case Example

Real-world Use Case

I'm a web producer (non-engineer) building a recruitment landing page for
a beauty salon client. My workflow over the last 3 days:

Project session structure:

• Claude Desktop: ~50 messages discussing design decisions, drafting

instruction documents

• Claude Code: implements 8 sections, hamburger menu, modals, scroll-aware

header, font system overhaul, etc.

• ~25 completion reports transferred back to Desktop for review

Friction count per session: 25 transfers × ~45 seconds (copy +
formatting cleanup + context switch) = ~19 minutes of pure overhead per session.

With this feature: That same workflow would take ~25 seconds total
(one click per transfer + occasional comment). Save ~18 minutes per session.

Specific moment of pain:

Today I asked Claude Code to refine font sizes across all sections. The
completion report was a beautifully formatted markdown table showing every
change. When I copy-pasted to Desktop:

• Table formatting partially broke (some cells, not others)
• I wanted to write "this looks correct, but the SP version feels too

conservative — let's revisit" but had to either:

1. Send the broken report first, then a separate comment
2. Manually reformat the report to fix the table, then write the comment

Both are friction-inducing. A "Send + comment" flow would have made it
seamless.

Why this matters beyond me

This workflow (Desktop = strategic reviewer, Code = implementer) is
extremely common among:

• Web producers / project managers using AI to amplify their reach
• Designers who code in collaboration with AI
• Educators teaching AI-assisted development
• Solo developers wearing multiple hats

All of them would benefit measurably from this feature.

Additional Context

Additional Context

Why I'm requesting this specifically

I'm a Japanese web producer (not an engineer) who has been using
Claude Desktop + Claude Code intensively for ~3 days on a single project.
The workflow is genuinely transformative for someone like me — I can ship
production-quality code through Claude Code while leveraging Claude Desktop's
ability to think strategically and produce thorough instructions.

But every transfer between the two products is a small papercut. After
~25 transfers in a single session, the papercuts start to bleed.

What I've already tried

• Manual copy-paste: standard but loses markdown fidelity
• Asking Claude Code to write reports in "copy-paste-friendly format":

helps somewhat but Claude Code occasionally forgets when given complex
task instructions

• Saving reports as files and attaching to Desktop chats: works but

adds steps and doesn't solve comment-attachment

Mock-up reference (rough)

I described the ideal modal in the "Proposed Solution" section. Happy to
provide more detailed mockups if useful.

Cross-platform considerations

• Should work consistently across macOS / Windows / Linux versions of

VS Code

• Should respect user's existing Claude Desktop session (don't open a

new window if one is already active)

• iPad / mobile editions of VS Code are out of scope for v1

Future expansion

If this lands, natural follow-ups include:

• Bidirectional handoff (send instruction documents from Desktop → Code)
• Threading: link Code completion reports as replies to the originating

Desktop message

• Conflict detection: warn if Desktop chat context has diverged

significantly since the task started

But v1 should be the simple "Send + optional comment" flow described
above. Ship the obvious win first.

---

Thank you for considering this. Happy to discuss further or refine the
proposal in any direction the team finds useful.