[FEATURE] Let claude.ai chat delegate briefs to a Claude Code session through an approval card, and get the result back

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

I am a solo operator who does not read or write code. Everything in my project is written by agents; my job is to decide what should be built and where the limits are.

I cannot do that directly in Claude Code, for two reasons. I do not know how to phrase a task so that the agent builds what I have in mind. And, more importantly, I do not know how to phrase the limits — the only constraint I can write by myself is "read, do not touch any file". Where to draw the line during real development work, and how to say it so the agent respects it, is exactly what I cannot do.

So I work through claude.ai chat. I explain what I want in plain language (in French — I do not write English). The chat asks the questions I would not have thought of, tells me what the change will do in plain terms, and then writes the brief for Claude Code for me: context, numbered steps, what must not be touched, when to stop, what to report. I paste that brief into Claude Code. When Claude Code is done, I paste its report back into the chat, which tells me what happened and what comes next.

This works. It is also the single most tedious part of my day. Every step of every task is two manual copy-and-pastes between two windows of the same application, and the chat has no way to know whether Claude Code has finished, failed, or is waiting for something. I have tried several times to automate this and never found anything that holds up.

Proposed Solution

Let the chat side of the Claude app talk to Claude Code sessions, the same way it already talks to connectors — with the user as the gate.

1. A delegation card in the chat. When the chat has a brief ready for Claude Code, it does not print it as text to copy. It shows a card: a one-line title of what the brief does, the model and effort it proposes, the target (an existing session or a new one, on which branch), and a collapsed "show full prompt" for anyone who wants to read it. Above the card, the chat says in plain words what will happen — that is what a non-technical user actually reads. Three actions: approve and send, refuse, or modify (give a different instruction, change the model, pick another session). Nothing goes to Claude Code without that click, exactly like a connector call the user has to approve.

The model and effort shown on the card are not just labels: clicking one opens the choice, so if the chat proposes "low" and I want "high", I change it right there and send. And the collapsed "show full prompt" opens as an editable view, so someone who can read the brief can add a line or fix a detail directly and send — for a small change, that is faster than going through "modify".

1. The chat picks the routing. It chooses model, effort and target session itself, and can open a new session when the task warrants it. Those choices are shown on the card and can be overridden before sending.
2. The result comes back on its own. When the session finishes, its final report lands in the chat as a message, and the chat resumes from it without me pasting anything. How the chat waits in the meantime is open — a lightweight watcher, short progress notes every few minutes, or something else entirely; those are examples, not a specification. What matters is that the report arrives by itself.

Mockup attached (names and numbers are placeholders).

<img width="1920" height="1640" alt="Image" src="https://github.com/user-attachments/assets/6e7554bc-d19c-42ae-9a60-dc662170e5ab" />

How I write the briefs today, in case it helps design the card

The chat writes them in English with XML sections (<context>, <steps>, <scope_out>, <stop_criteria>, EXPECTED RESPONSE FORMAT) — English because it tokenizes more compactly than French, XML because Anthropic's own prompting docs recommend tags to keep instructions, context and constraints from bleeding into each other. Above the brief, a French summary of what it does for me, and one line naming the model and effort. That two-layer shape — plain summary for the human, structured brief for the agent — is what the card would formalise.

Why this is not only a convenience

It would open agent-driven development to people like me who cannot write code and cannot yet write agent instructions. But I think it also helps people who can code: the chat is better than most of us at turning a spoken idea into a precise, bounded brief, and having it draft every brief, with the human approving each one, is a stronger habit than typing instructions ad hoc.

Scope note

I realise all of this may be hard to implement together. If only part of it is feasible — the approval card alone, or the automatic return of the final report — either one on its own would already remove most of the copy-and-paste.

Alternative Solutions

_No response_

Priority

High - Significant impact on productivity

Feature Category

Other

Use Case Example

_No response_

Additional Context

Related issues

#23017 asked for a one-way "open in Claude Code" with the chat context; #54880 asks for the reverse hand-off. This request is the loop between the two, with the user approving each brief and the result coming back into the chat.