implement skill
✓ VerifiedFills in stub modules of a pipeline emitted by rote by writing code that honors the IR contract and verifies it with rote run.
- GitHub stars
- 8
- Files
- 2
- Last commit
- Nov 11, 2026
- License
- Apache-2.0
- Allowed tools
- —
What does the implement skill do?
implement fills in stub modules of a pipeline emitted by rote by writing code that honors the IR contract and verifies it with rote run.
Summary generated from the skill's SKILL.md.
About the implement skill
Developers using rote to build automated pipelines can use this skill to transform scaffolded code into functional applications. When running rote emit or rote compile, the system produces stub modules that raise errors instead of executing logic. This skill identifies those stubs by reading the pipeline IR contract and replaces them with real code that honors specific inputs, outputs, and constants. It is designed for engineers working with runtimes like Cloudflare, Inngest, DBOS, or Temporal.
The process involves locating the emitted directory, building a task list from the unimplemented stubs, and reading the detailed requirements from the pipeline YAML and source skill files. The skill writes implementation code only in user-owned files, ensuring that rote-owned files remain untouched and ready for regeneration. After writing the logic, it verifies the entire pipeline by executing rote run with a provided input to ensure end-to-end success.
What an agent can do with it
- 1Wire up API callsA developer can ask the agent to replace placeholder stubs with actual network calls to external vendor services.
- 2Verify pipeline executionAfter writing code, the agent can prove the pipeline works by running it through the rote CLI.
- 3Synchronize code with IR contractsThe agent can ensure that all function signatures and constants match the requirements defined in the pipeline configuration.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the implement skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the implement skill in Plugin
/plugin marketplace add trevhud/rote /plugin install rote@rote
Install the implement skill in Claude Code
~/.claude/skills/implement/SKILL.md
$ npx degit trevhud/rote/plugin/skills/implement ~/.claude/skills/implementInstall the implement skill in Claude Code (project)
.claude/skills/implement/SKILL.md
$ npx degit trevhud/rote/plugin/skills/implement .claude/skills/implementInstall the implement skill in Codex
~/.agents/skills/implement/SKILL.md
$ npx degit trevhud/rote/plugin/skills/implement ~/.agents/skills/implementInstall the implement skill in Gemini CLI
~/.gemini/skills/implement/SKILL.md
$ npx degit trevhud/rote/plugin/skills/implement ~/.gemini/skills/implementInstall the implement skill in Claude.ai
npx degit trevhud/rote/plugin/skills/implement implement && zip -r implement.zip implement # claude.ai → Customize → Skills → + → Create skill → Upload a skill → implement.zip
Automated checks
Ran Nov 15, 2026Full report →Passed our automated checks. That is not a security audit: read the scripts before you let an agent run them. How checks work
- Source repository linked and reachabletrevhud/rote/plugin/skills/implement is public and reachablegithub.com/trevhud/rote/tree/HEAD/plugin/skills/implement ↗Pass
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit 2026-11-11github.com/trevhud/rote/commits ↗Pass
- No download-and-run or credential theft in scriptsNo scripts in the skill folderPass
- No hidden instructions in SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/trevhud/rote/blob/HEAD/plugin/skills/implement/SK ↗Pass
- Pre-approved tools are scopedNo pre-approved tools; the agent asks before using onegithub.com/trevhud/rote/blob/HEAD/plugin/skills/implement/SK ↗Pass
- SKILL.md follows the Agent Skills formatValid name and description; says when to use it; 273 linesgithub.com/trevhud/rote/blob/HEAD/plugin/skills/implement/SK ↗Pass
SKILL.md
View on GitHubImplement the stubs of an emitted pipeline
rote emit and rote compile produce a runnable app whose deterministic
steps are scaffolds: every pure_function and external_call node that
has no real implementation yet gets a stub that fails on call. Your job is
to replace those stubs with working code that honors each node's IR
contract, then prove the pipeline runs end to end with rote run.
You write code only in user-owned files. rote owns everything else and regenerates it on the next emit.
The CLI ships on PyPI as rote-cli. Invoke it as
uvx --from rote-cli rote <args>, which works on every release (the
uvx rote-cli shorthand needs a release newer than 0.14.0). Running a
Python app needs that runtime's extra in the same environment, because
rote run executes it with its own interpreter: uvx --from 'rote-cli[dbos]' rote run ... for DBOS,
'rote-cli[temporal]' for Temporal. If the user is inside a rote
checkout with a .venv, .venv/bin/rote works too.
1. Locate the emitted dir and its IR
The user names the directory, or it is the most recent --out in the
conversation. Accept any of:
- a
rote compile --outdir: IR atcompiled/pipeline.yaml, apps underruntime/<target>/(ask which target if there are several); - a bare emitted runtime dir.
Find the runtime from its marker files, in this order: wrangler.jsonc
= cloudflare, src/inngest/ = inngest, dbos-config.yaml + main.py =
dbos, dbos-config.yaml alone = dbos-ts, workflow.py + activities.py
= temporal, main.py alone = python.
Find the IR the way rote run does: <dir>/pipeline.yaml, then
<dir>/../../compiled/pipeline.yaml when the parent is named runtime,
then <dir>/../pipeline.yaml. If none exists, ask the user for it. Do not
implement from the emitted code alone: the IR is the contract, and the
stub docstrings are a lossy rendering of it.
Confirm the directory, runtime, and IR path with the user before editing.
2. Build the TODO list
Get the list from rote rather than by guessing. Re-emitting into the same directory is safe (see section 6) and reports what is still a stub:
uvx --from rote-cli rote emit <pipeline.yaml> --runtime <runtime> --out <dir> --json
Read three keys from the JSON:
unimplemented_stubs: absolute paths of modules that still have a stub function. This is the TODO list. A module drops off it once none of its functions is a stub. In Python that means no function raises with the[rote stub]sentinel and none has a body that is onlyraise NotImplementedError. In TypeScript it means[rote stub]appears nowhere outside a comment. The full rule, with examples, is in references/runtimes.md.preserved_new_files:.newsiblings parked next to files the user already edited. Handle these before anything else (section 6).contract_findings: IR promises the implementations beside thepipeline.yamlbreak (missing function, wrong signature, syntax error). Treat anyerroras a defect to fix.
The list covers every runtime, temporal included. Files under
extracted/ that are not on it are rote's, even when they sit right
next to the stubs (see section 5).
3. Read each node's contract
For every stub, find every node whose impl points at it (several nodes
can share one Python function). Read from pipeline.yaml:
| Field | What it tells you |
|---|---|
kind |
pure_function = no I/O, deterministic. external_call = network I/O |
description |
what the step does, in the compiler's words |
input / inputs |
the parameter names, their types, and where each value comes from |
output |
a single type name (return that value bare) or a key-to-type map (return a dict with exactly those keys) |
constants |
values lifted from the source skill: thresholds, IDs, queries |
mandatory |
the workflow always calls this node, so never make it conditional |
timeout / retry |
the runtime retries, so your code should raise on failure, not swallow it |
source.section |
the heading in the original SKILL.md this node came from |
Then open the source skill: source_skill in the IR is a path relative
to the pipeline.yaml. Read the section each node names. It holds the
detail the IR summarized: column names, the exact rule behind a
threshold, report formatting. When the description and the source
disagree, the source skill is what the user ran in production. Follow it
and tell the user about the gap.
Work out the data shapes by tracing the edges. A parser's input is its upstream fetcher's output, and the final node's input is every parser's output. Implement the producer and consumer of each edge against the same shape. The exact call shape (keyword arguments for Python, one input object for TypeScript) is in references/runtimes.md. Read the generated call site in the workflow file to confirm it.
Two rules that are easy to get wrong:
- Constants arrive with every call, on every runtime. Each node's
IR
constantsare passed next to its inputs: as keyword arguments on dbos, python and temporal, and as keys of the one input object on cloudflare, inngest and dbos-ts. Read them from there and never hard-code a value. A hard-coded constant turns the pipeline.yaml value into dead config, so editing it changes nothing. A Python function several nodes share receives the calling node's values, so take each constant as a keyword parameter. Every calling node is listed in the stub's docstring with its constants. A constant every caller sends is a required parameter with no default: writingchannel_id: str = "C0EXAMPLE000"orfixed_queries or []repeats the IR value, so if the constant ever stops arriving the function silently falls back instead of raising. Only a constant that some callers omit gets a default. Each TS stub serves one node, and its doc comment lists that node's constant keys. Declare them in the input type, ortscrejects the call. Confirm against the generated call site. - Optional pipeline inputs may be absent. An
input_schemafield not inrequiredcan be missing or null. Apply the default the schema's description names (for example "omit to default to today") inside the node that consumes it.
4. Write the implementations
Write real code. No placeholders, no TODO, no sample data presented as
real output, no silent fallbacks: a failure should raise with a message
that names the node, because the runtime's retry and error reporting
depend on it.
- Keep the function name and module path exactly as the IR's
impl(or the TS export the workflow imports) names them. The workflow file imports them by that name. pure_function: deterministic, no network, no clock reads unless the contract asks for one (a "defaults to today" input is such a case). Return the declared output keys and nothing the contract does not promise.external_call: call the vendor API directly with its official SDK or plain HTTP. Read credentials from environment variables, name them in the module docstring, and fail with a clear error when one is missing. Look up the vendor's current API docs before writing the call. Do not rely on memory for endpoints or SDK shapes. Honor the IRtimeouton the request itself where the runtime has no per-step timeout (DBOS, python).- An
external_callwith anmcp:binding is not a stub. rote emits a working MCP call for it. Leave it alone. - Add any new dependency where the emitted app declares them
(
requirements.txt,package.json) and tell the user. - On the TypeScript runtimes,
src/types.tsdeclares each type an agent loop's output names but the IR never defines (InvoiceResult), asJsonValue. Narrow it to the real shape once, an interface or an import of your own, before typing a node that reads that output. rote keeps your edit on re-emit.rote emitprints onenote:line per such type.
If a node needs credentials or a service nobody has here, ask the user how they want to proceed. When they want a local run anyway, implement the real client and select a local fixture source with an explicit environment variable (for example a directory of captured responses), so production keeps the real path and the fixture path is visible in the code. Say in your summary which nodes ran against fixtures.
5. Never edit rote-owned files
These are regenerated on every emit. Edits there are either overwritten or get parked as conflicts, and some are byte-compared in rote's own tests:
- the workflow and wiring:
main.py(dbos, python),workflow.py,activities.pyand__init__.py(temporal),src/workflow.ts,src/index.ts,src/main.ts,src/inngest/*; - generated agent-loop modules on the TypeScript runtimes:
src/extracted/<agent_loop node id>.ts. They sit beside the stubs but are working code that binds the loop's tools and calls the inference helper; - the verbatim runtime helpers:
extracted/_rote_mcp.py,signatures/_rote_inference.py,src/extracted/_roteMcp.ts,src/signatures/_roteInference.ts; - judge modules (
signatures/*,src/signatures/*) andextracted/__init__.py; - config and metadata:
dbos-config.yaml,wrangler.jsonc,tsconfig.json,manifest.json,.dev.vars.example(copy it to.dev.varsfor local secrets),README.md, and.rote-manifest.json(never edit or delete it, because it is how re-emit knows which files are yours).
If the bug is in one of these files, the fix belongs in the IR or in rote itself. Stop and tell the user. Do not patch emitted code.
Your files are exactly the stub modules on step 2's list, plus any new modules you import from them.
6. Respect re-emit
rote's emit writer records the hash of every file it writes in
.rote-manifest.json. On the next emit it overwrites a file only if it
is still exactly what rote wrote. A file you edited is preserved, and the
fresh rote output lands next to it as <name>.new.
- A
.newsibling of a file you implemented is usually the regenerated stub. Read the diff: if only the docstring changed, delete the.new. If the contract changed (new parameter, new output key, new constant), update your implementation to match, then delete the.new. Expect it back after every emit: rote keeps parking the fresh stub beside a file you own, so a.newthat is only the stub again is safe to delete each time. - A
.newnext to a rote-owned file means someone edited that file. Show the user the diff. The usual answer is to move their change somewhere it belongs and accept the fresh file. - For dbos, python and temporal, emission copies
extracted/<module>.pyfrom beside thepipeline.yamlinto the runtime dir verbatim. When that directory exists, it is the source of truth: write the implementation there and re-emit, so every Python runtime emitted from this IR gets the same code.
7. Verify with rote run
Always pass --input. Without it, rote run derives an input from the
source skill with a model call, which spends tokens and prompts for
confirmation. Build the input from the IR's input.input_schema.
Every HITL gate needs a resume payload up front, one --signal per gate,
shaped like the gate's output in the IR:
uvx --from 'rote-cli[dbos]' rote run <dir> --json \
--input '{"report_date": "2026-07-18"}' \
--signal manual_data_provided='{"sorter_metrics": [], ...}'
rote run refuses to start while any module on step 2's list is still a
stub, and names them. Fix those first. Pass --allow-stubs only when
the run cannot reach the remaining stubs (they sit on a branch this input
does not take), and say so in your report. A stub the run does reach
still raises.
A zero exit with "error": null and an output keyed by the exit nodes
is a pass. On failure, read the error, fix the implementation, and run
again. If the failure is inside a rote-owned file, follow section 5.
Also run the project's own checks where they exist: the emitted test
suite if there is one, tsc --noEmit after npm install for TypeScript
runtimes.
8. Report
Tell the user, in this order:
- what
rote runreturned (pass or fail, wall time, and the output's shape); - each implemented node: what it calls, which credentials it reads, and whether it ran against real services or fixtures;
- any contract gaps you found (description vs source skill, an output key no producer can supply) and anything left unimplemented, with why;
- new dependencies and environment variables they need to set before deploying.
Files in this skill
2implement skill questions
How do I install the implement skill in Claude Code?
Run npx degit trevhud/rote/plugin/skills/implement ~/.claude/skills/implement. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the implement skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.
What should I do if the emitted app has stubs that raise a [rote stub] error?
You should use the implement skill to replace those stubs with working code that honors the node's IR contract, then verify with rote run.
How do I handle constants in the implementation?
Constants arrive with every call and should be treated as parameters (keyword arguments in Python, keys in an input object in TypeScript) rather than being hard-coded.