File a task with no_human and check on it without leaving Claude Code: task_add and task_status over your local no_human server (127.0.0.1:8420). no_human plans, codes, tests and has the work reviewed by a second model, then opens the pull request and stops. Also ships nh gate: run the fresh-session reviewer and tamper guard over your current branch or a GitHub pull request, no server required.

GitHub stars
322

Install

/plugin install no-human@no-human-ai

Run it inside Claude Code after adding the marketplace with /plugin marketplace add no-human-ai/no_human.

Contents

Discovered from source

Skills 3

File a task into no_human

Use the two MCP tools this plugin exposes — task_add and task_status — to hand off work that should become a reviewed pull request, instead of making the change yourself in this conversation.

When to use

  • The work is substantial enough to deserve its own branch, its own tests, and independent review — not a one-line edit you can just make inline.
  • You want no_human to plan, code, test, have the result reviewed by a second model, and open a pull request, while you keep doing something else.
  • Do not use this for small edits you can make directly in the current conversation — that is strictly slower and adds no value.

Prerequisite: the local server must already be running

Both tools call the existing no_human HTTP API at http://127.0.0.1:8420. The bridge does not retry or fall back if that address is unreachable — it refuses to start at all (SystemExit, no auto-retry). Before using either tool, make sure the server is running:

nh start

(The desktop app starts this for you automatically.) If a tool call fails with a connection error, the fix is to start the server, not to retry the call.

Tool: task_add

Creates a new no_human task via POST /api/tasks.

Parameters (all required strings):

NameTypeDescription
titlestringShort task title.
descriptionstringFull task description — inline the concrete context here (exact file paths, exact acceptance criteria), rather than referencing this conversation, since no_human cannot see it.
repo_pathstringAbsolute path to the target repo checkout the task should run against.

You do not pass source — the bridge sets it to "mcp" on every call it makes, server-side, before the request is sent.

Returns: compact JSON with the new task's id and the source the server actually stored (first-class alongside "board"/"jira"), e.g.:

{"task_id":"task-abc123","source":"mcp"}

Tool: task_status

Fetches a task's current full state via GET /api/tasks/{id}.

Parameters (required string):

NameTypeDescription
task_id_or_external_idstringEither the task's own id (or a unique prefix of it) or its external id.

Resolution order: first tries the value as a task id (or id prefix); if that 404s, falls back to a client-side scan of GET /api/tasks for a matching external_id, then re-fetches by the real id. If nothing matches either way, the call raises — a nonexistent id is an error, not an empty result.

Returns: the complete task object as compact JSON, including at least id, external_id, source, title, description, status, created_at, updated_at, e.g.:

{"id":"task-abc123","external_id":null,"source":"mcp","title":"Fix thing","description":"...","status":"in_progress","created_at":"2026-08-20T12:00:00Z","updated_at":"2026-08-20T12:05:00Z"}

task_status is read-only polling — call it again later to check progress; it never changes the task.

Writing a good ticket

Inline everything the coding agent will need directly into description: exact file paths, exact acceptance criteria, any commands to run. Do not reference "the conversation above" or anything in your own context — the task runs in its own fresh session and cannot see it.

Product boundary — no_human opens a PR and stops

no_human plans, codes, tests, has the work reviewed by a second model, opens the pull request, and stops there. Merge is always the human's action — this skill must never instruct or attempt a merge, an approval, or a push to a protected branch. There is no tool exposed here that can merge or approve anything, and none should be sought or improvised — do not run any merge or approval command on the agent's behalf. Once task_status reports a PR link, your job is to report that link back to the human — not to merge it, approve it, or push further changes to it yourself.

Release notes

Turn one release (a tag, or a range of commits) into notes a reader skims in under a minute: what the release does for them, stated as impact, and a thank- you to everyone whose work is in it. Not a changelog, not a commit list.

Three rules, in priority order:

  1. Lead with business impact, not mechanism. Every line answers "what does this change let me do / stop worrying about," not "what file moved." Group by the value to the reader, not by subsystem. Drop anything a user never sees (CI wiring, test-only changes, internal refactors) unless it changed a guarantee they rely on.
  2. Thank every contributor whose commits are in the release (see below). Completeness here is not optional — a missing name is the one error people notice.
  3. Short. If a section is not impact or thanks, cut it. No methodology hedging, no "we're excited to", no filler. A reader should reach the end without scrolling twice.

Step 1 — establish the exact range, then read it

Never write from memory or from a PR list. Read the real commits.

  • Find the previous release tag and this one: git tag --sort=-creatordate | head.
  • List the commits: git log <prev-tag>..<this-tag> --format='%h %an%x09%s'. (If there is no tag yet, use <prev-tag>..HEAD and say so.)
  • Verify both endpoints resolve (git rev-parse <tag>), and that the range is non-empty. An empty range means the wrong tags — stop and fix it.

Read every subject line. Cluster them by what the user gets. A cluster of five commits that together fix one thing is ONE bullet about that thing.

Step 2 — write the impact, and claim only what the range establishes

For each cluster, write one line of impact. Constraints:

  • State only what the commits actually did. If you cannot point to the commit that establishes a claim, do not make the claim. No numbers without a source you can name (a command, a file). If you quote a measurement, say where it was measured.
  • Platform coverage and signing, when relevant, are stated plainly and honestly — what is signed, what is not, and what the user must do about it. Never imply a signature or an auto-update path that does not exist.
  • Keep the project's own voice. Do not add a tagline the project has not adopted; if it has a pinned one, use it verbatim and do not reword it.
  • Banned, because they read as machine-written or as marketing haze: "verbatim", "delve", "seamless", "robust", "we're thrilled/excited", "leverage" (as a verb), "in today's fast-paced". Say the plain thing instead.

Step 3 — the thanks section: every contributor, once, by handle

The contributors are the distinct authors of the commits in the range — the AUTHOR, never the committer (many projects normalise the committer to one maintainer identity, so the committer tells you nothing about who wrote it).

  1. List the authoring commits: git log <prev-tag>..<this-tag> --format='%H%x09%an%x09%ae'.
  2. Resolve each commit to a GitHub handle authoritatively — do NOT parse the email. An email does not reliably encode the handle: a GitHub noreply address like 103962359+L4XB@users.noreply.github.com happens to embed the login, but a personal address like rahulpamula123@gmail.com embeds nothing, and the login is not the display name (author Rahul-pamula with that email is handle Rahul-pamula, whose CLA ledger file is rahul-pamula.md — a dash and a case the email never shows). Get the login from the forge instead: gh api repos/<owner>/<repo>/commits/<sha> --jq '.author.login' per commit (or .commit.author cross-checked against the PR that landed it). That is the handle; the email is only a hint you must confirm.
  3. Also enumerate co-authors — the author query cannot see them. %an/%ae and the commits API each return exactly ONE author per commit; a Co-authored-by: trailer (used for pairing, and by some squash-merges to credit a second person) is invisible to both. Read them explicitly: git log <prev-tag>..<this-tag> --format='%(trailers:key=Co-authored-by,valueonly)', which yields Name <email> lines. Resolve each to a handle the same way as a primary author (by the ledger, or a forge lookup on the email) and add it to the set. Do not skip this because "we don't use trailers" — verify it on the range; a single co-authored commit crediting an external is a name you would otherwise drop.
  4. Remove the maintainer/release identity and any bots (dependabot[bot], github-actions[bot], and the maintainer's own login) from the combined set of primary authors and co-authors. What remains is the external contributors.
  5. Deduplicate to one person. The same human appears under multiple author identities in one range (a noreply email on one commit, a personal email on another; a display name and a login) — e.g. Prince Panchani and PrinceXDev are one person, handle PrinceXDev. Collapse by resolved handle, not by email or name, so each person is thanked exactly once.
  6. If the project keeps a CLA ledger (contributors/<handle>.md — the filename IS the handle, lowercased), confirm each resolved handle has a matching ledger file and print it in the ledger's spelling. The CLA gate guarantees every external author has a ledger entry, so a resolved author with no ledger match means your handle resolution is wrong (you parsed the email, or missed a dash/case), not that they are unlisted — re-resolve that author's handle (list item 2 above), do not drop them. Without a ledger, and when a commit's .author.login comes back null (the commit email is tied to no GitHub account), resolve the person by the Name <email> from git show -s --format='%an <%ae>' and, if you still cannot get a handle, name them by that display name rather than dropping them — a missing contributor is worse than an un-linked one.
  7. Verify by UNION, not by recounting one query. The distinct people you print must equal the deduped union of {primary-author handles} ∪ {co-author handles} ∪ {any commit whose author login was null}, minus maintainer/bots. Do NOT re-derive the check from the same %ae set you thanked from — a count built from the query that already dropped the co-authors and the null-logins will "confirm" a list that is missing exactly them. Recompute each input set independently and compare.

Write the section as a plain thank-you naming each @handle, separated so it scans (e.g. ·-joined on one line, or a short list). One sentence of context is enough; do not explain the contribution model at length.

Step 4 — self-review before you hand it over

  • Every impact line: is it true of the code in this range, and is it impact (not mechanism)?
  • Thanks: re-run the author query and confirm every distinct external person is present exactly once, spelled as their real handle.
  • Length: could a reader skim it in under a minute? If not, cut.
  • Then have it independently reviewed before it ships — release notes are outward-facing text, and a false or missing claim there is the expensive kind.

Shape (adapt; keep it short)

<product> <version> — <platforms in one clause>.

<one or two lines: the headline of the release, as impact.>

## Fixed / Added / Changed   (only the sections you actually have)
**<impact, bold lead>.** <one or two sentences, plain.>
…

## <Signing / install, if the release changes it, stated plainly>

## Thanks
<one sentence>, then: @handle · @handle · @handle

Review this branch

Run nh gate to get a fresh-session, adversarial code review and a test-tampering check over a diff, right now, with nothing installed or running beyond the nh CLI itself.

When to use

  • Someone asks "review this branch" / "check this PR" / "is this safe to merge" and wants a real second-model review with file:line citations, not a summary you write yourself.
  • There is no no_human server running and no ~/.no_human database set up. Unlike file-a-task, this skill needs neither. It runs once and exits.

Prerequisite: your own Claude credential

nh gate uses your own Claude credential, the same one every other nh command uses, never one belonging to no_human itself. If none is on file, create it with:

claude setup-token

nh gate also needs the nh CLI on PATH and a claude CLI it can find: the one bundled inside the installed SDK package is used first, so a separate install on PATH is not required. If either precondition is missing, the command refuses and names exactly what is missing. It never prints a pass when it could not actually run.

Running it

Two invocations, both read-only:

nh gate                        # current branch vs. its merge base with origin's default branch
nh gate --pr <github-pr-url>   # a GitHub pull request's head vs. its merge base

Optional flags: --repo <path> to point at a checkout other than the current directory, --base <ref> to override the comparison base.

The comparison actually used, for example working tree branch ... against merge base with origin/<default> or pull request owner/repo#N head ... against merge base with origin/<default>, is always printed at the top of the output. If the working tree has uncommitted changes, the output says so explicitly and those files are not reviewed; commit them first if they should be.

Reading the result: the exit-code contract

Exit codeMeaning
0Gate passed: reviewer found no blocking findings and the tamper guard found no test-weakening.
1Gate failed: a blocking review finding or a tamper-guard finding (deleted/weakened tests).
2Gate refused to run: no review verdict was reached at all. A named precondition failed: no credential, no upstream, not a git repo, PR fetch failed, the diff is over the single-turn review cap, or the reviewer timed out / hit a transport error.

On exit 2, never report a pass. Also never report the reviewer's checklist as a fail, since the reviewer never actually finished. This includes a diff too large to review and a reviewer timeout or transport error: both refuse before or without a real verdict, not with a "no findings" pass or a "timeout" finding treated as a real blocking issue. Relay the exact refusal message back to the human (it names the missing credential, missing upstream, oversized diff, or fetch/transport failure) instead of guessing at a verdict. Only exit 0 is a pass; treat exit 1 and exit 2 identically as "cannot say this is fine" until the human has read the printed detail.

Relay the full Markdown checklist nh gate prints back to the human, including every file:line citation and the tamper guard's before/after counts. Do not summarize away the citations or the counts.

Product boundary: read and report only, never write

This skill only reads and reports. It never commits, pushes, merges, or edits a tracked file in your checkout, and it must never be followed by a commit, a push, an approval, or a merge of the pull request on the agent's behalf. The exact write surface, stated in full:

  • ~/.no_human/config.yaml is read if it already exists (for reviewer backend/model settings); it is never created by this skill, and there is no on-demand ~/.no_human setup here, unlike other nh commands. One thing does write there: the CLI's background update check caches its result in ~/.no_human/cache/update-check.json, creating that directory if the run lasts long enough to finish the check. Nothing else in ~/.no_human is created or modified.
  • In --pr mode only, one additive git fetch of the pull request's ref writes FETCH_HEAD and the fetched objects into your checkout. It creates no branch and moves no ref you own.
  • Every invocation, default and --pr alike, also makes one local git clone --local --shared of your own checkout into a throwaway temp directory (see below) and a git checkout inside that temp directory only, never against your own checkout.

Beyond that, nh gate only runs read-only git plumbing against your checkout: rev-parse, merge-base, diff, status --porcelain, symbolic-ref (reads the locally recorded default branch; never a network call), and config --get remote.origin.url (to check a --pr URL names your own repo). It also uses the tamper guard's own read-only calls (ls-tree, show) and a read-only reviewer backend. This list describes what the current implementation does, not a promise that it will never grow; it never becomes a write against a tracked file.

The throwaway clone exists so the review reads the exact committed tree it diffed instead of your live working tree (which may be dirty) or, in PR mode, whatever branch you happen to have checked out; it is deleted before the command exits. Merge is always the human's action. After running this skill, your job is to relay the checklist, not to act on it.

MCP servers 1

Sponsors

Details

Marketplace
no-human-ai/no_human
Source
plugins/no-human
Author
eyalgolan
Category
Development
License
MIT
Keywords
mcp, coding-agent, pull-request, code-review, jira, linear, sdlc, review-gate, tamper-guard