A task-launcher skill for Claude Code & Codex — grill the requirements, optionally cross-review the plan across models, then run it with PM-mode parallel sub-agents.
English | 简体中文
A single model has systematic blind spots — it tends to miss the same edge cases it didn't think to ask about. But simple work shouldn't pay for heavy process either, so starks tiers every task and keeps trivial jobs fast. At the one decision point that matters, handing the plan to the other model for a second opinion (Claude↔Codex) catches gaps before any code is written.
- Task tiering — every task is sorted into trivial / light / full before anything runs, so simple work stays fast and only real complexity triggers the full flow.
- Cross-model review (you choose) — at sign-off you can send the plan to the other engine (Claude↔Codex) for a critical second pass. Never automatic, never silently skipped — it's offered as an option.
- PM-mode parallel sub-agents — independent slices fan out to parallel sub-agents; tightly-coupled work stays sequential instead of being force-split.
- Two-stage review — a reviewer checks spec compliance, then a reviewer checks code quality; failures loop back.
- Verification gate — no "done / passing / fixed" claim without freshly-run evidence on the spot.
- Optional memory layer — project memory is recalled at task start and a summary is written back when there's reusable progress (e.g. to Obsidian); skipped entirely if unconfigured.
- Dual-platform — one
SKILL.md, symlinked into both Claude Code and Codex. - Anti-recursion guard — when invoked as a cross-reviewer, starks answers once and exits instead of re-entering its own flow.
- Claude Code or Codex CLI
bash- macOS or Linux
- Cross-model review needs the other engine's CLI on your
PATH(claude/codex) - Optional: a knowledge base such as Obsidian for the memory step;
gh(maintenance only) - Recommended: the superpowers plugin — starks hands off to its
systematic-debugging/writing-skills/brainstormingskills when those situations arise (works fine without it; those hand-offs just won't fire)
bash scripts/install.shThis symlinks the repo into ~/.claude/skills/starks and ~/.codex/skills/starks, so both engines share the same SKILL.md. Existing files or symlinks pointing elsewhere are left untouched.
starks reads a few optional environment variables (all have defaults or degrade gracefully):
| Env var | What | Default |
|---|---|---|
STARKS_AGENT_MODEL |
strongest model for parallel sub-agents | your platform's strongest (e.g. Claude opus, Codex gpt-5-class) |
STARKS_REVIEW_MODEL |
model used for cross-review on the OTHER engine | same |
STARKS_MEMORY_DIR |
project-memory dir (e.g. an Obsidian vault subfolder); unset → memory step skipped | unset |
STARKS_STYLE_NOTE |
optional note the memory writer reads first to match your style | unset |
Copy .env.example and adjust the values for your setup.
starks doesn't run the same heavyweight pipeline on everything. When real work starts, it first tiers the task:
- trivial — a one-line edit, a lookup, a concept explanation, an obvious typo. Just do it: no grilling, no review, no memory.
- light — a single clear concern across a few files. Do it (or confirm in one line) and skip the parallel / cross-review machinery, but the verification gate still applies.
- full — multi-file, architectural, large behavior change, or genuinely uncertain. This runs the whole flow.
For a full-tier task the flow is: recall project memory (when configured, so settled questions aren't re-asked) → grill the requirements — multiple-choice first, batching independent questions — to surface hidden assumptions, edges, and success criteria → draft a plan → present it for one decision (a hard gate: start now / cross-review first / revise). Only if you pick cross-review does the plan go to the other model; the revised version comes back for sign-off. After approval the PM fans out parallel sub-agents for the independent work, runs the two-stage review (at most two rework loops, then it stops and escalates back to you), holds the verification gate, and — when a memory dir is configured and there's reusable progress — records a project summary to your knowledge base.
One skill, two engines — starks maps each step to the platform's native tools.
| Action | Claude | Codex |
|---|---|---|
| Spawn parallel sub-agents | Task / Agent |
spawn_agent |
| Track progress | TodoWrite |
update_plan |
| Cross-model review | codex exec -m "$STARKS_REVIEW_MODEL" … |
claude -p --model "$STARKS_REVIEW_MODEL" … |
bash scripts/uninstall.shRemoves only the two symlinks, and only when they actually point at this repo (symlinks pointing elsewhere, or non-symlinks, are skipped). The source repo is never touched. Preview without removing:
DRY_RUN=1 bash scripts/uninstall.shMIT
See docs/DESIGN.md for the design rationale.