Skip to content
Skills Library
AI & agents · Automation

orchestrate

/orchestrate

Run a whole hackathon entry end to end, on autopilot, without stopping. A task graph (orch.py) covers every phase (event rules, credential sweep, /grok-ideation, /idea-judge, spec, Codex build workers, /dribbble-frontend UI, /chatgpt-assets art, /gemini-video clip, live proof, /idea-judge on the build, /judge-skill gallery and walkthrough, the film, the submission pack), and a Stop hook refuses to let the session end its turn while any task is runnable. It stops only for steps only the human can do, and keeps working on everything else meanwhile. Use it when someone says "do it all", "end to e

Repository
nick-skills ↗
Licence
MIT
Last repository change
12.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
7
Scripts
4
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 4 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/check-workers.sh, scripts/codex-run.sh, scripts/install-hooks.sh, scripts/orch.py

What it does and when to use it

Run a whole hackathon entry end to end, on autopilot, without stopping. A task graph (orch.py) covers every phase (event rules, credential sweep, /grok-ideation, /idea-judge, spec, Codex build workers, /dribbble-frontend UI, /chatgpt-assets art, /gemini-video clip, live proof, /idea-judge on the build, /judge-skill gallery and walkthrough, the film, the submission pack), and a Stop hook refuses to let the session end its turn while any task is runnable. It stops only for steps only the human can do, and keeps working on everything else meanwhile. Use it when someone says "do it all", "end to e

Triggers from the description

do it all
Original author description

Run a whole hackathon entry end to end, on autopilot, without stopping. A task graph (orch.py) covers every phase (event rules, credential sweep, /grok-ideation, /idea-judge, spec, Codex build workers, /dribbble-frontend UI, /chatgpt-assets art, /gemini-video clip, live proof, /idea-judge on the build, /judge-skill gallery and walkthrough, the film, the submission pack), and a Stop hook refuses to let the session end its turn while any task is runnable. It stops only for steps only the human can do, and keeps working on everything else meanwhile. Use it when someone says "do it all", "end to e

How it works

  1. Step 0: arm it (first time on a machine, then every run)
  2. The loop (this is the whole skill)
  3. Autopilot rules (default mode)
  4. What each phase means (the graph already holds these tasks)
  5. Standing constraints (every product)
  6. Delivery
Original SKILL.md headings · 103 lines, 1,207 words
SKILL.md preview
---
name: orchestrate
description: Run a whole hackathon entry end to end, on autopilot, without stopping. A task graph (orch.py) covers every phase (event rules, credential sweep, /grok-ideation, /idea-judge, spec, Codex build workers, /dribbble-frontend UI, /chatgpt-assets art, /gemini-video clip, live proof, /idea-judge on the build, /judge-skill gallery and walkthrough, the film, the submission pack), and a Stop hook refuses to let the session end its turn while any task is runnable. It stops only for steps only the human can do, and keeps working on everything else meanwhile. Use it when someone says "do it all", "end to end", "run the pipeline", names a hackathon and wants entries, or types /orchestrate.
---

# /orchestrate

You are the conductor of a run that **does not stop**. The work is split up:
- **Codex** writes code.
- **You** do design, film, copy and review.
- **Grok** scouts ideas.
- **ChatGPT and Gemini** make art.

The run is a task graph in `orch.py`. A Stop hook holds you to it.

Why it's built this way: the old version ended its turn at every milestone ("Say go and I'll start…",
a status report, "want me to…?"). It also launched Codex detached, so nothing woke it when the
workers finished. The human came back hours later to "why u stopped". Both holes are closed now:
- **The Stop guard** blocks the end of the turn while a task is runnable, and tells you the next task.
- **Workers run under Bash `run_in_background: true`**, so the harness wakes you when each one exits.
  The guard then makes you review the result.

```
O="python3 $HOME/.claude/skills/orchestrate/scripts/orch.py"   # (zsh: use a function, not "$O")
```

## Step 0: arm it (first time on a machine, then every run)
1. Run `scripts/install-hooks.sh` once per machine. It is idempotent, and it's a no-op for sessions without a run.
2. **New run:**
   ```
   orch.py init --work <grokbot>/runs/<event-slug> --event "<name>" --url <event page> --deadline <UTC> [--products a,b,c]
   ```
   - Name the products if the human already chose them; ideation is then skipped.
   - Otherwise ideation runs first and you add products after the pick with `orch.py add-product a,b`.
   - **Continuing a run in a new session:** `orch.py resume --work <dir>`, then read `<dir>/STATE.md`.
3. `init` and `resume` bind **this** session to the run. From then on, ending the turn while tasks are
   runnable gets blocked, with the next task in the message. That's intended. Keep going.

## The loop (this is the whole skill)
```
while true:
  orch.py next --all                 # NEXT task, its skill, its done-criteria; plus what's parallel
  orch.py start <id>
  do it (with the named skill; parallel independent tasks via subagents or Codex workers)
  orch.py done <id> --evidence "<commit / URL / path / test line>"
     or orch.py block <id> --needs "<exact credential or decision>" --who human   -> PushNotification it
     or orch.py skip <id> --why "<reason>"
```
- **Never end the turn while `next` prints `NEXT:` or `REVIEW:`.**
- **`WAIT:`** (only background workers are running): you may end the turn. Their exit wakes you.
- **`HUMAN:`** (only human steps are left): make sure every ask was sent, report in five lines, and end.
- **`DONE:`**: run `orch.py finish` and send the deliverables.
- **Evidence is required.** "done" without a commit, URL, path or command output isn't done.
- `orch.py status` re-renders `STATE.md`. Show it to the human at phase changes, not every task.

## Autopilot rules (default mode)
1. **No permission questions.** No "should I continue", "say go", "want me to", or "which one?" when you have
   a recommendation. Pick it, `orch.py decide "<what and why>"`, tell the human in one line, keep going.
   They redirect you if they disagree.
2. **A missing key blocks one task, never the run.**
   - `block` it, PushNotification the exact ask (what, where to get it, which `.env` variable), and move on.
   - Soft dependencies (`~id`) route around a blocked task. Film on a local fork or testnet when mainnet keys
     are missing, label it honestly, and re-shoot when the key lands.
3. **The only real gates** are steps only the human can do:
   - real money or a mainnet spend (ask once, with an amount);
   - making a repo public, if it wasn't pre-approved;
   - submitting the form, signing in, or posting.
   Everything else you do yourself.
4. **Parallel by default.** `next --all` lists every runnable task.
   - Independent tasks go to subagents (research, QA) or Codex workers (code).
   - At most 2–3 heavy workers on a 16 GB laptop.
   - Design, art direction, film and review stay with you.
5. **The human said stop** → `orch.py pause` (the guard goes off). "Carry on" → `orch.py unpause`.
6. **Stalls:** the guard lets you stop after 3 turn-ends in a row that didn't change the task graph. If you are
   truly stuck, `block` the task with what's needed rather than looping.

## What each phase means (the graph already holds these tasks)
| Phase | Tasks | Use |
|---|---|---|
| 0 intake | `rules`, `creds` | Read the event page live → `RULES.md` (deadline UTC + IST, rubric weights, must-haves, entries/team, prizes copied, bans). Credential sweep → `CREDENTIALS.md` + one PushNotification checklist **in the first hour**. Losing streaks came from "BLOCKED: needs a key" found on deadline day. |
| 1–2 ideas | `ideate`, `pick` | `/grok-ideation`, then `/idea-judge` (you judge, never Grok). Autopilot takes the top pick. If the human rejects the batch, change the lens, not the wording. |
| 3 build | `spec`, `repo`, `brief`, `code`, `review` | Write `specs/<slug>.md`; set up a monorepo with MIT (Copyright (c) 2026 Nivesh Gajengi) and a private remote; write briefs from `templates/codex-brief.md`; run `ORCH_TASK=<id> scripts/codex-run.sh <repo> <brief>` **with `run_in_background: true`**. Review before every commit: deleted or weakened tests, gutted docs, staged secrets, fake data. Commit each diff and push straight away. |
| 4 look | `ui`, `art`, `clip`, `qa` | `/dribbble-frontend` (you, never Codex): layout from the real category leader's screens, finish from the Dribbble library, never an invented layout or a clone of another of our apps. Then `/chatgpt-assets`, `/gemini-video`. QA at 375 and 1440 px. Live data, empty states, or "Setup required" only. |
| 5 live | `live`, `testing` | Real transactions with explorer links in the README; `TESTING.md` from real runs. Mainnet spend is a `block` for the human's yes. |
| 6 judge + film | `judge`, `gallery`, `walk`, `film` | `/idea-judge` on the running build, then fix the weakest criterion. `/judge-skill` gallery and raw walkthrough. Cut a ~3-minute film with `/hyperframes`: problem first, then live demos only, full-width app screens, captions, speed badges. Never edit real output; redact with a visible box. |
| 7 submit | `pack`, `public`, `submit` | `HACKATHON_SUBMISSION_FORM.md`, README, post text. Run a secret scan, then make the repo public. `submit` is the human's: send a 3-line checklist with links and the deadline in IST. |

Add any extra work with `orch.py add --product <p> --phase <n> --title "..." --after <id>`. That covers judge
fixes, a second chain check, or a re-shoot when a key lands.

## Standing constraints (every product)
- One chain per project.
- No re-skins of past builds.
- A product that won on one chain stays there.
- Several products in one event must not look like one team made them.
- Brandable names (Japanese, Greek or Korean).
- No mocks of external APIs.
- Fail loudly ("Setup required").
- Never print or open secrets.
- Never force-push.
- Never delete a submitted video; upload a new version of the same file.

## Delivery
- Send each result the moment it lands with SendUserFile: a gallery link, a film, a live URL.
- Reports are plain words: what's done, what's live (with links), what only the human can do, and by when.
- Push back honestly. If an entry won't be live by the deadline, say so early and `add` the cut that makes it live.
Files in this package (7)
  • SKILL.md 8 KB
  • scripts/check-workers.sh 1 KB
  • scripts/codex-run.sh 2 KB
  • scripts/install-hooks.sh 1 KB
  • scripts/orch.py 23 KB
  • templates/RULES.md 1 KB
  • templates/codex-brief.md 1 KB

Versions

RepositoryScoreLicence
This page · nickthelegend/nick-skills100MIT
kriegcloud/beep-effect100Apache-2.0
zahidakhyar/skills100MIT
jkaloger/lazyspec100MIT
superset-sh/superset100MIT
boshu2/agentops100Apache-2.0
Ovich/charrette100MIT
matthew-eth724/orchestrate100MIT
aayushpokhrel1/delegation-pipeline100MIT

Database snapshot: 13.11.2026 · package version f020f0788804 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100grok-ideation
    Generate and judge hackathon ideas in five rounds using Grok (grok.com, Expert mode, driven in the user's real Chrome) as the idea engine and Claude as the harsh judge. Round 1 fans one shared brief out across 5–10 "lenses" (one Grok chat each); round 2 kills ideas that are…
  • 100idea-judge
    Judge hackathon ideas or finished builds honestly yourself, in five rounds, against the event's real rubric. Round 1 captures the rubric, round 2 runs the prior-art kill check, round 3 scores each criterion with evidence, round 4 improves each idea at its weakest criterion, and…
  • 90Hedera Hackathon PRD
    This skill should be used when the user wants to plan a Hedera hackathon project, create a PRD, write a project spec, brainstorm a hackathon idea, or structure their hackathon submission. Triggered by phrases like "hackathon project plan", "hackathon PRD", "plan my hackathon…
  • 90solve-this
    Solve a task end to end on autopilot with minimal user input, then prove it is solved. Runs /plan-this and /build-this without asking the user anything, keeps diagnosing and retrying until the result passes its checks, and stops with one report containing evidence. Use when the…
  • 100orch-add-feature
    Orchestrate building a brand-new feature end to end — research, plan, TDD implementation, review, and gated commit — by delegating each phase to the matching ECC agent. Use when adding a capability that does not exist yet.
  • 100karpathy-graph-build
    Stage 3 of the karpathy-graph pipeline, and the end-to-end entry point. Create a graph, assemble validated writes with provenance, and produce the machine and human artifacts. Use when the user asks to build or create a knowledge graph from a context, to add facts to an existing…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.