Claude Code in deiner eigenen Web-App · Teil 11 von 16 der Serie
Teil 11: Einen Plan freigeben
Ein Kästchen „Plan first“ für den Auftrag: Claude Code arbeitet im Plan-Modus, der Server schaltet den Modus mit Shift+Tab um und liest ihn aus der Statuszeile ab, und der Plan erscheint in der Seite, zum Freigeben oder zum Zurückschicken mit einer Notiz.
Claude Code in deiner eigenen Web-AppTeil 11 von 16
Auf dieser Seite
Quest-Ziele
- Dem Auftragsfeld und dem Auftragstext eine Option „Plan first“ geben
- Den Berechtigungsmodus von Claude Code mit Shift+Tab umschalten und aus der Statuszeile ablesen
- Eine neue Sitzung von der ersten Nachricht an im Plan-Modus starten
- Den Plan, den ExitPlanMode mitbringt, als Dialog in der Seite zeigen
- Ihn mit der Hook-Ausgabe freigeben, die Claude Code wirklich annimmt, oder ihn mit einer Notiz zurückschicken
Bisher fängt Claude Code an zu bauen, sobald ein Auftrag ankommt. Für eine kleine Änderung ist das richtig. Bei einer größeren willst du vielleicht erst sehen, was es vorhat: welche Dateien, welche Abschnitte, was wohin kommt. Dafür hat Claude Code einen Modus, den Plan-Modus. Es liest, schaut sich um und fragt, wenn es etwas braucht, und dann schreibt es einen Plan, statt etwas zu ändern. Du gibst den Plan frei oder schickst ihn mit einer Notiz zurück, und erst dann baut es.
Dieser Teil gibt dem Auftrag ein Kästchen „Plan first“ und der Seite einen Plan-Dialog. Zwei Dinge daran sind neu. Der Server muss den Modus von Claude Code umschalten, und das tut kein Hook: Er drückt die Tasten, die du drücken würdest, und liest das Ergebnis aus der Statuszeile ab. Und einen Plan über den Hook freizugeben, braucht mehr als ein „allow“.
Erst planen
Das Auftragsfeld bekommt ein Kästchen. So sieht src/requestBox.ts jetzt aus:
import { api } from './api.ts';
import { h } from './dom.ts';
import type { RequestBody, Site } from '../shared/types.ts';
/** Where you tell Claude Code what to build or change. */
export class RequestBox {
readonly el: HTMLFormElement;
private url: string;
private label = h('h2', {}, 'What should Claude Code build?');
private text = h('textarea', { rows: 5, 'aria-label': 'Your request' });
private go = h('button', { type: 'submit', class: 'primary' }, 'Build the site');
private plan = h('input', { type: 'checkbox' });
private msg = h('p', { class: 'hint bad', 'aria-live': 'polite' });
private busy = false;
constructor(site: string) {
this.url = `/api/sites/${site}/requests`;
this.el = h('form', { class: 'panel request' },
this.label, this.text,
h('div', { class: 'actions' },
h('label', { class: 'check', title: 'Claude Code shows you its plan before it changes anything' }, this.plan, 'Plan first'),
this.go),
this.msg);
this.el.onsubmit = (e) => { e.preventDefault(); void this.send(); };
this.text.onkeydown = (e) => { if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) { e.preventDefault(); void this.send(); } };
}
/** A built site gets changes; a new one its first version. Nothing goes out while a run is on. */
update(site: Site | null, busy: boolean) {
this.busy = busy;
const built = Boolean(site?.built);
this.label.textContent = built ? 'What should Claude Code change?' : 'What should Claude Code build?';
this.text.placeholder = built
? 'Make the header smaller, add a page with the opening hours…'
: 'A warm, simple one-pager: the breads of the week, opening hours, where to find us…';
this.go.textContent = built ? 'Send to Claude Code' : 'Build the site';
this.go.disabled = busy || !site;
}
private async send() {
if (this.busy) return;
this.msg.textContent = '';
const body: RequestBody = { text: this.text.value, plan: this.plan.checked };
try {
await api('POST', this.url, body);
this.text.value = '';
} catch (err) { this.msg.textContent = (err as Error).message; }
}
}Das Kästchen nimmt den Platz des Hinweises „Ctrl+Enter sends“ ein; Strg+Enter schickt weiterhin ab. Es bleibt für den nächsten Auftrag so, wie du es gelassen hast. Sein Wert reist mit dem Auftrag, also bekommt RequestBody in shared/types.ts ein Feld:
/** A request typed into the page. */
export interface RequestBody {
text: string;
/** plan first: Claude Code shows its plan for approval before it changes anything */
plan?: boolean;
}Die Route in server/main.ts gibt das Flag zweimal weiter, an den Auftragstext und an den Lauf:
// requests: Claude Code works on the site
['POST', /^\/api\/sites\/([^/]+)\/requests$/, async (req, res, m) => {
if (!terminals.available) throw new HttpError(409, 'Sessions need tmux.');
const site = sites.get(m[1]);
const { text, plan } = await readJson<RequestBody>(req);
try {
send(res, 201, agent.run(target(site.name), runTitle(site), requestText(site, String(text ?? ''), plan === true), plan === true));
} catch (err) { throw new HttpError(409, (err as Error).message); }
}],Der Auftragstext in server/requests.ts bekommt für einen Plan einen Absatz mehr:
import type { Site } from '../shared/types.ts';
/** The page's name for a run of this site. */
export const runTitle = (site: Site) => (site.built ? 'Changing the site' : 'Building the site');
/**
* What Claude Code gets for a request: the user's words, framed by what Sitesmith needs. It goes
* into .sitesmith/request.md; the folder's CLAUDE.md says what the site is and how it is built.
*/
export function requestText(site: Site, text: string, plan = false) {
const task = site.built
? 'Change the site in this folder as follows:'
: 'Build the first version of the site in this folder (CLAUDE.md says what it is about). The user adds:';
return `# A request from Sitesmith
${task}
${text.trim() || '(nothing: use your own judgement)'}
If something important is open (the style, the sections, the tone of the texts), ask before you
build, with AskUserQuestion: two to four options per question, the one you recommend first. For a
question about the layout, give each option a small sketch of the page in plain text as its
preview. Don't ask about details you can decide well yourself.
${plan ? `You are in plan mode: first make a plan (what you will build or change, file by file, in a
few short points) and present it with ExitPlanMode. Sitesmith shows it to the user for approval.
` : ''}When you are done, say in two or three sentences what you built or changed.
`;
}Im Plan-Modus weiß Claude Code, dass es einen Plan mit dem Werkzeug ExitPlanMode vorlegen soll. Der Absatz sagt es trotzdem und bittet um einen kurzen Plan, Datei für Datei, weil er in einem Dialog gelesen wird und nicht in einem breiten Terminal. Der Absatz über Fragen bleibt: Auch im Plan-Modus kann Claude Code zuerst fragen, und im Lauf für die Screenshots hat es das getan, mit einer Frage vor seinem Plan.
In server/agent.ts merkt sich ein Lauf, ob er erst planen soll:
/** A run, with what only the server needs. */
interface Job extends Run {
target: Target;
/** plan first: Claude Code works in plan mode until you approve its plan */
plan: boolean;
/** when its line was typed in (or its session started) */
sentAt: number;
}und run() nimmt das Flag entgegen:
/** Asks Claude Code for something. One run at a time per site. */
run(t: Target, title: string, request: string, plan = false): Run {
const on = this.active(t.name);
if (on) throw new Error(`Claude Code is still on “${on.title}”. Wait until it is done, or stop it.`);
fs.mkdirSync(path.join(t.dir, OWN), { recursive: true });
fs.writeFileSync(path.join(t.dir, REQUEST), `${request.trim()}\n`);
const job: Job = { id: crypto.randomUUID(), title, status: 'queued', queued: Date.now(), target: t, plan, sentAt: 0 };
this.site(t.name).queue.push(job);
this.note(t.name, { kind: 'note', text: `Asked from the page: ${title}` });
void this.deliver(t.name);
this.changed(t.name);
return pub(job);
}Die Modi von Claude Code
Claude Code hat Berechtigungsmodi, die entscheiden, was es tun darf, ohne zu fragen. Sitesmith hat bisher einen verwendet, gesetzt mit --permission-mode acceptEdits beim Start einer Sitzung (Teil 3): Dateiänderungen gehen durch, und viele Befehle fragen weiterhin nach (Teil 9). Der Plan-Modus ist ein anderer: Claude Code darf lesen und sich umschauen, ändert aber nichts, bis ein Plan freigegeben ist.
Im Terminal zeigt die Statuszeile unter dem Eingabefeld den Modus, und Shift+Tab schaltet zum nächsten weiter. Ein Druck nach dem anderen sah so aus:
# the status line under the input box, Shift+Tab after Shift+Tab (on a machine where auto mode# is available; without it, the cycle skips it) ⏵⏵ accept edits on (shift+tab to cycle) ⏸ plan mode on (shift+tab to cycle) ⏵⏵ auto mode on (shift+tab to cycle) ⏸ manual mode on
„Manual mode“ ist der Standardmodus von Claude Code, in dem auch Dateiänderungen nachfragen. Der Auto-Modus ist nur dort im Kreislauf, wo er verfügbar ist; ohne ihn hat der Kreislauf drei Stationen.
Umschalten mit Tasten
Kein Hook schaltet den Modus um. Also tut der Server, was du tun würdest: Shift+Tab drücken, auf die Statuszeile schauen und wieder drücken, bis der richtige Modus dasteht. tmux nennt Shift+Tab BTab, für „back tab“. Du kannst es von Hand an einer Sitzung ausprobieren, die an ihrem Prompt wartet:
$ tmux -L sitesmith send-keys -t =lumen-cafe: BTab$ tmux -L sitesmith capture-pane -p -t =lumen-cafe: | grep -E 'edits on|mode on'
Jedes BTab rückt die Statuszeile eine Station weiter, und grep fischt sie aus dem Bildschirm, den capture-pane ausgibt. Füge in server/terminals.ts unter Target einen Typ für die Modi und einen für die Arten hinzu, wie eine Sitzung starten kann:
export interface Target { name: string; dir: string }
/** How a session starts: with a first message, continuing the last conversation, in plan mode. */
export interface StartOptions { prompt?: string; resume?: boolean; plan?: boolean }
export type Mode = 'plan' | 'acceptEdits' | 'auto' | 'default';und zwei Methoden hinter atEmptyPrompt():
/** The permission mode, from the status lines under Claude Code's input box. */
async mode(t: { name: string }): Promise<Mode> {
const footer = (await this.screen(t)).trimEnd().split('\n').slice(-4).join('\n');
if (/plan mode on/.test(footer)) return 'plan';
if (/accept edits on/.test(footer)) return 'acceptEdits';
if (/auto mode on/.test(footer)) return 'auto';
return 'default';
}
/**
* Switches the permission mode as you would: Shift+Tab cycles through the modes, the status line
* says which one is on. Only at an empty prompt. False if the mode never came up.
*/
async setMode(t: { name: string }, want: Mode) {
for (let i = 0; i < 5; i++) {
if (await this.mode(t) === want) return true;
await this.keys(t, 'BTab');
await new Promise((r) => setTimeout(r, 400));
}
return await this.mode(t) === want;
}mode() liest den Bildschirm ohne Farben, wirft die leeren Zeilen am Ende weg und schaut sich die letzten vier an: Dort steht die Statuszeile. Drei Modi erkennt es an ihren Wörtern. Alles andere ist 'default': der Manual-Modus, aber auch ein Bildschirm, den es nicht erkennt. Weil Sitesmith immer nur nach dem Plan-Modus oder nach Accept Edits fragt, kann ein unbekannter Bildschirm nie als Erfolg zählen.
setMode() dreht bis zu fünf Runden: schauen, Shift+Tab drücken und Claude Code 400 Millisekunden zum Neuzeichnen geben. Fünf Drücke kommen von jeder Station aus einmal um einen Kreislauf mit drei oder vier Stationen herum. Warum ablesen statt Drücke zählen? Weil du nicht weißt, wo der Kreislauf anfängt (vielleicht hast du im Terminal selbst umgeschaltet) und wie viele Stationen er auf diesem Rechner hat. Die Statuszeile abzulesen erledigt beide Fragen.
Das funktioniert nur an einem leeren Prompt. In einem Dialog bedeutet Shift+Tab etwas anderes: Im eigenen Plan-Dialog von Claude Code zum Beispiel gibt es den Plan mit deinem getippten Feedback frei, wie du weiter unten siehst.
Eine neue Sitzung lässt sich so gar nicht umschalten. Ihre erste Nachricht steht auf der Kommandozeile (Teil 5), Claude Code fängt also an zu arbeiten, bevor irgendwer eine Taste drücken könnte. Sie bekommt ihren Modus von Anfang an: command(), start() und respawn() nehmen die neuen Optionen:
/**
* What the session runs: Claude Code in a login shell, and when it exits, an interactive shell in
* the folder, so the session stays open. The shell gets the program and its arguments as "$0"
* and "$@", so no argument is ever parsed by the shell.
*/
private command(opts: StartOptions) {
return [SHELL, '-lic', '"$0" "$@"; exec "$SHELL" -i', CLAUDE,
// file edits in the site's folder go ahead, commands still ask; or plan mode for a plan first
'--permission-mode', opts.plan ? 'plan' : 'acceptEdits',
// the hooks, on top of your own settings
...(this.hooks ? ['--settings', this.hooks.settings] : []),
...(opts.resume ? ['--continue'] : []),
...(opts.prompt ? [opts.prompt] : [])];
}
/** Starts Claude Code in a site's session: fresh, or continuing the folder's last conversation. */
async start(t: Target, opts: StartOptions = {}) {
if (this.states.has(t.name)) return;
await this.tmux('new-session', '-d', '-s', t.name, '-x', '120', '-y', '36', '-c', t.dir, ...this.env(t), ...this.command(opts))
.catch((err: Error) => { if (!/duplicate session/.test(err.message)) throw err; });
await this.poll();
}
/** Claude Code again, in place of the shell it left behind. */
async respawn(t: Target, opts: StartOptions = {}) {
await this.tmux('respawn-pane', '-k', '-t', pane(t.name), '-c', t.dir, ...this.env(t), ...this.command(opts));
await this.poll();
}In server/agent.ts gibt deliverNext() das Flag weiter und schaltet den Modus um, bevor es tippt:
private async deliverNext(name: string, s: SiteAgent) {
const job = s.queue[0];
if (!job) return;
await this.terminals.poll();
const term = this.terminals.get(name);
const resume = this.terminals.hasConversation(job.target.dir);
try {
if (!term) await this.terminals.start(job.target, { prompt: COMMAND, resume, plan: job.plan });
else if (!term.claude) await this.terminals.respawn(job.target, { prompt: COMMAND, resume, plan: job.plan });
else {
if (this.busy(name) || !(await this.terminals.atEmptyPrompt(job.target))) return;
// it may have been taken while we looked
if (s.queue[0] !== job) return;
// plan mode for a plan first, and out of it for everything else
if (!(await this.terminals.setMode(job.target, job.plan ? 'plan' : 'acceptEdits'))) {
throw new Error(`Claude Code did not switch to ${job.plan ? 'plan mode' : 'accepting edits'}: look in the terminal.`);
}
await this.terminals.type(job.target, COMMAND);
}
} catch (err) {
s.queue.shift();
s.run = job;
this.end(name, 'failed', (err as Error).message);
return;
}
s.queue.shift();
s.run = job;
job.status = 'starting';
job.started = job.sentAt = Date.now();
this.changed(name);
}Jeder Auftrag, der in eine laufende Sitzung getippt wird, setzt den Modus: den Plan-Modus, wenn erst geplant werden soll, Accept Edits für alles andere. Ein normaler Auftrag nach einem Plan-Lauf findet Claude Code also nie noch im Plan-Modus vor, und hast du im Terminal selbst umgeschaltet, schaltet der nächste Auftrag aus der Seite zurück. Will der Modus nicht erscheinen, scheitert der Lauf mit einer Meldung, die dich ins Terminal schickt, statt deinen Auftrag in einem Modus abzuschicken, den du nicht gewählt hast.
Der Plan in der Seite
Hat Claude Code seinen Plan, ruft es ExitPlanMode auf, mit dem Plan als Markdown in tool_input.plan. Den Plan-Modus zu verlassen braucht deine Zustimmung, also geht der Aufruf über PermissionRequest, den Teil 9 schon für jedes Werkzeug festhält. hook.ts und die Einstellungen der Hooks bleiben, wie sie sind, nur hookAsk() muss den Plan erkennen. Sein Zweig, der das Ask baut, wird zu:
let ask: Ask;
if (ev.hook_event_name === 'PermissionRequest' && ev.tool_name === 'ExitPlanMode') {
// Claude Code's plan, as its own dialog would show it
ask = { id, kind: 'plan', plan: String(ev.tool_input?.plan ?? ''), since: Date.now() };
this.note(name, { kind: 'note', text: 'Shows you its plan' });
} else if (ev.hook_event_name === 'PermissionRequest') {
const input = ev.tool_input ?? {};
const detail = [input.command, input.file_path, input.url].find((v) => typeof v === 'string') as string | undefined;
const summary = describeTool(String(ev.tool_name), input);
ask = { id, kind: 'permission', tool: String(ev.tool_name), summary, detail, remember: Boolean(ev.permission_suggestions?.length), since: Date.now() };
this.note(name, { kind: 'note', text: `Asks for permission: ${summary}` });
} else {
ask = { id, kind: 'questions', questions: (ev.tool_input?.questions ?? []) as Question[], since: Date.now() };
}Der Plan ist eine neue Art von Ask in shared/types.ts, und die Antwort bekommt ein Feld für die Notiz, die mit einem zurückgeschickten Plan mitgeht:
/** What Claude Code waits for the page to answer. */
export type Ask =
| { id: string; kind: 'questions'; questions: Question[]; since: number }
| {
id: string;
kind: 'permission';
tool: string;
/** one line about what it wants to do */
summary: string;
/** the command, the file or the address */
detail?: string;
/** whether Claude Code offers a rule for "from now on" */
remember: boolean;
since: number;
}
/** the trust dialog of a folder Claude Code has never worked in */
| { id: string; kind: 'trust'; dir: string; since: number }
/** a plan to approve (ExitPlanMode), in Markdown */
| { id: string; kind: 'plan'; plan: string; since: number };
/** The page's answer: per question text, the chosen labels (joined with ", ") or your own words. */
export interface AnswerBody {
id: string;
answers?: Record<string, string>;
/** for a permission prompt, and for a plan (allow: approve it, deny: keep planning) */
decision?: 'allow' | 'always' | 'deny';
/** for a plan sent back: what should change */
note?: string;
/** for the trust dialog */
trust?: boolean;
/** hand it back: Claude Code asks in the terminal instead */
terminal?: boolean;
}Importiere in src/askDialog.ts markdown, die Darstellung aus Teil 7:
import { api } from './api.ts';
import { h } from './dom.ts';
import { markdown } from './markdown.ts';
import type { AnswerBody, Ask, Question } from '../shared/types.ts';nimm den Plan in show() auf:
/** Shows a site's ask; nothing happens when it is already on screen, so choices made stay. */
show(site: string, title: string, ask: Ask) {
if (this.el.open && this.ask?.id === ask.id) return;
this.ask = ask;
this.site = site;
this.dismissed = null;
this.msg.textContent = '';
this.sub.textContent = title;
if (ask.kind === 'questions') this.renderQuestions(ask.questions);
else if (ask.kind === 'permission') this.renderPermission(ask);
else if (ask.kind === 'plan') this.renderPlan(ask.plan);
else this.renderTrust(ask.dir);
if (!this.el.open) this.el.showModal();
}und füge den Dialog selbst hinter terminalButton() ein:
/** The plan: approve it, or send it back with what should change. */
private renderPlan(plan: string) {
this.heading.textContent = 'Claude Code has a plan';
const view = h('div', { class: 'plan md' });
view.innerHTML = markdown(plan || '(The plan is empty: see the terminal.)');
const note = h('textarea', { rows: 2, placeholder: 'What should change? (to send it back)', 'aria-label': 'What should change' });
this.body.replaceChildren(view, note);
const approve = h('button', { type: 'button', class: 'primary', onclick: () => void this.send({ decision: 'allow' }) }, 'Approve and build');
this.foot.replaceChildren(this.terminalButton(),
h('button', { type: 'button', onclick: () => void this.send({ decision: 'deny', note: note.value }) }, 'Keep planning'),
approve);
requestAnimationFrame(() => approve.focus());
}Der Plan kommt vom Modell, also gelangt er über markdown() in die Seite, das den Text maskiert, bevor es Markup hinzufügt (Teil 7), und nie direkt in innerHTML. Darunter ein Feld für eine Notiz und drei Buttons: Answer in the terminal aus Teil 10, Keep planning mit der Notiz und Approve and build.
Freigeben oder zurückschicken
Füge in answer() nach dem Zweig für den Vertrauensdialog einen Zweig für den Plan hinzu:
if (ask.kind === 'plan') {
// approved: leave plan mode for "accept edits", as the dialog's "Yes" would. The allow needs
// the tool's input back (updatedInput), or Claude Code shows its own dialog anyway.
if (req.decision === 'allow') {
this.note(name, { kind: 'prompt', text: 'You approved the plan' });
this.settle(p, { status: 'answered', output: { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: {
behavior: 'allow',
updatedInput: p.event?.tool_input ?? {},
updatedPermissions: [{ type: 'setMode', mode: 'acceptEdits', destination: 'session' }],
} } } });
} else {
const note = oneLine(String(req.note ?? ''));
this.note(name, { kind: 'prompt', text: note ? `Keep planning: ${short(note)}` : 'You sent the plan back' });
this.settle(p, { status: 'answered', output: { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: {
behavior: 'deny',
message: note ? `The user wants the plan changed: ${note}` : 'The user did not approve the plan. Ask what should change.',
} } } });
}
return;
}Der Hook gibt aus, was dieser Zweig baut, und Claude Code liest es. Eine Freigabe gibt Claude Code das hier:
{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"allow","updatedInput":{…die Eingabe des Werkzeugs…},"updatedPermissions":[{"type":"setMode","mode":"acceptEdits","destination":"session"}]}}}
behavior: 'allow'lässtExitPlanModedurch: Der Plan ist freigegeben.updatedInputgibt die Eingabe des Werkzeugs unverändert zurück. Das sieht überflüssig aus, aber ohne es übergeht Claude Code das „allow“ und fragt doch im Terminal.updatedPermissionsmitsetModesagt, in welchen Modus es aus dem Plan-Modus geht: Accept Edits, der Modus, in dem jede Sitzung von Sitesmith arbeitet, für den Rest dieser Sitzung.
Den Plan zurückzuschicken gibt Claude Code das hier:
{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"deny","message":"The user wants the plan changed: …"}}}
Ein „deny“ mit einer Nachricht. Claude Code liest die Nachricht, bleibt im Plan-Modus und arbeitet am Plan weiter, und die nächste Fassung kommt über denselben Hook als neuer Dialog zurück. Ohne Notiz wird es gebeten zu fragen, was sich ändern soll. Die Notiz wird zu einer Zeile, wie eine Antwort in Teil 7.
Der Plan-Dialog im Terminal
Wie bei Berechtigungsabfragen zeichnet Claude Code seinen eigenen Dialog, während der Hook den Plan festhält. Im Test hat das Terminal das hier gezeigt, während die Seite einen Plan festhielt:
# Lumen Café: the terminal while the page held the plan Claude has written up a plan and is ready to execute. Would you like to proceed? ❯ 1. Yes, and use auto mode 2. Yes, manually approve edits 3. Tell Claude what to change shift+tab to approve with this feedback ctrl+g to edit in VS Code · ~/.claude/plans/do-what-sitesmith-request-md-says-giggly-wadler.md
Die letzte Zeile zeigt, dass Claude Code jeden Plan als Markdown-Datei in ~/.claude/plans/ aufbewahrt. Seine Möglichkeiten unterscheiden sich ein wenig von denen der Seite: Sie können in den Auto-Modus wechseln oder dazu, jede Änderung von Hand freizugeben, während die Freigabe der Seite zu Accept Edits geht. Wie in Teil 10 gewinnt, was zuerst beantwortet wird, und moveOn() schließt den Dialog der Seite, sobald Claude Code weitermacht.
Probier es aus
Starte den Server neu, öffne eine Site, die schon gebaut ist, hake Plan first an und schick eine Änderung. Im Test sollte Lumen Café eine Seite mit Veranstaltungen bekommen:
Der erste Plan erschien in der Seite: „Plan: events page for Lumen Café“, mit Context, Changes und Verification.
Er ging zurück mit der Notiz „Also show the next event on the home page, under the hero.“
Der zweite Plan erschien als neuer Dialog, jetzt mit einem „Next event strip directly under the hero“.
Freigegeben, hat Claude Code ihn gebaut, und das Panel sagte „Done after 0:31“.
Die Statuszeile im Terminal lautete
⏵⏵ accept edits on (shift+tab to cycle): raus aus dem Plan-Modus, rein in den Modus, in dem Sitesmith arbeitet.
Schick danach einen normalen Auftrag, ohne Häkchen, und schau wieder auf die Statuszeile: Sie bleibt bei Accept Edits, denn deliverNext() prüft sie vor jedem Auftrag.
Was du jetzt hast
Ein Auftrag kann zuerst einen Plan verlangen, und der Plan erscheint in der Seite, dargestellt, mit einem Weg, ihn freizugeben, und einem, ihn zurückzuschicken. Unterwegs hat der Server gelernt, einen Teil von Claude Code zu bedienen, an den kein Hook herankommt: Er drückt die Tasten und liest das Ergebnis ab, und wenn das Ergebnis ausbleibt, hört er auf und sagt es dir, statt zu raten.
Jeder Dialog, den Claude Code während eines Laufs zeigt, hat jetzt seinen Platz in der Seite. Bisher hast du dir eine Site nach der anderen angesehen. Der nächste Teil lässt mehrere gleichzeitig arbeiten und zeigt dir, welche davon auf dich wartet.
Kommentare
Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.
Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.

