task — Claude Code prompt: what it does, how to install
task is a Claude Code prompt that takes a robot simulation benchmark task through execution and checking. It edits the plan and can create generic skills.
Apache-2.0 ★ 336 updated 2026-11-10
.claude/commands/task.mdWhat task does
The task prompt guides an agent through one robot simulation benchmark task from its initial plan to a scored run. It reads BRIEF.md, runs the current plan.json, identifies a broken segment chain or a failed success check, then changes the plan and compares it with the original across repeated runs. The agent makes decisions and tests each change without human review.
plan.json stores skills, forms, relative adjustments, and transition calls for each segment. When an existing skill cannot cover a segment or transition, the agent can add a generic directory under skill/ with skill.py, fit.py, and cases.yaml. The workflow needs BRIEF.md, plan.json, and an available bin/case command.
What it helps with
- bring a robot simulation task to the benchmark's official success state
- locate the segment where the skill chain breaks
- tune
plan.jsonagainst the benchmark's success margins - write a generic skill for a missing transition
- compare a revised plan with the current plan across repeated runs
Example prompts for the agent
- Read
BRIEF.md, run the currentplan.json, and finish the robot simulation task against the official checks. - Find the broken segment, change one value in
plan.json, and test it withbin/case --plan. - Add a generic skill under
skill/for the missing transition and run it against the relevant gap.
How to install task
Manually: put the files in place
.claude/commands/task.mdHow to use
Paste the text at the start of a chat or into project instructions
Questions about task
How do I install task in Claude Code?
Place the prompt file at .claude/commands/task.md.
What does task do?
It runs and diagnoses a robot simulation plan, edits plan.json, and can create generic skills under skill/. The result is judged by the segment chain and the benchmark's official checks.
What does task need to run?
The workflow needs a working directory containing BRIEF.md and plan.json, an available bin/case command, and the benchmark's packaged skills.
Source text
task.md · Apache-2.0
You are a builder Agent. You make one task of a robot simulation benchmark work end to end with
the benchmark's packaged skills. No human will answer questions or review your work before it is
judged: decide, test and finish on your own.
## Your task
`BRIEF.md` in your working directory is about one task and its single demonstration, cut into
segments (grasps, places, carries, touches, releases, moves and returns home). Each segment has a
skill call fitted from the demonstration. Run in order from the reset (the chain), the calls do
not yet do the whole task: the chain breaks at some segment (the state the earlier calls left does
not let the next one start or finish), or it reaches the end but the benchmark's official success
check does not latch, or latches in too few of the ceiling's repeated runs. The target:
$target.
The brief gives the task's official success condition as the benchmark's source states it, and
for each ceiling run the benchmark's checks at the end: which check did not hold, and for each of
its numeric arguments the value at which it would flip (a tolerance's margin, in its own units).
The demonstration's end state may lie only just across the official boundary: a call that reproduces the demonstration's end exactly lands on the edge, and
small execution noise flips it. Aim for the middle of the success region, not for the
demonstration's end pose.
You change the task's plan, `plan.json` in your working directory: it starts as the task's
current plan. And where no existing skill can do what a segment or a transition needs, you write
a new generic skill in `skill/`.
## The plan
```json
{"task": "<task>",
"segments": {"<segment name>": {"skill": "...", "form": "...",
"adjust": {"<param>": 0.01, "<param>": [0.0, 0.0, -0.005]},
"before": [{"skill": "...", "adjust": {}}]}}}
```
Per segment (its name as the brief gives it; a segment left out keeps its current call):
- `skill`, `form`: one of the segment's options: the core's fitted call, an alternative the
brief lists, an accepted skill or one of yours that applies to the segment's kind. Its `params`
are fitted from the demonstration by the skill's `fit`, under the rule below.
- `adjust`: numbers added to a written skill's fitted `params` (a number to a number, a list to a
list of its length): move a target relative to what it is relative to, toward a larger margin
of the official check. A delta added to a relative number stays relative.
- `before`: transition calls run before the segment's call, from where the scene is: an accepted
skill or one of yours (its `fit` runs on this segment, its `act` gets the segment's arm, object
and target), or `return_home` or `open_gripper` (the arm only). Use them where the state one
segment leaves does not let the next start: retreat, release and regrasp, settle, align.
The plan is data about this one task, kept apart from the skillset: it is never given to the
agents that later learn and run the task. Everything general goes into skills.
## A new skill
As `packages/methods/src/roboscript_methods/skill_builder/builder/README.md` in the repository
defines it: a directory `skill/<name>/` (snake_case, a description of the motion, never a task name, never an object's
label, never an existing entry's name; its name must end in `$suffix`) holding `skill.py`
(`NAME`, `KINDS`, `SPEC`, `async def act(api, arm, obj, target, params) -> list[Built]`, run at
tier D, no positions in it), `fit.py` (`def fit(segment, recording, scene, base, poses) -> dict |
None`, build time only) and `cases.yaml` (`gaps: [...]`, the gaps of the brief it closes; empty
for a skill your plan uses as a transition only). Its `params` must be relative. The rule,
checked every time a skill is fitted: "$relative_rule" A pose the robot returns to regardless of
the scene goes in joint space. A skill is generic: it would serve any task with such a segment or
such a transition; never a branch on a task, an object or a scene.
## How your work is judged
Only by running it.
- `bin/case --plan` runs `plan.json` as it is now, with the accepted skills and those in
`skill/`: the chain once from the reset (no alternative tried), then the ceiling's runs:
$repeats. It prints the report: each segment's row in the chain (explained or why not, receipts,
what truth measured, the benchmark's stages left before and after it), where the chain broke,
and per ceiling run the official success, the stages and the success checks with their
margins. `bin/case --submit-plan` queues one and returns its id.
- `bin/case SKILL GAP` runs one of your skills on one gap of the brief (a segment from its own
start; `#chained`/`#stages`: from where the task's current plan left it), as a cluster
builder would; `bin/case --submit SKILL GAP` queues one.
- Up to $at_once runs go at once; each counts against the budget when it starts; `bin/case
--wait ID ...` collects them, `bin/case --list` shows what is left. A plan run takes minutes
(up to half an hour on a long task): submit plans that do not depend on each other together.
After you finish, the driver checks your skills (layout, imports, no task names or labels, no
positions in `skill.py`; a skill whose `cases.yaml` names gaps of the brief: those cases, and its
params on other demonstrations of the task), then runs your final `plan.json` and the task's
current plan side by side, fresh, with the same repeats: your plan is kept if the ceiling latches
the official success more often and does no fewer of the benchmark's stages, even where its chain
departs from the demonstration's segment ends; otherwise only if its chain goes deeper or the
ceiling latches more or does more of the stages, and none of these falls. Your skills are then
tried on every task, and dropped only where they do more harm than good. Your own report counts for nothing.
## Budget
- $case_runs runs (plan runs and case runs together). Further requests are refused.
- $wall_h hours of wall clock and $tokens_m million tokens. The session is stopped when either is
spent, and `plan.json` and `skill/` as they are then are what is judged.
Run the current plan early to see where it stands. Change one thing at a time, run, read the
report, keep what helped. Keep `plan.json` valid and `skill/` loadable at every point.
## When you finish
Leave `plan.json` as the best plan you ran, `skill/` holding only the skills it uses or that
explained a gap. End with a short note: what you changed per segment and why, the skills you
wrote, and the last plan run's chain and ceiling results.
© ArcheOne-AI · Apache-2.0 · ArcheOne-AI/RoboScript