🧩 Product Specialization
The same pattern changes with the context. A shared core—identity, safety, format, tools— is rewritten when it becomes a chatbot, coding agent, search engine, Office app, voice, or CLI. Here you’ll see, using real prompts, what each product adds and what remove from the core.
Detailed content
One core, many contexts
Every product system prompt starts from a core inherited from Tracks 1 and 2: identity, safety, format, tools. What distinguishes a chatbot from a CLI is not a different core — it’s what each one adds (rules born from the channel) and what remove (rules that don't make sense there). Specializing means editing the core, not rewriting it.
What it is
Product specialization is the process of taking the core and applying two deltas: +context (rules that exist only because of the medium)
and −noise (core rules that the medium makes irrelevant or harmful). The claude-for-excel.md
remove "explain your reasoning" and add "the spreadsheet is the deliverable; the chat is the cover note".
Why learn
When you understand the core as a fixed foundation and the product as a pair of deltas, you stop "starting from scratch" with every project. You ask: what is the channel? what does it require? what does it prohibit? — and the prompt practically writes itself. That’s the difference between copying a prompt and port it for a new product.
✓ The product ADDS
- +Rules arising from the channel (citation ID, step narration)
- +Contract with the environment's API (Office.js, control_browser)
- +Specific output limits (≤100 words in the CLI)
- +Definition of the "actual deliverable" (spreadsheet, doc, speech)
✗ The product REMOVES
- −Markdown when the output is spoken or plaintext
- −Long explanations when the artifact is the result
- −"Ask for clarification" when the channel doesn't allow it (search engine)
- −Implementation details delegated by the user
💬 Chatbot — tone, refusal, persona
The chatbot is the "baseline" case: text rendered in a conversation, with no external environment. Its delta is almost entirely about tone and persona — what it sounds like, when it refuses, what personality it adopts. It’s the product where the core appears “purest” and where Tracks 1 and 2 have already given you almost everything.
What defines a chatbot in the prompt
Because the output is rendered and the conversation is multi-turn, the chatbot keep markdown, medium-length prose, and the option to ask for clarification. Your specialization is to calibrate the persona and the principled refusal (Track 1, "Rule with Why" pattern). It’s the starting point from which the other five products diverge.
The chatbot is the baseline, not the exception
When reading any product prompt, ask "what does this do different from a chatbot?". The answer is exactly the product delta. Voice removes markdown; CLI cuts length; the search tool replaces refusal with a silent search.
⌨️ Coding agent — autonomy, tool contract
The coding agent has an environment: files, a shell, a repository. Its dominant delta is autonomy ("keep going until you resolve it; don’t return early") and tool contracts rigid (Track 1, default "Tool Contract"). It’s the product that most adds to the core — because the environment is rich and dangerous.
You are an agent - please keep going until the user's query is
completely resolved, before ending your turn and yielding back to
the user. Only terminate your turn when you are sure that the
problem is solved.
- Never output more than one tool in a single step. Use consecutive steps instead.
- NEVER output any thinking tokens [...] before any tool. [...] to minimize latency.✓ A well-crafted agent delta
- +"Keep going until resolved" — explicit autonomy
- +Tool order and exclusivity ("one per step")
- +Search scope (cwd and children, in copilot-cli)
- +Declared parallelism ("read 3 files in one response")
✗ Antipattern
- −Autonomy without a stopping criterion → infinite loop
- −Tools without order → conflicting calls
- −Inherit “ask for clarification” from the chatbot without limits
- −Keeping long chatbot prose in a terminal
🔎 Search — source preservation, citation
The search engine browses the web and returns facts with provenance. Its delta is the pattern Source Preservation (Track 1, sheet 09): each piece of information carries an id, and the final answer cites it by that id — inline, next to each item, not at the end. And it remove the “ask for clarification” rule: in a search engine, ambiguity leads to more searching, not a question to the user.
# ID System
Each id [...] is formatted as {type}:{index} (e.g. tab:2, web:5).
- web: a source on the web
# Citing results:
- cite the results [...] by the id of the snippets rather than the document.
[...] your answer should cite the corresponding snippet inline next to
each item in the answer, NOT at the end of the answer.
# Clarification (delta − removido do núcleo)
- If the user's query is unclear, NEVER ask the user for clarification
in your response. Instead, use tools to clarify the intent.Citation by ID ≠ link in the footer
Comet treats the {type}:{index} as a first-class citizen of the entire prompt — tools, reasoning, and response all use the same id. This is Source Preservation taken to the limit: traceability becomes part of the grammar, not an appendix.
📊 Office + 🎙️ Voice — structured vs. extreme concision
Office and voice are both opposite ends of the format spectrum. Office (Excel/Word) produces a structured artifact — the deliverable is the spreadsheet or document, and the chat is just the "cover note." Voice speaks in real time: remove all Markdown, trim the length, maybe ask it to "talk quickly". Same core, mirrored formatting rule.
- Default to brevity. One tight paragraph
or a short list.
- Never paste walls of formulas or cell
values into chat. The spreadsheet is the
deliverable; chat is the cover note.
- Any derived number must be a formula
referencing source cells — never a value
you computed externally and typed.
=SUM(A1:A10) not "55".O claude-for-word.md echoes: "the document is the deliverable; chat is the cover note". Output = editable structure, not text in the chat.
You can hear and speak. You are chatting
with a user over voice.
This means that your response should be
concise and to the point, unless the
user's request requires reasoning or
long-form outputs.
# Voice
Your voice [...] should be warm and
engaging [...]. Please talk quickly.No Markdown, no lists, no code — everything becomes speech. The voice delta is subtractive: removes a visual format that the core would allow.
The same format rule, mirrored
Take the pattern Concision Budget (Track 1, sheet 07). In office settings, it becomes "be brief in chat why the work is in the document". In voice, it becomes "be brief why no one listens to a long paragraph, and without markdown why no screen.” Same principle, a different channel rationale — the module activity is exactly to compare these two phrasings.
▌ CLI + “what changes by product” table
The CLI runs in a terminal: output is plaintext, and space is expensive. Its delta is the output budget — an explicit numeric limit —
plus the reminder that everything will be printed on one command line. The copilot-cli.md opens with this and closes the module
with the Track 3.2 deliverable: the table comparing 3 patterns across products.
# Tone and style
* When providing output or explanation to the user, try to limit
your response to 100 words or less.
* Be concise in routine responses.
# Tool usage efficiency
* USE PARALLEL TOOL CALLING - [...] make ALL tool calls in a SINGLE response.
* Suppress verbose output (use --quiet, --no-pager, pipe to grep/head).
Remember that your output will be displayed on a command line interface.Table: what changes by product — 3 patterns
| Product | Concision Budget | Tool Contract | Source Preservation |
|---|---|---|---|
| 💬 Chatbot | Medium-length prose, markdown OK | Lightweight or nonexistent | Optional |
| ⌨️ Coding agent | Concise; brevity doesn't apply to sub-agents | Strong — order, exclusivity, parallelism | File / repo paths |
| 🔎 Search | Complete, cited answer | One tool per step | Central — inline id {type}:{index} |
| 📊 Office | Chat = cover note; artifact = the doc | Office.js; read-back after editing | Formula references source cell |
| 🎙️ Voice | Extreme — terminal-like tone, speak quickly | Minimum (search_web, terminate) | Verify with a new search |
| ▌ CLI | ≤100 words, plaintext | Parallel; cwd scope | Suppressed output (--quiet) |
This table is your deliverable
Reconstruct it yourself by reading the cited prompts: comet-browser-assistant.md, claude-for-excel.md, claude-for-word.md, voice-assistant.md, copilot-cli.md. Each cell should have line-level evidence. It’s the best proof that you read products by the delta.
Module Summary
- ✓Every product = shared core + two deltas: what it adds and what it removes
- ✓Chatbot is the standard: tone, persona, and principled refusal, without an environment
- ✓Coding agent adds autonomy + strict tool contract
- ✓Search elevates Source Preservation to the center: inline ID, and removes “clarify”
- ✓Office structures the artifact; voice removes markdown — mirrored format
- ✓CLI enforces an output budget (≤100 words) — deliverable: 6×3 table
Next: Module 3.3
Comparison matrix — one problem, four responses. Select 3 universal problems and map the solutions from 4 providers side by side, exposing trade-offs.