Allow viewing and editing content of “pasted text” blocks before submission

This is an issue even without the speech-to-text use case.

I frequently use the up arrow to examine my previous prompts. But all I see when I do that is "[Pasted text #3 +15 lines]" which is both opaque and unhelpful.

I need to be able to view the actual contents of my prompt history.

+1 for this feature request

I'm experiencing the same issue on Windows with VS Code terminal (Claude Code v2.0.33), so this isn't macOS-specific.

My use case: I built a custom voice recording application that:

• Records audio in my native language
• Transcribes via Whisper API
• Translates and formats the output
• Auto-pastes into Claude Code

For 2-3 minute recordings (~500-1000 chars), the text appears as [Pasted text #1] with no way to review or edit before submission. This breaks my workflow since I can't catch transcription/translation errors or refine prompts.

Current workaround: Submit + ESC ESC (uncomfortable and hacky)

This feature would benefit not just accessibility users but anyone with automated prompt generation workflows. The fact that multiple people are reporting this across different platforms and use cases suggests this is becoming a real pain point.

Would love to see any of the proposed solutions implemented - even a simple keyboard shortcut to expand the placeholder would be incredibly helpful!

Current workaround: Submit + ESC ESC (uncomfortable and hacky)

I'm not able to get this to work either - I can _see_ the full text of the cancelled prompt but if I try and cycle back to it with the <kbd>↑</kbd> key it just truncates again so I still can't edit it.

> Current workaround: Submit + ESC ESC (uncomfortable and hacky) I'm not able to get this to work either - I can _see_ the full text of the cancelled prompt but if I try and cycle back to it with the ↑ key it just truncates again so I still can't edit it.

I’m using a Voice Agent that auto-pastes the transcription, so I never see the pasted text before submitting.
When I press Escape to interrupt Claude Code, the hidden text suddenly appears — that’s how I can tell what was actually pasted.
Then I copy it, split it into smaller chunks, and paste it back manually so it doesn’t get truncated.
Another possible workaround would be to keep a blank text file or editor open, paste everything there first, review or edit it, and then paste the final version into Claude Code.
But both ways are really inconvenient — it’s frustrating that there’s such a simple fix for this, yet we have to break our workflow like this to work around it.

At latest support editing the long text with visual editor popuped by shortcut Ctrl+G .

This issue has been inactive for 30 days. If the issue is still occurring, please comment to let us know. Otherwise, this issue will be automatically closed in 30 days for housekeeping purposes.

The issue is still occurring.

i'd really love the ability to see the pasted text, and turn it off by default. especially now that we can modify the input buffer with vim.

+1, I find the current implementation extremely annoying and frustrating, I would really like the option to see the pasted text as well

omg yes... turn this feature OFFFFF

Why was this issue closed without an explanation and marked as "completed" when the problem clearly persists?

I just tried the latest version of Claude Code and it's still not possible to paste longer text, as it displays it as:
[Pasted text #1 +X lines]

Yes, please.

For example, my workflow for a large prompt is to create it in iA Writer and then paste it into Claude Code. I want to verify that my text is pasted correctly. A separate hotkey would be amazing for pasting text without [Pasted text +X lines].

GitHub does this slightly annoying thing where a PR that says it addresses this issue will auto-close the issue. In the next release, you should be able to use the Editor feature to inspect the pasted text.

GitHub does this slightly annoying thing where a PR that says it addresses this issue will auto-close the issue. In the next release, you should be able to use the Editor feature to inspect the pasted text.

It's the nicest thing to appear on a thread for a feature that you need and seeing that it is about to be integrated. Thanks CC team!

At latest support editing the long text with visual editor popuped by shortcut Ctrl+G .

I think this is key. We have Ctrl+G now but the text isn't expanded when EDITOR opens. I think if they expanded when you press Ctrl+G it would solve the problem here. Also I think it's confusing to show the placeholder in EDITOR because it isn't clear if information is being lost.

This feature would be really great, it happens to me very often that I need to change a few characters or words in [Pasted text #1 +40 lines]. Just please add a shortcut to expand it. It's not a dealbreaker but it would save me a few seconds here and there, which adds up when you are addicted to Claude Code

+1 on this. This is especially painful for speech-to-text users.

When using dictation, the transcribed text gets pasted into Claude Code and is immediately collapsed into [Pasted text +X lines]. The problem is that speech-to-text is inherently error-prone — words get misheard, punctuation is off, sentences may be garbled. You need to review and correct the text before submitting. But with the current behavior, you're completely blind to what was actually pasted. You only discover the errors after submission, at which point it's too late.

What makes this even more frustrating is that the collapsing is overly aggressive — it kicks in even for very short text, as little as 4 lines. There's no reason such a small amount of text should be hidden from the user.

A simple toggle to disable collapsing (or at least a way to expand and edit before submitting) would make a huge difference for anyone relying on voice input.

One more vote for disabling it, really annoys

@dicksontsai nice re https://github.com/anthropics/claude-code/issues/18369 BUT it seems specific to vscode (like I have 2.1.34 on linux and still issue, the 1869 says applied in 2.1.7).

One trick I did not know is ctrl-g mentioned somewhere else: it opens the EDITOR you have defined in your env (for me, vim), and there the text is expanded. I can live with that. However a couple of times after returning from the editor, my terminal was messed up -- I had to exit the session, run reset, and resume the session. Haven't used ctrl-g enough to identify a pattern, I think it might just be pycharm Terminal.

The ctrl-g isn't really what this issue is asking for, or at least not what I'm asking for. The option is to disable this behavior entirely.

What? really? Anthropic is not going to fix this?
Open Code already implemented a solution for this, please, a lot of people use dictation, and we need to be able to check if the text is what we expect, we need to be able to fix it, and the solution is to edit every time in an external editor? naaaa, no way josé!

The real case when pasted text blocks have sense - inserting debug log, app output, etc, by using three quotes ```

+1 from a voice input user on Windows

I rely on voice-to-text input (via an IME-level dictation tool) for most of my interactions with Claude Code. This collapsing behavior is a major pain point for me.

Voice transcription is inherently error-prone — misrecognized words, missing punctuation, wrong homophones, etc. I need to visually verify the full transcribed text before submitting. But with the current [Pasted text #1 +N lines] collapse, I'm essentially submitting blind.

What makes it worse: as of v2.1.34, the collapse threshold seems to have been lowered further. Even 3-4 lines of voice input now get collapsed, making the problem significantly more noticeable than before.

A configurable threshold setting (or a simple toggle to disable collapsing) would be a huge accessibility win for voice input users.

The core problem: blind submission erodes trust in the tool

The paste collapse isn't just a cosmetic annoyance — it creates a trust gap between the user and Claude Code. When I paste text, I have no way to verify what Claude actually received. This matters because:

1. Pasted content is often imperfect and needs correction

The most common sources of pasted text are inherently error-prone:

• Voice-to-text / dictation — misheard words, wrong homophones, garbled punctuation
• OCR from screenshots — character substitution errors, broken formatting
• Copied terminal output — stray escape codes, truncated lines
• LLM-generated prompts from other tools — need tweaking before submission

In all these cases, I know the text probably has errors. But I can't see them, so I can't fix them. I'm forced to submit blind and hope for the best.

2. Incorrect input silently derails entire sessions

This is the real cost. When Claude receives garbled or wrong input:

• It interprets the errors literally and heads in the wrong direction
• I don't realize it until several tool calls and minutes later
• By then, Claude has made changes based on bad premises
• I have to interrupt, explain what I actually meant, and undo work
• Context is wasted, tokens are burned, momentum is lost

A 2-second review before submission would prevent 5+ minutes of course correction. The current behavior optimizes for visual tidiness at the expense of correctness.

3. The threshold has gotten more aggressive recently

Multiple people in this thread and in #23134 report that v2.1.34 lowered the collapse threshold. Even 3-4 lines of text now get collapsed. This means the problem now affects even short, routine pastes — not just large blocks.

4. Adjacent bugs compound the problem

• #14164: Pasted text placeholders aren't expanded in message history, stash/unstash, or team sessions. The agent literally receives [Pasted text #1 +55 lines] as the prompt. This means the content is lost entirely in some workflows.
• #18672 / #13125 / #13328: Paste truncation bugs mean the content Claude receives may be incomplete even when it does get expanded.

So not only can't I see what I pasted — there are active bugs where Claude doesn't see it either.

What would fix this

In order of impact:

1. A setting to disable collapsing entirely — "collapsePastedText": false in settings.json. Simple, solves the problem for everyone who wants it.
2. A configurable threshold — "pasteCollapseThreshold": 0 to never collapse, or a line count. Lets users choose their own tradeoff.
3. Expand-in-place — Make collapsed blocks expandable with a keyboard shortcut (or at minimum, ensure Ctrl+G expands them in the editor). @dicksontsai mentioned the Editor feature should help with this — is that shipped?

The current behavior assumes all users prefer a tidy input over a correct one. That's the wrong default for a tool where input accuracy directly determines output quality.

This issue is indeed quite annoying for voice-to-text user relying on tools like Whisper or SuperWhisper etc

What was I doing? Let me press up arrow to check my previous message.
[Pasted text #1 + 9 lines]
Oh...

This is well needed!

It's hard to imagine this issue has existed for 5 months without being supported

It's also hard to imagine how every developer at anthropic, who surely use cc, aren't equally annoyed by this and using cc to fix it. What am I missing....

Well might be worth a try.

• OpenCode has disable_paste_summary
• Copilot CLI has compact_paste (copilot help config)

I can't understand how this is the default with no override in CC when @bcherny himself uses dictation the whole time.

Absolute madness that I have wasted an hour tracking this down to: Claude Code is deliberately designed in this ridiculous way! Fix this fix this fix this!

Can't believe this is still an issue

When dictating into Claude Code, it automatically collapses into [Pasted Text]. This immediately disallows the user from being able to see if what they've dictated is correct and accurate.

People who rely on dictation for any number of reasons including disability can no longer effectively use this.

This is a blisteringly ignorant BREAKING CHANGE.

Overall, the design choice of hiding pasted text into a powerful AI agentic system, and not having that be configurable… it is so dubious.

We may be seeing the "Claude is building Claude" effects. No way this kind of UX nightmare should have made it this far.

I used to be able to work around this by just pasting a few lines at a time (headache but manageable sometimes), today I tried to paste just THREE lines of text and even that was compacted. 🤦🏻

Anyone have any reasonable solution that doesn't involve pasting into an interim editor -> editing -> and then into claude?

eg. a dictation app that pastes the final output sentence by sentence with a small delay, or a terminal where "pastes" get entered as if you were typing? I like my VoiceInk and iTerm, but I would insta-switch to anything that could fix this.

Anyone have any reasonable solution that doesn't involve pasting into an interim editor -> editing -> and then into claude? eg. a dictation app that pastes the final output sentence by sentence with a small delay, or a terminal where "pastes" get entered as if you were typing? I like my VoiceInk and iTerm, but I would insta-switch to anything that could fix this.

Handy does just that.

Direct mode simulates typing.

Still, I use Clipboard (Cmd + V) in OpenCode and Codex - those apps have an override setting for this behavior we're complaining here. Reason why I prefer the clipboard method is that the typing simulation sometimes goes too fast and there's a glitch in terminal apps that ends up eating a few letters along the way and spits them at the end.

<img width="759" height="194" alt="Image" src="https://github.com/user-attachments/assets/6fda8dc0-a682-472a-9f03-368994b8fe1e" />

Handy does just that. Direct mode simulates typing.

Thanks and sorry what does Handy call it? Not seeing Direct mode?

To be clear, I don't want dictation as I'm speaking

> Handy does just that. > Direct mode simulates typing. Thanks and sorry what does Handy call it? Not seeing Direct mode? To be clear, I don't want dictation as I'm speaking

I think I don't understand what you don't understand.

I think I don't understand what you don't understand.

Sorry to derail the thread. Where are the docs on Handy's "Direct mode simulates typing." that you mentioned

Edit: Oh, I see it in the screenshot, it's called "Paste Method" - thanks!!!

Same problem with possible solution outlined here: 28687

This "solution" https://github.com/anthropics/claude-code/issues/28687 does not address the problem.
The problem is not that we need to see the Head and Tail, it's that we need to refine what's pasted.
User descriptions in this thread describe this as an accessibility issue where users that have to use speech to text cannot fix incorrectly captured dictations.

This "solution" #28687 does not address the problem. The problem is not that we need to see the Head and Tail, it's that we need to refine what's pasted. User descriptions in this thread describe this as an accessibility issue where users that have to use speech to text cannot fix incorrectly captured dictations.

My apologies, I have reopened my issue, which is indeed distinct.

That there is no way to see the text pasted or edit the text pasted is insane.

Agree, it's even more insane how many loops the multiple requests in here to fix this have gone into.
I'm not hopeful for a solution at this point even though it's an easy fix. :-(

fwiw Ctrl+g seems to work very well for me (to view and edit pasted text that's too long). That said, would be nice to disable the feature entirely

New to Claude and the feedback here- I'm assuming the github issues are the best place for this. Adding my voice as yet another that thinks this is a significant hindrance to not be able to see and edit the pasted text in the interactive prompt

This is a huge hinderance to my workflow. Really hope you prioritize this on your roadmap.

@claude pliss make a fix for this make no mistakes

really annoying lil feature that feels like a bug!

+1

number one reason for me to look for other solutions, the annoyance is absurd. Especially when the solution is looking like... very easy? I mean, how difficult can it be to just show the full pasted text or add an option for it or a mapping to expand? Every other AI-harness has a solution for that.

Ex-Visual Studio dev here! If you're using VS Code, I created a dead-simple VS Code extension that "types" your content into the terminal window (default: command/control+shift+v) character by character. This bypasses Claude's annoying default [Pasted text +X lines] behavior.

Even if you aren't using VS Code, this should be easy to port to any OS/IDE/terminal app.

https://github.com/Looking4OffSwitch/claude-code-type-from-clipboard.

For those using voice-to-text tools that paste via clipboard + Cmd+V, VoiceInput-Patch can help. It intercepts Cmd+V in terminals and re-types the content character-by-character — the terminal sees keyboard input instead of a paste, so the text appears inline rather than being collapsed into a "[Pasted text]" block.

You can try to paste to your web browser's URL section to remove the new lines, then pasting what you would like. Of course this only works if you don't truly need the new lines.

You can try to paste to your web browser's URL section to remove the new lines, then pasting what you would like. Of course this only works if you don't truly need the new lines.

Very cool workaround bro, works brilliant!
Thank you!

+1 vote for this issue.

In my workflow i can start type the task in obsidian or somewhere else without file references and then paste the text to claude code in terminal and i need to insert file references. but the collapsing issue makes this impossible.

+1 for this feature.
It is kinda rediculous that you can't edit content you pasted in some fashion.
Pasting into another editor, editing, copying and pasting back into Claude is the whole reason that Claude Code exists. Do not have to do this kind of nonsense back and forth work.
Anything that takes a user outside of Claude Code seems like a bug.

No follow up?

I've found that setting my default editor to vim is a good work around. ctrl+g then opens the text up in vim, which makes it easy to manipulate. and for the non-vim users then quitting :q! shows the text in the interactive prompt as normal

Why multi-line pastes become a token? Is there any good reason for it?

+1 for this feature please :)

Ex-Visual Studio dev here! If you're using VS Code, I created a dead-simple VS Code extension that "types" your content into the terminal window (default: command/control+shift+v) character by character. This bypasses Claude's annoying default [Pasted text +X lines] behavior. Even if you aren't using VS Code, this should be easy to port to any OS/IDE/terminal app. https://github.com/Looking4OffSwitch/claude-code-type-from-clipboard.

Love this! Ported it to work with any terminal app: https://github.com/cyrus-cai/claude-code-paste-enhancement

This is an important accessibility issue for voice-to-text users. Until Claude Code adds paste preview/editing, here are workarounds:
Workaround 1 — Paste into a file, then reference it:
Instead of pasting directly into the Claude Code input:

pbpaste > /tmp/prompt.txt  # macOS

This lets you review the file contents in your editor before Claude processes them.
Workaround 2 — Use pipe mode:

pbpaste > /tmp/prompt.txt
cat /tmp/prompt.txt  # Review
cat /tmp/prompt.txt | claude -p

Workaround 3 — Configure dictation software to type instead of paste:
Some dictation tools can be configured to simulate keystrokes instead of clipboard paste:

• MacWhisper: Check if there's a "type" vs "paste" output mode
• Whisper.cpp: Output to file instead of clipboard
• macOS Dictation: Uses keystroke simulation by default (not clipboard), so switching to the built-in dictation may avoid the collapsed block behavior

Workaround 4 — UserPromptSubmit hook to log and confirm:

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "matcher": "",
        "hook": "bash -c 'INPUT=$(cat); PROMPT=$(echo \"$INPUT\" | jq -r .user_prompt); LEN=${#PROMPT}; if [ $LEN -gt 500 ]; then echo \"Long prompt detected ($LEN chars). First 200 chars:\" >&2; echo \"${PROMPT:0:200}...\" >&2; fi'"
      }
    ]
  }
}

This logs long prompts (likely pasted content) so you can see what was submitted, even if the TUI collapsed it.

This shouldn't even be a feature request, it should just be the default behavior.

Re: @yurukusa's suggestion:

Workaround 1 — Paste into a file, then reference it:

I wanted to make sure the stored prompt was visible in the conversation for later reference, so I used this prompt:

I have a prompt stored in "/tmp/prompt.txt". Read it and echo its contents, then execute the prompt.

I use Wispr Flow (voice-to-text dictation) as my primary input method with Claude Code in VS Code. Dictated text often needs minor corrections before submitting — a wrong word here, a sentence that didn't come out right there. Currently I can't edit pasted/dictated blocks at all, which means I have to delete everything and re-dictate.

This is a big accessibility issue for anyone using voice input, not just a convenience feature. Being able to review and edit the pasted block before submission would make voice-driven workflows actually viable.

I need this. I've started using Vibing (Vibevoice) and long text descriptions sometimes need editing

I've faced the same issue as I initially adopted dictation via Wispr Flow. While it would be great for this to be fixed so we don't need to worry about stream speaking/rambling, I've switched my behavior by releasing my shortcut after 3-4 sentences. The text appears pretty fast and I read it as it streams in. If it looks good, I immediately hit the shortcut again and speak a few more sentences.

In the beginning it felt like it was disturbing my flow, but now I prefer it. It forces be to think through what I'm trying to communicate which in turn results in clearer thinking and better outcomes. It might be worth giving it a try until this issue is resolved.

This isn't just an accessibility issue or feature request, it's a potential security concern. If pasted text isn't visible until after pressing Enter, users may unknowingly submit personally identifiable or sensitive information. By the time they realize (assuming they even do), it's already too late.

Current workaround is to use the Edit Prompt in IDE hotkey with [Mac] Control + G.
The problem is that if I am not using VSCode, then it initializes the heavy VSCode app just to see or edit the text ( [Pasted text #2 +92 lines]).

+1 to this feature to expand.

This is resolved. ✅

Now, when you paste something big it initially comes up as [Pasted text #5 +24 lines] and a new tooltip appears below:

paste again to expand

<img width="1847" height="215" alt="Image" src="https://github.com/user-attachments/assets/86d31088-1d65-4e99-a262-b19285d44467" />

If you repeat your paste command again, then it expands.

TLDR

Just hit Cmd + V + Cmd + V and it will expand the text automatically.

Observed on MacOS, Claude Code @ v2.1.116 running via npx.

We also need this available for prompts that are in the history

when does this hit windows?

For dictation software, the prompts are still shown in [Pasted] form, and Cmd + V + Cmd + V will not expand it.

Seconds this. Dication app such as Typeless, after input the clipboard content is not the input. Past (Cmd + v) will not expand the []window

Seconds this. Dication app such as Typeless, after input the clipboard content is not the input. Past (Cmd + v) will not expand the []window

Ctrl g (opens default editor)
Exit editor
See converted text

Cmd+V, Cmd+V is not a good solution:

1. How is a user supposed to discover this?
2. Literally no other application I've ever used going back to Windows 3.1 doesn't paste when you paste, why are we doing this in the first place?
3. I literally never want the collapsed text, based on some Googling it seems no one else wants this feature, I should be able to turn it off once in a system setting and never have to do this double-paste nonsense
4. It wouldn't be that unlikely that I would want to paste the same thing multiple times, now I've got to do four pastes to paste something twice? how does that make sense
5. Other people are saying this solution still breaks accessibility for speech input tools. (I can't vouch for this personally.)

Jumping on this thread to just add my +1, not sure how to edit it or easy way to open it up and view it.

I don't see any benefit for collapsing pasted text.
It can often lead to submitting and then cancelling when you notice something wrong with a transcription, or you pasted the wrong bit of text. I think it should be an option that you turn ON. Default to OFF.

Adding on to this, I often use voice-to-text software for creating my prompts, especially when I know it's something that's really long and detailed. It's much quicker and easier to just spit out a bunch of things via talking instead of spending the time to type it all out,

In fact, I'm writing this right now by talking.

But often in my workflow I go back and proofread what was pasted since often voice-to-text software gets little pieces wrong or maybe heard you a bit incorrectly, especially if you are a non-native speaker.

Currently, there's basically no way to recover this, or at least it is extremely inconvenient. The ironic part is I know the Claude Code team themselves have mentioned using voice to text for making prompts, so I can't understand how this isn't an issue that they would have run into themselves and how this is still not an option to this day.