Claude Code's SendFeedback Tool Lets AI Draft Its Own Session Failure Reports

Anthropic has shipped a new internal tool for Claude Code called SendFeedback, introducing a structural shift in how the AI coding tool handles quality feedback: Claude Code can now draft its own failure reports and queue them for your review before anything is sent to Anthropic. The feature inverts the traditional bug-reporting workflow. Rather than waiting for a developer to notice something went wrong and manually write up a report, Claude Code now witnesses session failures in real time and composes a draft — with the developer retaining full control over what, if anything, gets submitted.

The practical change is modest. The architectural implication is not. For the first time, the model running your coding sessions participates actively in documenting its own shortcomings, making agent-observed failure data available to Anthropic's engineers rather than relying exclusively on developer-initiated reports. Anthropic's data-usage documentation explicitly describes the tool: "With Claude-drafted feedback, Claude can also draft a feedback report and queue it on your machine for you to review. Claude Code sends nothing until you choose to send the draft, and a sent draft goes through the same submission path and retention as other /feedback reports."

What Triggers the Draft — and What Gets Written

SendFeedback activates under four conditions, as described in Anthropic's documentation: a tool or command fails repeatedly without resolving; Claude cannot complete a request after sustained attempts; the user tells Claude that it made an error, or Claude independently determines that it has; or the user explicitly asks Claude to file a report.

When any of these conditions arise, Claude calls SendFeedback internally and generates a structured draft. That draft contains a title, a category field, the body of the report itself, and a toggle controlling whether the conversation transcript from the current session will accompany the submission. The draft is immediately written to the user's local filesystem at ~/.claude/feedback/drafts/. Nothing travels to Anthropic at this stage.

The draft's local residence is deliberate. Anthropic built the workflow so that users can read, edit, and either approve or discard every report before any data leaves the device. This differs significantly from passive telemetry systems, which typically transmit automatically on configurable policies. In Claude Code's implementation, submission requires an affirmative human action at every step.

The transcript toggle defaults to on when the session that generated the draft is still active — meaning the conversation history is available locally — and to off otherwise. Users can override this in either direction before submitting. Even with transcript sharing enabled, the local working directory path is stored in the draft record for reference but is stripped from anything transmitted to Anthropic.

The Queue System: Cards, Limits, and Configuration

Claude Code surfaces pending feedback drafts through an inline card UI rendered above the prompt input. Each card shows the draft's title and offers three keyboard actions: pressing 1 opens the full draft for review and editing; pressing 2 twice in succession sends the draft immediately without editing; pressing 0 dismisses the card without deleting the draft. Dismissed drafts persist in the feedback queue and remain accessible through the /feedback command with no arguments, which opens the full queue across all sessions.

The system enforces session-level throttling: no more than three feedback cards appear during a single session by default. Once that limit is reached, Claude Code switches to displaying a count indicator at the bottom of the input area instead of popping up individual cards. When a user dismisses two consecutive cards and declines to disable the feature, Claude Code stops asking again in that session.

Across all sessions, the draft queue holds a maximum of ten reports. When an eleventh draft is generated, Claude Code automatically removes the oldest entry. Individual drafts expire after thirty days and are deleted from the local filesystem at that point. Once a draft is successfully submitted, it is immediately removed from the local device. Submitted feedback transcripts follow Anthropic's standard data retention policy; according to the data-usage documentation, transcripts shared via /feedback are retained for five years.

For teams that want manual report composition, the /feedback command with a text argument and the /bug command both open the standard feedback window directly, bypassing the draft queue entirely.

Why the Self-Reporting Design Matters for Data Quality

The conventional AI product feedback loop depends on a series of events that each require developer action: noticing something wrong, deciding it is worth reporting, navigating to a feedback mechanism, and writing a coherent description of the failure. Each step drops users, and the failures that survive this pipeline are disproportionately the dramatic ones — crashes, complete task failures, obvious wrong outputs — rather than the subtle ones: quiet reasoning errors, context degradation over long sessions, or tool-use edge cases that produce plausible-looking but incorrect behavior.

SendFeedback's trigger conditions specifically target session-level failure patterns that Claude can observe but users might not independently report. When Claude Code determines on its own that it could not complete a request — an internal evaluation, not one the user necessarily sees — the tool creates a record of that moment before the session context disappears. This captures the failure's technical signature: what was attempted, what tool calls occurred, what the model state was at the moment of failure. A human-authored report filed hours or days later reconstructs that signature from memory and loses precision at each step.

Thariq Shihipar, an Anthropic engineer on the Claude Code team, described the intended workflow in a public post: instead of users navigating to /feedback to write a report themselves, they can instruct Claude to draft one and then review it before sending. The framing is about friction reduction, but the underlying mechanism is a structured data pipeline: agent-observed failure events, formatted into consistent reports, approved by users, and submitted through a defined channel.

Where the Feature Does Not Reach

The availability constraints on SendFeedback are as revealing as the feature itself. Anthropic has excluded it from every deployment context where local draft storage is architecturally unavailable or where data handling obligations override the default product behavior.

Cloud-hosted sessions — including Claude Code on the Web — cannot generate feedback drafts because the execution environment has no access to the user's local filesystem. Non-interactive sessions using the -p flag and Agent SDK runs are excluded for the same structural reason: there is no terminal interface through which the user could review and approve a queued card.

The cloud provider exclusions — Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, and Microsoft Foundry — reflect a different consideration. On those platforms, Anthropic's documentation notes that feedback is written to a local archive under ~/.claude/feedback-bundles/ rather than transmitted to Anthropic. A feedback submission containing session content from a Bedrock deployment would implicate data handling agreements the user signed with AWS, not just with Anthropic. Excluding these contexts from the SendFeedback pipeline prevents that complexity from arising.

The most consequential exclusion is for organizations with Zero Data Retention enabled. ZDR is an enterprise configuration in which Anthropic commits that session content is not retained after a request completes. Allowing feedback drafts in ZDR contexts would create a channel through which session content — even with user approval — could enter Anthropic's feedback pipeline, directly contradicting the retention commitment. The feature is simply unavailable for ZDR organizations.

Three environment variables also disable the feature individually: setting CLAUDE_CODE_SEND_FEEDBACK=0, DISABLE_FEEDBACK_COMMAND=1, or any non-empty value for CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC removes SendFeedback from the session. Organizations that have disabled feature-flag fetching or turned off product feedback at the organizational level through Anthropic's managed settings are similarly excluded.

Read more: Claude Code experiment quietly remapped effort levels for Fable 5, Anthropic confirms

The Changelog Problem This Feature Is Designed to Help Solve

Claude Code's release cadence is aggressive — release trackers log hundreds of versions shipped in 2026, typically with multiple releases per week. Each release bundles dozens of changes spanning security patches, behavioral adjustments, UI refinements, and infrastructure improvements. The changelog covers these items, but it cannot capture what the changelog does not know: the moments inside a session when Claude Code encountered something it could not handle and moved on without record.

This limitation is structural and documented. Earlier this year, GPTS24 covered an incident in which an Anthropic A/B experiment changed how effort level selections were translated into numeric parameters for Fable 5 sessions — a behavioral modification that did not appear in the changelog and was only discovered when a developer compared raw API request logs against expected values. Anthropic acknowledged the experiment after the fact, but the incident illustrated the gap between what the changelog covers and what actually changes during a session.

SendFeedback does not close that gap for undisclosed experiments. What it does is create a formal mechanism for the other direction: failures that Claude observes but that currently vanish when the session ends. From Anthropic's perspective, a feedback report filed by the model itself — at the moment of failure, with the session context intact — contains significantly more diagnostic information than one reconstructed after the fact. For the developer, the cost is a few seconds reviewing a pre-written draft rather than composing one from scratch.

The feature also changes who the system is designed to serve in the feedback loop. Prior to this change, only developers who were motivated enough to navigate to /feedback contributed quality data about session failures. With SendFeedback, every session in which Claude Code encounters a failure becomes a potential data source, filtered through user approval rather than user initiative.

How It Compares to Feedback Mechanisms in Competing Tools

No directly comparable AI-initiated feedback drafting mechanism appears in current documentation for other major AI coding CLI tools — including OpenAI Codex CLI, Cursor, Gemini CLI, and GitHub Copilot CLI.

The approaches competitors currently use follow the traditional model: a separate feedback command or button, no AI drafting, and no structured capture of machine-observable failure conditions. GitHub Copilot's feedback path routes through GitHub's issue tracker. Cursor's in-app feedback mechanism is user-initiated. Anthropic appears to be the first major AI coding CLI developer to implement AI-initiated, human-approved feedback drafting — though this characterization is based on documentation review rather than independent audit of each product's internal capabilities.

The distinction is not merely in UX convenience. It reflects different assumptions about where quality data comes from in an agentic coding workflow. If the assumption is that developers will notice and report failures, the existing model works adequately. If the assumption is that a model running tens or hundreds of tool calls per session will encounter edge cases that the developer may not notice — or may attribute to their own code rather than to the agent — then an agent-level observation mechanism changes the quality feedback picture materially.

Claude Code runs an unusually high volume of tool calls per session compared with chat-based AI products. A session involving multi-file refactoring, repeated test runs, git operations, and web lookups might involve dozens of discrete tool invocations, any of which could fail in ways that are difficult to isolate retrospectively. The SendFeedback tool is positioned to capture those failure signatures while they are still observable.

The competitive gap here may narrow quickly. Codex CLI and Gemini CLI are both releasing at high frequency in 2026, and the diagnostic surface in agentic coding tools is expanding in ways that would benefit from a similar self-reporting mechanism. Whether competitors add AI-drafted feedback mechanisms in upcoming release cycles will partly depend on whether Anthropic's implementation demonstrates measurable improvement in bug fix turnaround or model behavior quality.

For Claude Code's enterprise buyers in particular, the feedback loop has additional significance. Large deployments generate failure patterns that individual developers rarely see: edge cases at scale, specific codebase structures that trigger unusual agent behavior, or tool-use sequences that fail only under production load. A mechanism that systematically collects those failure signatures — with user approval — gives Anthropic a diagnostic dataset that manual reporting cannot replicate at volume.

What Remains Company-Claimed and What Developers Should Check

The behavioral details described above are drawn from Anthropic's documentation and are company-claimed rather than independently verified through external audit. Anthropic's stated data handling — that drafts remain local until submission, that working directory paths are not transmitted, that ZDR organizations are excluded — constitutes documented behavior, and the data-usage page at code.claude.com/docs/en/data-usage is the authoritative reference.

Developers in regulated environments or those with heightened data sensitivity should confirm the exclusion conditions apply to their specific deployment before assuming the feature is inactive. The simplest verification is checking whether the /feedback command is available in the session: for ZDR organizations and the excluded cloud providers, Anthropic states that neither the feedback command nor the SendFeedback tool will be present.

For teams that want to disable the feature proactively, setting CLAUDE_CODE_SEND_FEEDBACK=0 in the environment accomplishes this before any session begins.

The feature's data architecture — local drafts, human approval, ZDR exclusion — represents a more conservative privacy posture than typical telemetry systems, but it is also recent enough that its real-world behavior in edge cases has not been publicly documented at scale. As the feature accumulates usage, any gaps between the documented behavior and the observed behavior should surface through the same mechanism Anthropic built it to enable: a feedback report, drafted by Claude, reviewed by you.

The milestone to watch next is whether Anthropic extends the SendFeedback mechanism beyond failure detection into proactive quality signaling — drafting reports for sessions where tasks succeeded but the path was unusually circuitous, or where the model made assumptions that the developer corrected mid-session. That expansion would shift the feature from a failure tracker to a continuous quality instrument, giving Anthropic a richer signal about how Claude Code performs on the long tail of real-world coding tasks that no benchmark captures. It would also require a more nuanced trigger model than the current failure-detection approach, and it raises the privacy bar considerably: a success that required three corrections is a qualitatively different piece of data than a session that crashed. Whether Anthropic navigates that tradeoff — or keeps SendFeedback focused narrowly on observable failures — will determine how significant this addition looks in retrospect.

👉 Read more: Codex hits 20 million users as Claude Code's lead in AI coding narrows