ultrapack

Ultrapack is an opinionated Claude Code, Codex, and Pi skill pack for developers: plan-driven, git-centered, minimalistic. Built around frequently clearing context and using one conversation for one feature.

TL;DR

Claude Code:

/up:make fix the flaky login test

Codex:

Use $make to fix the flaky login test.

Pi:

/skill:make fix the flaky login test

Will take you through the process: design → plan → execute → verify → review → update docs.

Each stage populates docs/tasks/.md. The task file is the source of truth — any fresh agent can read it and resume from wherever the last one stopped.

For smaller tasks, use /up:qplan add a date filter in Claude Code, Use $qplan to add a date filter. in Codex, or /skill:qplan add a date filter in Pi. It combines short context, desired design, invariants and principles, sequential implementation phases, and a minimal verification plan in one task file. After explicit plan approval, it executes and finishes with a positive and negative manual try. Hands-off mode auto-approves the plan under the handsoff contract. No subagents or separate workflow stages. Plan-only requests stay read-only.

Claude Code: /up:make handsoff fix the flaky login test.

Codex: Use $make handsoff to fix the flaky login test.

Same, but ask you as few questions as possible.

While you sleep, the agent makes direct, scoped edits, preserves reversibility through version control, works in a git branch, avoids silent defaults and fallbacks, and fixes only critical and important issues.

Core ideas:

• One file per task. docs/tasks/.md evolves through Context → Design → Plan → Verify → Conclusion.
• Invariants-, principles-, and assumptions-first. Discovered in design, obeyed in plan, checked at review. Short IDs (IV, PC, AS, UK, PH, RK, CK) let later sections reference them without re-quoting.
• Per-phase subagent implementation. Each plan phase dispatched to a fresh up:implementer. Plan declares interfaces (### Interfaces) and an execution graph (### Interface graph); the executor topo-sorts it into waves and dispatches independent phases in parallel.
• Mandatory manual testing. Agent must run what it built before claiming done.
• Goal-gated done. Each task carries a **Goal:** — the observable end state that defines done. The task isn’t done until the Goal is confirmed achieved (a validating status sits between review and done); verified + reviewed code is not done if the real-world outcome — e.g. “training works on the new dataset” — isn’t confirmed.
• As short as I could make it.

Install

Claude Code

Add the repo as a marketplace and install the plugin:

/plugin marketplace add btseytlin/ultrapack
/plugin install up@ultrapack

Then /reload-plugins. Verify with /up:make or by listing skills.

Codex

Add the same repository as a Codex marketplace, install up, then start a new thread so Codex loads the skills:

codex plugin marketplace add btseytlin/ultrapack --ref main
codex plugin add up@ultrapack

Verify by invoking $make or asking Codex to use make for a small task. For a local checkout, replace btseytlin/ultrapack with the checkout path.

Pi

Install the Git package, then start a new Pi session so it discovers the skills:

pi install git:github.com/btseytlin/ultrapack@main

Verify with /skill:make or /skill:qplan.

Design

All three harnesses use the same main branch and shared skills/. Claude Code uses commands/ and agents/. Pi loads only shared skills through package.json. Use /skill: to load a workflow and append its arguments. Ultrapack provides no Pi prompt-template commands.

Inspired by feature-dev and obra/superpowers. feature-dev is too barebones. superpowers is great, but creates huge plans with a lot of work duplication, changes too frequently and is geared to a specific type of dev work. Also it’s a chore to type “superpowers” every time.

Shortened and simplified, taking from both. The whole workflow is built around updating one markdown file per task docs/tasks/.md with sections Context, Design, Plan, Verify, Conclusion. It’s also git centered: use worktrees by default for easier parallel work, incremental commits for easier rollback and review.

Each stage of task planning and execution is a skill. Claude Code’s /up:make and Codex’s make both orchestrate the whole flow.

up:udesign is the first stage: discuss trade-offs with the user, discover invariants (specific things that must hold, e.g. “class Player must not access internals of class Enemy”), principles (softer guidance, like “prefer composition over inheritance”), assumptions (unverified premises the design rests on — the Conclusion reports whether each held), and unknowns (open questions to resolve during plan/execute). Prepare initial spec in the task file.

up:uplan populate the task file with a specific plan. Define what files to change, what classes and methods to update or create, what interfaces they will have, what is the test strategy, break down into phases, define order of execution. No code blocks here unless they are especially tricky.

up:uexecute create git branch and worktree, dispatch independent up:implementer agents per plan phase, make incremental commits, check against plan and design between phases. When the plan declares ### Interface graph, the executor topo-sorts the graph into waves; phases in the same wave are dispatched in parallel (implementers stage changes, dispatcher commits serially in phase order). After each phase’s commit: Boundary check (diff ⊆ declared @ paths). After the final wave: Wiring check (per-IF caller/anchor match). Uses TDD for tasks where it’s helpful.

up:uverify performs manual smoke testing, defining a checklist of fast positive (what should work) and negative (what should not work) checks based on invariants. Writes summary to task file. Loops back to execute on failure.

up:ureview dispatches an independent up:reviewer subagent that knows the design, plan, and changes. It doesn’t know the implementer’s rationale. In the end it’s an independent review: check that all invariants from design and plan still hold and find bugs.

Finally, the conclusion section of the task markdown file is populated. Then all documentation of the project is updated.

Details

Skills

Process skills (u-prefixed to dodge Claude Code built-ins):

• up:udesign — Brainstorm requirements, populate Context + Design + Invariants + Principles + Assumptions + Unknowns, decide whether to use TDD.
• up:uplan — Plan: what files to change, what class/methods and with what interfaces, test strategy, order. Only non-trivial code blocks.
• up:uexecute — Dispatch up:implementer per phase (parallel waves derived from ### Interface graph), incremental commits, Boundary + plan-diff + consistency sweep per phase, Wiring check after the final wave.
• up:uverify — Positive + negative + invariant checklist, manual smoke test, writes summary to task file, loops back to execute on failure.
• up:ureview — Dispatch up:reviewer subagent: independent review, check that all invariants from design and plan still hold.
• up:udebug — Four-phase root-cause investigation.
• up:udocument — Guidance for updating docs, CLAUDE.md, READMEs, in-code comments.

Discipline skills:

• up:test-driven-development — write failing test → make change → test passes.
• up:git-worktrees — guidance for using git worktrees.
• up:job-guardian — babysit a long-running process (training run, batch job) while the user is away: launch contract, immediate-crash gate, stability poll, recoverable→fix/resume vs unrecoverable→reversible teardown + notify. Runs under the up:handsoff contract.
• up:handsoff — Shared contract for hands-off mode (activated via /up:make handsoff ): safety principles, decision log, no-default rule, end-of-task summary. Referenced by /up:make and every process skill.

Workflow entry points

• /up:make [handsoff] — Orchestrate the full flow: task file → design → branch → plan → execute → verify → review → update docs.
• /up:qplan — Combine design and planning, execute sequential phases, run focused checks and a manual try. Avoid overengineering and scope creep.
• /up:try — Design one positive and one negative test case, run both, report.
• /up:attack-loop — Run bounded implement, independent attack, and repair rounds; require a maximum round count and stop condition.
• /up:step-back — Circuit breaker: stop, diagnose why approaches failed, propose new direction.
• /up:summary — Produce a summary so another session can continue with zero context.
• /up:reflect — Reflect on the dialogue, extract learnings into CLAUDE.md / memory / docs.

Codex exposes the same command workflows as skills: make, qplan, e, try, attack-loop, step-back, summary, and reflect. Invoke them with $ or ask Codex to use the named skill. Codex uses its own delegation tools for the implementation, exploration, research, and independent-review roles; it does not rely on Claude-specific custom-agent model pins or transcript files.

Claude Code agents

• up:explorer (Haiku 4.5) — Codebase tracing, file:line refs, 3–5 essential files.
• up:implementer (Opus 4.7) — Default implementer for complex phases (multi-file, new logic, TDD, interface changes). One phase: code + tests + commit + self-review. Receives Owns / Implements / Consumes from the plan’s interface graph. commit: self|defer mode; defer stages only and the dispatcher commits (used in parallel waves). Fresh context per dispatch.
• up:implementer-sonnet (Sonnet 4.6) — Same procedure as up:implementer but on Sonnet for trivial phases (typos, one-line fixes, mechanical renames, doc/copy edits, lint/import cleanup). Bounces non-trivial work back with escalate: up:implementer.
• up:reviewer (Sonnet 4.6) — Independent review against Plan + Invariants + Assumptions. Confidence-filtered (≥80), severity-tiered.
• up:researcher (Sonnet 4.6) — General-purpose investigation: decompose + systematically answer.
• up:summarizer (Sonnet 4.6) — Drafts the handoff prose for /up:summary; gathers repo state, never writes to disk.

License

WTFPL — see license.txt.