giladbarnea/soft-skills / plugins/soft-skills/skills/ai-to-delegated
ai-to-delegated
VerifiedBest practices for getting a step-function leap in productivity when working with other AI’s. Load `ai-to-delegated` before spawning a sub-agent, creating a team, talking to a teammate agent, or writing a doc likely read by other agents. Trigger words include “dispatch an agent”, “spawn a team”, and “fork the session to ...”.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 2.9 KB |
| briefing/examples.md | markdown | 12.7 KB |
| briefing/forked-context.md | markdown | 613 B |
| briefing/fresh-context.md | markdown | 1.6 KB |
| configurations/colloquium.md | markdown | 2.2 KB |
| configurations/external-advisor.md | markdown | 1.1 KB |
| configurations/hillclimber-watcher/protocol.md | markdown | 4.0 KB |
| configurations/hillclimber-watcher/watcher.md | markdown | 1.5 KB |
| configurations/pair-programming.md | markdown | 5.1 KB |
| configurations/research-fanout.md | markdown | 2.8 KB |
| coordination/budget-balancing.md | markdown | 1.0 KB |
| coordination/delegates.md | markdown | 4.9 KB |
| coordination/leading-leaders.md | markdown | 4.2 KB |
| coordination/many-hours-supervision.md | markdown | 3.6 KB |
| coordination/peers.md | markdown | 2.4 KB |
| planning/choose-configuration.md | markdown | 7.9 KB |
| planning/dispatch-outside-the-harness.md | markdown | 1.3 KB |
| planning/when-to-delegate.md | markdown | 8.7 KB |
briefing/examples.md
View on GitHub---
name: briefing-examples
description: Contrasting examples of preserving intent and context when requesting work from other agents.
---
# Briefing Examples
These illustrate [brief the bottom line, not the how](coordination/delegates.md#brief-the-bottom-line-not-the-how) and [fresh-context briefing](briefing/fresh-context.md). Read them when examples would help apply their principles.
<example-1>
<negative-example-1 why-bad="main agent shoots its own foot by limiting the delegate research scope">
User to main agent: "Why does Vercel claim their integrated version is beneficial?"
Main agent spawns a sub-agent and prompts it: "Research why Vercel claim their integrated version is beneficial (edge runtime, seamless DX, zero-config, billing, monitoring, tight coupling to `vercel` CLI / dashboard / functions)."
</negative-example-1>
<positive-example-1 why-good="main agent declares the bottom line added value it needs without prescribing what and how to do it">
User to main agent: "Why does Vercel claim their integrated version is beneficial?"
Main agent spawns a sub-agent and prompts it: "I want to know why Vercel claim their integrated version is beneficial."
</positive-example-1>
</example-1>
<example-2>
Example 2 settings: the `load-context` skill instructs to read CLAUDE.md, ARCHITECTURE.md, docs/webserver/API.md, docs/data/architecture.md, server/api.py, and server/db.py.
<negative-example-2 why-bad="main agent fails to leverage the harness and instead prescribes what to do; moreover it makes the same scope-narrowing mistake as in example-1">
User to main agent: "/skill:load-context domain: acme, subdomain1: the public REST API, subdomain2: the data layer. I want to plan a view layer with you later, so let’s understand the foundations."
Main agent spawns a sub-agent and prompts it: "Read CLAUDE.md, ARCHITECTURE.md, docs/webserver/API.md, docs/data/architecture.md, server/api.py, server/db.py, and summarize how the REST API and data layers work. Cover how function `server/api.py:from_db` fetches the data by calling the `server/db.py:get_data` function, and how [... proceeds to prescribe ironically specific locations to “discover”]"
</negative-example-2>
<positive-example-2 why-good="main agent recognizes the work can be distributed concurrently, shortly shares the wider context (the “why”), forwards the user’s context levers — keeping the shared domain and handing each agent one of the two subdomains rather than dropping them — and does not micro-manage the agents with how-exactly instructions">
User to main agent: "/skill:load-context domain: acme, subdomain1: the public REST API, subdomain2: the data layer. I want to plan a view layer with you later, so let’s understand the foundations."
Main agent fans out research scope horizontally to two parallel sub-agents and prompts them: "The user and I are planning a new view layer, so we need a thorough understanding of the foundations. [to one agent] /skill:load-context domain: acme, subdomain: the public REST API [to the other agent] /skill:load-context domain: acme, subdomain: the data layer. [to both] Study your subdomain deeply and exhaustively."
[Main agent receives the two independent sub-agents’ responses, thinks hard to synthesize them]
Main agent responds to user: "I have deep understanding of both layers and their relationships. What did you have in mind?"
</positive-example-2>
</example-2>
<example-3>
<negative-example-3 why-bad="main agent prescribes how to review its work, repeats the peer-review skill’s contents. moreover, agent puts words in the user’s mouth, who did not emphasize any specific aspects.">
User to main agent: "Spawn a sub-agent to review your work."
Main agent spawns a sub-agent and prompts it: "Load the load-project-context and peer-review skills. The user asked me to <user request>. I’ve made an attempt to complete the task. Review my work (the current main dirty tree). do you spot any blindspots, bugs, or opportunities to achieve the same results with a simpler, collapsed approach? if you find any, please suggest a specific alternative implementation that is simpler and achieves the same results."
</negative-example-3>
<positive-example-3 why-good="main agent writes as simple a prompt as possible. adds only what is necessary to get the reviewer up to speed. does not put words in the user’s mouth. does propagate the user’s explicit emphasis">
User to main agent: "Spawn a sub-agent to review your work. I’m mostly interested in blindspots in the implementation, bugs, and opportunities to get the same results with a simpler, collapsed approach."
Main agent spawns a sub-agent and prompts it: "Load the load-project-context and peer-review skills. The user asked me to <user request>. I’ve made an attempt to complete the task. Review my work (the current main dirty tree). Do you spot any blindspots, bugs, or opportunities to achieve the same results with a simpler, collapsed approach?"
</positive-example-3>
</example-3>
<example-4>
Example 4 settings: the user and the main agent designed an experiment to test whether a Pi session converted to Claude Code keeps Claude’s signed thinking blocks. Two independent prerequisites stand in the way: a logging proxy that proves a beta header reaches the API, and a Pi-to-Claude session converter.
<negative-example-4 why-bad="main agent does both prerequisites itself, one after the other; its own context window fills with proxy logs and converter debugging before the real experiment even starts">
User to main agent: "Ok, let’s do the experiment."
Main agent builds and debugs the proxy, then writes and tests the converter, then starts the experiment with a crowded context window.
</negative-example-4>
<positive-example-4 why-good="main agent recognizes two independent, hands-on prerequisites standing between the session and its real goal, suggests forking itself once per prerequisite, and briefs each fork with only its assignment and the proof it must bring back">
User to main agent: "Ok, let’s do the experiment."
Main agent responds to user: "Two things must exist first: the proxy and the converter. They don’t depend on each other. Should I fork myself into two and build them in parallel?"
User to main agent: "Yes."
Main agent forks itself twice and prompts the forks: "[to one fork] You are the fork for task 1: prove the beta header and set up the proxy. [to the other fork] You are the fork for task 2: write the Pi-to-Claude converter. [to both] Bring back proof that it works on a real run, or the specific blocker."
[The forks build and prove the prerequisites; the main agent’s window stays reserved for the experiment.]
Main agent responds to user: "Both prerequisites are ready and proven. Let’s run the experiment."
</positive-example-4>
</example-4>
<example-5>
<negative-example-5 why-bad="main agent restates to the fork what the fork already holds: the human’s question, the estimate, the reason for asking, and where to look. It also dictates the report format">
[Human to main: i want to know why does rpiv-todo collapse its panel to two lines instead of hiding it […]? fork yourself to answer this "why 2" question]
Main agent forks itself and prompts the fork: "You are the fork. Your assignment: answer "why 2". Why does rpiv-todo collapse its panel to two lines instead of hiding it […]? The human estimates 50-50. Why we need it: […]. Sources: the fresh clone at ./rpiv-mono […] and every issue and PR ever opened about rpiv-todo […]. Deliver to main (me) one short report: the verdict (a or b), your confidence, and the evidence with exact citations (commit SHAs, file:line, issue/PR links, quotes) […]"
</negative-example-5>
<positive-example-5 why-good="if you know it, the fork knows it. Main agent gives only the assignment and what it needs back">
[Human to main: i want to know why does rpiv-todo collapse its panel to two lines instead of hiding it […]? fork yourself to answer this "why 2" question]
Main agent forks itself and prompts the fork: "You are the fork. Your assignment: answer "why 2". I need cited evidence and transparency of your confidence either way."
</positive-example-5>
</example-5>
<example-6>
<negative-example-6 why-bad="main agent copies a rule from its memory into the fork’s prompt. The fork inherits the same memory, so the rule is already in its context window">
[Main reads with a memory tool to never use `compress` unless human explicitly asks]
Main agent forks itself and adds to the fork’s prompt: "Never use the `compress` tool unless the human explicitly asks."
</negative-example-6>
<positive-example-6 why-good="if it's in your context window, it's in the fork's context window. Main agent adds nothing">
[Main reads with a memory tool to never use `compress` unless human explicitly asks]
Main agent forks itself and writes nothing about `compress` in the fork’s prompt.
</positive-example-6>
</example-6>
<example-7>
<negative-example-7 why-bad="main agent adds a guardrail and dictates the report format without a concrete necessity. The user asked neither, and main itself read the question correctly without them. So would the fork">
User to main agent: "ask the fork where's the best place in pi-extensions/*.md (not subdirs) to minimally instruct to check that rich README content (images, assets, html) renders on GitHub, npm, and pi.dev"
Main agent to the fork: "Which Markdown file directly in ~/dev/pi-extensions/ (top-level *.md only, not subdirectories) is the best place for this minimal instruction? Reply with the file, the spot in it, and why. Do not edit it yet."
</negative-example-7>
<positive-example-7 why-good="main agent relays the question with the user's own constraints and adds nothing without proven justification">
User to main agent: "ask the fork where's the best place in pi-extensions/*.md (not subdirs) to minimally instruct to check that rich README content (images, assets, html) renders on GitHub, npm, and pi.dev"
Main agent to the fork: "Which Markdown file directly in ~/dev/pi-extensions/ (top-level *.md only, not subdirectories) is the best place for a minimal instruction to check that rich README content (images, assets, raw HTML) renders on GitHub, npm, and pi.dev?"
</positive-example-7>
</example-7>
## Choosing an Implementer–Reviewer Team
<team-example>
Team Example settings: at the session’s start the user ran `/skill:load-context domain: acme, subdomain1: the public REST API, subdomain2: the data layer`; the main session explored the code, and the user approved a plan to add rate limiting to the public REST API.
<negative-team-example why-bad="main agent burns its own context shuttling the diff and the feedback back and forth — dives into the sub-agent’s work and clogs its own context window worse than doing the task solo would have, acts as a reviewer when biased">
User to main agent: "Great, go ahead and build it."
Main agent spawns one sub-agent to implement; when it returns the diff, studies and reviews it; relays the review the sub-agent; and keeps ferrying revisions until the diff settles.
</negative-team-example>
<positive-team-example why-good="main agent picks a team because the adversarial iteration is synergistic, replicates the user’s context levers verbatim — including the domain and the subdomains the user specified when loading the context skill — has the reviewer also load `peer-review`, declares only the bottom line it wants, and stays out of the loop while they converge">
User to main agent: "Great, go ahead and implement the plan."
Main agent spawns an implementer–reviewer team and prompts them: "/skill:load-context domain: acme, subdomain1: the public REST API, subdomain2: the data layer, then load `ai-to-leader` and the peer conduct in `coordination/peers.md`. You are an implementer–reviewer team. Here is the user’s original message to me, verbatim, for the bigger picture: {the-user-message-describing-the-task}.
[to the implementer] Implement the plan, and ping your teammate when you think you’re done.
[to the reviewer] Also load `peer-review`, and review your teammate’s work when it pings you.
[to both] The user and I finalized a plan to add rate limiting to the public REST API — here it is: {the plan}. Build it and tear it apart between yourselves until you’re confident it’s the simplest working, correct solution faithful to the plan."
[The team implements and reviews live, converging without the main agent in the loop; the main agent receives the finished, reviewed result.]
Main agent responds to user: "Done — implemented and adversarially reviewed between the two of them. Here’s what landed: …"
</positive-team-example>
</team-example>
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |