up

Plugin up from marketplace ultrapack in btseytlin/ultrapack. Commands read from the repo's manifest — 28 days ago.

Skills (20)

• attack-loop

  Run a bounded implement-attack-repair loop for a user-specified task. Use when work needs repeated independent criticism: perform the task, dispatch a fresh attacker, verify significant findings, repair them, and stop on a clean attack or the user's round limit.

• e

  Explain a file, error, design, diff, or concept like a helpful engineering colleague: grounded in evidence, concise, and with useful follow-up threads. Use when the user asks for a clear explanation of the current work or codebase.

• expand

  Turn one user criticism into a principle-level fix: find the violated principle, every similar occurrence, and fix the shared cause. Use only when the user explicitly invokes expand, $expand, /up:expand, or /skill:expand.

• git-worktrees

  Use when a task needs an isolated checkout. Verify the worktree location, keep mutable environments and build outputs local, and run only authorized setup and checks.

• handsoff

  Contract for hands-off mode — the ultrapack workflow variant that minimizes user prompts after Design, takes the safest reversible path, and logs every auto-choice for one end-of-task review. Referenced by the workflow entry point and child skills (udesign, uplan, uexecute, uverify, ureview). Read w

• job-guardian

  Use when the user explicitly asks to launch and supervise a job. Require an authorized launch, monitoring, recovery, and teardown contract. Detect failures without inventing permission to restart or spend money.

• make

  Orchestrate the full Ultrapack workflow in Codex and Pi: create or resume a task file, design, plan, execute, verify, review, and validate the observable goal. Use when the user asks to build, fix, or deliver a non-trivial change with the complete workflow.

• qplan

  Quickly design and plan, wait for plan approval, then execute sequential phases with focused verification and a manual try. Use when a task needs more than a prompt but does not need the full ultrapack make workflow, or the user asks for a quick plan.

• reflect

  Extract durable, non-obvious lessons from the current dialogue and route them to project guidance, memory, documentation, or the active task conclusion. Use when the user asks to reflect on a session or preserve learnings.

• step-back

  Break a failed implementation loop by tracing attempts, identifying the real blocker, and proposing a materially different direction before further changes. Use when repeated fixes or investigations are not converging.

• summary

  Produce a compact, zero-context handoff for the current Codex or Pi work and save it to the requested destination, active task conclusion, or a new task summary file. Use when the user asks to preserve progress for a later session.

• test-driven-development

  Use when implementing deterministic, reusable code where regressions would warrant a CI red light. Enforces RED-GREEN-REFACTOR. Applicability rule and skip conditions inside.

• try

  Manually test the latest change with one realistic positive case and one adversarial negative case, capturing evidence before any further fix. Use when the user asks for a quick confidence check or wants to test a recent implementation.

• udebug

  Use on any bug, test failure, or unexpected behavior before proposing a fix. Enforces four-phase root-cause investigation — reproduce, pattern-match, hypothesize, fix — with a hard rule against symptom patches.

• udesign

  Use before any creative work — features, components, behavior changes. Turns an idea into a validated spec with explicit tradeoffs and unknowns, and splits scope into multiple tasks if it's too large. Output is the `## Context` and `## Design` sections of the task file.

• udocument

  Use when writing or editing documentation — project docs, CLAUDE.md, READMEs, SKILL.md, docstrings, inline comments. Auto-triggers on `.md` files and docstring edits. Enforces lead-with-why, kill stale content, lists over tables, no aspirational sentences.

• uexecute

  Use to implement an approved plan. When the plan declares `### Interface graph`, derives waves by topo-sort over `[blocks]` IF edges only — non-blocking IF edges (the default) put producer and consumer in the same wave, since the IF declaration is sufficient context. Edits inline when only one imple

• uplan

  Use after design to turn a validated spec into a lean implementation plan. Outputs the `## Plan` section of the task file — files, line numbers, class/method names, invariants, test strategy, order. Ends with a scope-creep / simpler-way check.

• ureview

  Use after verify passes for the future maintainer's audit — sit in the chair of the person who'll touch this code in 3-6 months and ask "what will bite us later?" at the decision level. Surfaces wrong abstractions, load-bearing-but-unobvious shapes, next-change traps, drift from surrounding code. Ra

• uverify

  Use after execute to attack the change and demonstrate how it's broken. Default stance — the change is broken, prove and demonstrate it. Builds an attack checklist (happy-path / negative / invariant / interface hypotheses), runs each freshly, smokes the end-to-end, writes a short summary to the task

Slash commands (6)

• /up:e

  Explain something like a colleague explaining to another engineer. Picks a realistic depth, explains it in one message, offers follow-up threads.

• /up:make

  Orchestrate the full ultrapack workflow — slug, task file, design, plan, execute, verify, review. Size-aware, resume-ready. Prefix args with `handsoff` for hands-off mode (fewer prompts, conservative defaults, decision log).

• /up:reflect

  Reflect on the current dialogue, extract what's worth keeping, and route each learning to its right home — CLAUDE.md, memory, or project docs.

• /up:step-back

  Circuit breaker — stop, diagnose why attempts are failing, propose a fundamentally new direction before trying again.

• /up:summary

  Produce a summary so another session can continue with zero context beyond CLAUDE.md, the codebase, and the summary itself. Save to the requested destination, active task file, or a new summary task file.

• /up:try

  Manually test the latest change with one positive and one negative case. Goal is speed — shortest path to confidence.

Subagents (6)

• explorer

  Trace feature implementations through the codebase and return a compact map — entry points, call chain, 3-5 essential files with file:line references. Dispatched from up:uexecute when a codebase question needs answering.

• implementer-sonnet

  Implement one trivial phase of an approved plan — typos, one-line fixes, mechanical renames, doc/copy edits, lint/import re-orders. Same procedure as up:implementer but on Sonnet for cost. Dispatched per-phase from up:uexecute when the phase is unambiguously trivial.

• implementer

  Implement one phase of an approved plan — code, tests, commit. Default implementer for complex phases (multi-file, new logic, TDD, interface changes). Dispatched per-phase from up:uexecute.

• researcher

  General-purpose deep research. Decomposes a query, investigates systematically across the web, library docs, and the current codebase, returns a synthesized answer shaped by the question. Use when the main agent needs external knowledge beyond what Context7 or a quick web search gives.

• reviewer

  Independent code review against a task's Plan, Invariants, and Assumptions. Stance — the future maintainer's audit: sit in the chair of the next person to touch this code and ask 'what will bite us later?' at the decision level. Single dispatch. Confidence-filtered (≥80), severity-tiered, with optio

• summarizer

  Draft a session-handoff summary so a fresh agent can continue with zero conversation context. Locates the current session's JSONL transcript by grepping for a distinctive phrase, reads it, and merges with repo state. Never writes to disk.

Similar plugins