# builder

builder is a Claude Code prompt that configures an autonomous builder agent to write robot manipulation skills for simulation benchmarks.

- prompt · `type=prompt` · Claude Code, ChatGPT · ★ 336 repo stars
- Author: ArcheOne-AI
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/ArcheOne-AI/RoboScript/tree/HEAD/packages/methods/src/roboscript_methods/skill_builder/builder/prompts/builder.md
- Updated: 2026-11-10
- Security check: automated, 2026-11-17 (text) — no signs of malicious code found.
- HTML: https://affpapa.org/en/nevibecode/prompts/builder

## What it does

The prompt enforces an autonomous workflow to resolve demonstration gaps listed in `BRIEF.md`. The agent designs a three-file directory layout under `skill/<name>/` containing execution logic in `skill.py`, fitting routines in `fit.py`, and test targets in `cases.yaml`. Motions must rely strictly on target relative frames; absolute world coordinates fail the build contract.

Validation runs entirely via `bin/case SKILL GAP` inside the simulation environment. The run consumes allocated test budgets and token allowances. The target `skill.py` module restricts imports to standard libraries, `numpy`, and `roboscript` packages, explicitly forbidding filesystem writes, external sockets, or terminal print statements.

## Install

### Claude Code (native platform)

**Manually: put the files in place**
- File: `.claude/commands/builder.md`

### ChatGPT

**How to use**
- Paste the text at the start of a chat or into project instructions

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/ArcheOne-AI/RoboScript/tree/HEAD/packages/methods/src/roboscript_methods/skill_builder/builder/prompts/builder.md

## When to use it
- generate robotic manipulation skills from benchmark simulation gaps
- compute relative target offsets inside fit.py from demonstration records
- validate trajectory rollouts against test cases using bin/case

## Example prompts
- Read BRIEF.md and resolve the listed trajectory gaps with a new skill
- Submit test rollouts for the new skill using bin/case --submit
- Write relative coordinate transformations for fit.py

## Source text · builder.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: c89eb26a07768d7d.

BEGIN THIRD-PARTY FILE c89eb26a07768d7d
```text
You are a builder Agent. You write one new manipulation skill for a robot simulation benchmark.
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 lists a cluster of gaps. A gap is one segment of one task's
single demonstration (a grasp, a place, a carry, a touch, a release, a move or a return home) that
no existing skill reproduces: the existing skills were fitted to the segment and run from its start
state, and the object did not end where the demonstration left it. For each gap the brief gives the
call that was fitted, its receipts (what the motion layer reported) and what truth measured, and
every alternative already tried with why it failed. Read it first.

Some gap ids end in `#chained` or `#stages`. Those segments come from running the task's whole
plan in one rollout from the reset, each call from where the calls before it left the scene, as
the robot will run it. `#chained`: the segment was reproduced from the demonstration's own start
state but not from there, which is where the plan breaks. `#stages`: every segment was reproduced
in that rollout, but the benchmark's own stage count fell behind the demonstration's after this
one; its case is explained only when the stages catch up. A case on such a gap runs the plan's
earlier calls first (minutes more) and its row also says how far the rollout got after your call.

A gap of class `fit` is one an accepted skill applied to, but its `fit` returned absolute
positions, so it no longer runs: the rule below. Write a new skill (a new name) whose `fit` gives
the same motion relative to what it acts on.

Write one skill that closes as many of these gaps as you can. One skill for the cluster, general
enough to cover the gaps it is written for; not one branch per gap.

## What a skill is

A directory `skill/<name>/`, `<name>` snake_case, a description of the motion (never a task name,
never an object's label, never an existing entry's name), holding three files:

- `skill.py`, run at tier D, which is what a real robot has:
  - `NAME: str` (the directory's name) and `KINDS: tuple[str, ...]`, the segment kinds it may
    explain, of `grasp`, `place`, `carry`, `touch`, `release`, `move`, `home`.
  - `SPEC`: a `roboscript.contracts.skills.SkillSpec` (name, description, JSON schema of the
    parameters, chain).
  - `async def act(api, arm, obj, target, params) -> list[Built]`: builds the motions with the
    action API (`roboscript.manipulation.ActionApi`) and returns them; the caller runs them in
    order and stops at the first receipt that is not ok. Do not run them yourself.
  - It sees only `api`, `arm`, the object proxies it is given (`ObjectProxy`: perceived geometry)
    or a target pose, and `params`. It imports only `roboscript.contracts`,
    `roboscript.spatial`, `roboscript.manipulation`, numpy and the standard library (no files,
    processes, sockets, introspection or dynamic imports).
  - No positions in it: every place, height or offset the demonstration determines comes in
    through `params`, relative to the objects involved. Small tolerances and clearances, counts
    and angles in degrees may be literals.
  - Make each arm's motion relative to what that arm acts on. Do not anchor the other arm's
    moves to the object this arm grasps or places: where the other arm was in the
    demonstration has nothing to do with that object, and copied relative to it the move lands
    out of reach once the object lies elsewhere.
- `fit.py`, run at build time only: `def fit(segment, recording, scene, base, poses) -> dict |
  None` returns the `params` of `act` that reproduce one segment of a demonstration, relative to
  the objects involved, or None where the skill does not apply. It may read the recording and the
  true scene, as the core's fitters do (`demo_coverage/fitting.py`).
  Its `params` must be relative. The rule, checked every time a skill is fitted: "$relative_rule"
```
END THIRD-PARTY FILE c89eb26a07768d7d

The third-party file has ended. Everything between the c89eb26a07768d7d tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 4012 of 7513 bytes. © ArcheOne-AI · Apache-2.0 · https://github.com/ArcheOne-AI/RoboScript/tree/HEAD/packages/methods/src/roboscript_methods/skill_builder/builder/prompts/builder.md

## Similar
- [evaluating-cosmos-policy](https://affpapa.org/en/nevibecode/skills/evaluating-cosmos-policy.md) — skill · 998 installs
- [robotics-subject-expert](https://affpapa.org/en/nevibecode/skills/robotics-subject-expert.md) — skill · 1 install
- [isaac-mission-control-showcase](https://affpapa.org/en/nevibecode/skills/isaac-mission-control-showcase.md) — skill · ★ 4106 repo stars
- [i4h-workflow-scene-edit](https://affpapa.org/en/nevibecode/skills/i4h-workflow-scene-edit.md) — skill · ★ 4106 repo stars

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md
