Use Cases & Guide
Pick the right command for the job — plan-first work, verified open-ended loops, codebase onboarding, worktree-isolated execution, and post-implementation review.
LazyCodex (LZX) keeps a small public surface: four command pillars ($ulw-plan, $start-work, $ulw-loop, plus /init-deep) and a set of skills layered on top. The skill is picking the command that matches the shape of the work, then letting it carry the task to verified completion.
LazyCodex packages OmO (oh-my-openagent) as the Codex agent harness — LazyVim for Codex. Sisyphus orchestrates Hephaestus, Oracle, and Librarian underneath; you just choose the entry point.
Choose the right command
Most tasks need less than the full loop. Match the command to what the work actually needs:
| Need | Reach for | Why |
|---|---|---|
| Decisions before code | $ulw-plan | Prometheus turns a fuzzy idea into a decision-complete plan at plans/<slug>.md. |
| Execute an approved plan | $start-work | Runs the checklist with durable Boulder progress until every checkbox is done. |
| Open-ended, must be verified | $ulw-loop | Keeps moving until an Oracle verifies the result by evidence. |
| First contact with a big repo | /init-deep | Generates hierarchical AGENTS.md project memory before any edits. |
$ulw-plan never writes product code — it ends with a plan you hand to $start-work. Use $ulw-loop when you want progress measured by verification, not by a hopeful status update.
Use cases
Plan-first work
The canonical chain: decide the approach with $ulw-plan, then carry it with $start-work.
- When to use: the work needs decisions, sequencing, or trade-offs settled before implementation begins.
- Commands:
$ulw-planthen$start-work.
Plan the work with $ulw-plan
Prometheus runs a Socratic interview, explores the codebase in parallel, runs Metis gap analysis, and writes a decision-complete plan to plans/<slug>.md. It never touches product code.
$ulw-plan "add OAuth login with refresh-token rotation"You leave with a plan file, not a code change.
Execute the plan with $start-work
Hand the plan to $start-work. It runs every top-level checkbox with durable Boulder state in .omo/boulder.json, fans independent sub-tasks out to parallel subagents, and applies strict TDD. A Stop-hook re-injects the next turn until the plan is complete, and five evidence gates must pass: plan reread, automated verification, manual-QA, adversarial QA, and cleanup.
$start-work add-oauth-loginIt prints an ORCHESTRATION COMPLETE block once every checkbox is checked.
The whole pass in one block:
$ulw-plan "add OAuth login with refresh-token rotation"
$start-work add-oauth-loginIf the requirements are already clear enough to plan directly, skip the interview-heavy planning and start at $start-work once a plan exists.
Open-ended, verified work
- When to use: the task should keep moving until the result is proven, not until the agent claims it is done.
- Commands:
$ulw-loopwith--completion-promise.
$ulw-loop is self-referential. The agent emits its promise when it believes the task is complete, but that does not end the loop — an Oracle must verify the result first. If verification fails, the loop continues. The iteration cap is 500 in ultrawork mode, 100 in normal mode.
$ulw-loop "make the flaky checkout test pass on CI" --completion-promise="checkout suite green 3 runs in a row" --strategy=continueUse --strategy=reset to start the context fresh each iteration, or --strategy=continue to keep accumulated context.
Onboard a large codebase
- When to use: the repository is too large or too old to explain from memory, and future agents need landmarks before they edit.
- Commands:
/init-deep.
/init-deep scores complex directories and writes hierarchical AGENTS.md context near the code that needs it, so every later run starts with project memory instead of guessing.
/init-deepRun it again when the shape of the codebase changes.
Worktree-isolated execution
- When to use: structural changes or risky experiments you want kept off the main checkout until verified.
- Commands:
$start-work --worktree <path>.
Point execution at an isolated Git worktree so the main checkout stays clean while the plan runs.
$start-work refactor-payments --worktree /home/you/wt-refactor-paymentsPass an absolute path to --worktree. The plan executes inside that worktree; review and merge once ORCHESTRATION COMPLETE prints.
Post-implementation review
- When to use: code is written and you want a multi-angle check before merging.
- Commands: the
review-workskill.
After implementation, run the review-work skill for a multi-angle post-implementation review. Pair it with remove-ai-slops to strip AI-looking code without changing behavior, or comment-checker for feedback after edit-like operations.