code-yeongyu/oh-my-openagent / packages/omo-senpi/skills/ultrawork
ultrawork
VerifiedThe binding ultrawork-mode directive. This file IS the directive; read it only when ultrawork mode is requested and the directive is not already in the conversation.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 31.7 KB |
| references/gpt.md | markdown | 11.9 KB |
references/gpt.md
View on GitHub<ultrawork-mode>
Ultrawork mode is on. Begin this turn's reply with this line, alone and exactly:
`ULTRAWORK MODE ENABLED!`
Ultrawork raises the standard of proof and leaves the rest of your instructions in force. Your system prompt still decides how you read the request, investigate, report, and involve the user. This directive adds a registered goal, a durable notepad, evidence from the real surface, cleanup, commits, and a review gate. Where it is silent, your system prompt applies.
# What done means
The user's request works end to end and you can show it: the changed behavior was run through its real surface, the artifact is captured, the tests the repository keeps for that behavior still pass, and everything the run started has been torn down. A green test suite shows that unit-level contracts hold. Only the run shows that the behavior the user asked for works.
# Size the work once
Decide the tier before the first change and record it in the notepad with a one-line reason. It only goes up.
Your change set is what this session itself edits or runs. Work handed to another session sizes that session's process, and launching it is LIGHT however large the delegated project is.
LIGHT is the default: the deliverable follows a known pattern with no open design decision. It needs one or two success criteria (the happy path and the riskiest edge), one real-surface proof, and a self-review recorded in the notepad.
HEAVY applies when the change set hits a fact you can point to: a new module, layer, domain model or abstraction; auth, security, session handling or permissions; building or changing an external integration (calling an existing API is not one); a database schema or migration; concurrency, transaction boundaries or cache invalidation; a refactor that crosses domain boundaries; or the user asked for care or for a review of this work. It needs three or more criteria (the happy path, edges, a named adjacent regression, an adversarial case), each with its own scenario.
When unsure, take LIGHT. If a HEAVY fact appears mid-task, move up then and add what the LIGHT path skipped. The tier sizes the proof for what this run actually delivers: both tiers capture evidence and tear down what their QA started, and neither invents a scenario the deliverable has no real counterpart for.
# Start
1. Task resources. Before the first task command, create one run directory with `RUN_TMP=$(mktemp -d)` and pass `TMPDIR="$RUN_TMP" NODE_COMPILE_CACHE="$RUN_TMP/node-compile-cache" BUN_RUNTIME_TRANSPILER_CACHE_PATH="$RUN_TMP/bun-transpiler"` to every command and child. At the end, after the processes you own have exited, remove the directories you own. Shared caches stay, and so does a worktree an open PR still needs.
2. Notepad. Run `NOTE=$(mktemp -t ulw-$(date +%Y%m%d-%H%M%S).XXXXXX.md)` and state the path. It holds what the todo list cannot: the success criteria, the approach with the reasons behind it, and a running log. Append to the log as you work and never rewrite it: each finding with its file and line, each decision, each command that mattered, each artifact path, each lesson. The steps themselves live in the `todo` list and nowhere else. The notepad outlives the context window. After a compaction, or whenever your own earlier steps are no longer visible, read the whole notepad and the todo list before anything else and resume from the last log entry.
3. Skills and memory. Name in the notepad the skills whose workflow this task will run, with one line of reason each, and open a skill's body only when this session runs it. Consult memory before asking the user. Save durable facts, decisions, corrections, each regression a check caught, and each QA scenario with its invocation as they emerge.
4. Goal. Once you have read what the request points at and can state what the user wants and why, register the goal with `create_goal`, passing only `objective`. Write it at full detail: the end state the user wants, the tier with its reason, and each success criterion with its exact scenario (the literal command, page action or payload), the one observable that decides pass or fail, and the artifact it will capture. If this surface has no goal tool, open your reply with a `# Goal` block and treat it as binding. A goal has no budget.
5. Plan. Put the ordered steps in the `todo` list, one item per action, and keep it current as you go. Write the approach and its reasons into the notepad, or into `.omo/plans/<slug>.md` when the plan has to stand alone as a document. Add one cleanup item at creation for every worktree, cache directory and QA resource (a process, a terminal session, a browser context, a port, a container, a temporary path), and close it only after you have read back that the resource is gone.
When a ulw-loop pointer or the ulw-execute skill comes with this directive, that contract owns the goal, the notepad and the plan, and its final gate replaces the review gate below. Under ulw-execute its workers do the change and run steps, and you verify the evidence they capture.
# Work through each criterion
1. Read what already proves the area. Existing tests are the behavior of record, so note in the notepad what they pin. A test that is wrong before your change is a finding to report, and it is never edited to pass.
2. Reproduce a bug before you fix it and keep the failing output.
3. Make the smallest production change that meets the criterion, and update the tests your change makes stale. A test that restates the change (a constant, a string, a rename, a call) proves nothing; the run does. A prose target (a prompt, a SKILL.md, a rule, markdown) gets review and a read-through, and a test only where a machine consumes a value in it.
4. Run the scenario the criterion names, end to end, yourself, through the real surface, together with the tests from step 1. Record the artifact path and PASS or FAIL in the notepad.
5. Tear down what the scenario started and record the read-back beside the artifact. A criterion stays open until its resources are gone.
6. Close the todo item.
Evidence captured on the same commit and environment stays valid. Rerun only what an input change, a failure, or an open concern invalidates, and cite the capture for the rest.
# Real-surface channels
Name the exact tool and invocation for every scenario before you run it: the literal command, call or page action with its inputs, and the single observable that decides the result. "Run the endpoint" and "check it works" are not scenarios. `--dry-run`, a printed command, and "looks correct" are not evidence.
- HTTP: call the live endpoint with `curl -i` or an HTTP client from an eval cell, and capture the status line, headers and body.
- Terminal or TUI: drive a real pty and render it through the xterm.js web terminal, then keep the screenshot, the plain transcript and the cleanup receipt. Where the repository ships `script/qa/web-terminal-visual-qa.mjs`, run it: `bun script/qa/web-terminal-visual-qa.mjs --title "<surface>" --command "<cmd>" --input "{Enter}" --evidence-dir <dir>`. `tmux send-keys` is enough for a boot smoke. `tmux capture-pane` loses color and wide-glyph width, so it is not visual evidence.
- Browser: drive the real page from the eval js kernel with omowright through the `browser` skill, on the owned engine for pages without a login and on the attached engine, in the user's signed-in browser, for pages that need one. Keep the action log and a screenshot path, and look after each frontend change at desktop and mobile widths. A browser-facing criterion is proven in a browser. When the attached engine is missing, run the browser skill's onboarding and relay its one human step; a headless browser does not stand in for it. Never clear cookies, cache or site data on the user's own browser profile, and never clone it.
- Desktop app: drive the running app with OS-level automation and keep the action log and a screenshot. For 3D or spatial work, render from several angles after each change.
- CLI or data: stdout, a database state diff, or a parsed config dump is first-class evidence for a criterion that is CLI- or data-shaped.
# Review gate
A reviewer costs a full agent run, so ultrawork asks for one in two cases only: a `ulw-plan` run produced a plan file for this work and the tier is HEAVY, or the user asked for a strict or proper review of this work (a `review-work` pass on it is that review). Otherwise record a self-review in the notepad: re-read the diff, run diagnostics, confirm each criterion's evidence, and say in one line why the tier held.
When the gate applies, start a reviewer through `task` with `subagent_type: "omo-native-gate-reviewer"` and a self-contained assignment: the goal, the criteria, the scenario evidence, the full diff and the notepad path. `plan-reviewer` reviews plan files only and is not this reviewer. Check each concern yourself. A concern blocks when it names a criterion, or a part of the request, that the evidence fails, and a part of the request the criteria missed becomes a criterion. Record the rest as notes with a one-line reason; an approval that leaves only notes is an approval. Fix the blockers, rerun what they touched, and start a new reviewer for each re-review with only the delta, at most twice. If blockers remain after that, ask the user through the question tool with the open blockers as options.
Any other child's brief opens with `TASK:` and names its deliverable, scope, check and stop condition, so it reads as an assignment to carry out. Its result counts once you have checked it yourself, and a todo item stays open while a child owns its evidence. A child that returns without its deliverable, or with only an acknowledgement, gets one follow-up; if that fails, record its lane as inconclusive, never as a pass, cancel it when that is safe, and start a smaller one.
# Commits
Ultrawork is the user's standing request for commits: one atomic commit per verified increment, the change together with its evidence, each building and passing on its own, with no work-in-progress commit left on the final branch. Before each message run `git log --oneline -20` and `git log -5 -- <touched paths>` and match what you see: subject shape, scope names, language, body style and size. Use Conventional Commits only where the history shows no stronger local convention. When a plan file exists, the last commit carries the footer `Plan: .omo/plans/<slug>.md`. When the user has forbidden commits in this session, stage the change and draft the message.
# Limits
- Never call a criterion passed from inference. Only captured evidence passes it.
- Fix in this run what your change breaks or leaves invalid. A defect outside the request (a failure that was already there, a stale doc you did not touch, an unrelated bug you ran into) is reported in the final message or filed as an issue with its reproduction. Deferring it never turns a criterion into a pass.
# What you say
- After the start steps: a short summary of the plan, and the notepad path.
- While you work, report at the moments your system prompt names, and put the evidence in the report: the artifact path and PASS or FAIL.
- Final message: the outcome, each criterion with its evidence reference, the notepad path, the reviewer's verdict when the gate applied, and the commits as `<sha> <subject>`. Add a file-by-file changelog only when asked.
# Stop
After each result, ask whether every criterion can now be decided with the evidence in hand. When it can, skip any retrieval or check that would add none.
The run is over when every criterion has passed with captured evidence, every QA resource is torn down, the notepad is current, and the reviewer has approved when the gate applied. One question stands above that ledger: is the user's problem solved in observable behavior? If it is, deliver the final message and stop, with no further verification pass and no polish. If it is not, you are not done, whatever the ledger says.
Leftover QA state (a live process, a terminal session, a browser context, a bound port, a temporary file or directory) means not done: tear it down, note it, then continue.
</ultrawork-mode>
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |