
no-human
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-aiRun it inside Claude Code after adding the marketplace with /plugin marketplace add no-human-ai/no_human.
Contents
Discovered from sourceSkills 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):
| Name | Type | Description |
|---|---|---|
title | string | Short task title. |
description | string | Full 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_path | string | Absolute 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):
| Name | Type | Description |
|---|---|---|
task_id_or_external_id | string | Either 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:
- 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.
- 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.
- 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>..HEADand 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).
- List the authoring commits:
git log <prev-tag>..<this-tag> --format='%H%x09%an%x09%ae'. - 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.comhappens to embed the login, but a personal address likerahulpamula123@gmail.comembeds nothing, and the login is not the display name (authorRahul-pamulawith that email is handleRahul-pamula, whose CLA ledger file israhul-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.authorcross-checked against the PR that landed it). That is the handle; the email is only a hint you must confirm. - Also enumerate co-authors — the author query cannot see them.
%an/%aeand the commits API each return exactly ONE author per commit; aCo-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 yieldsName <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. - 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. - 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 PanchaniandPrinceXDevare one person, handlePrinceXDev. Collapse by resolved handle, not by email or name, so each person is thanked exactly once. - 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.logincomes backnull(the commit email is tied to no GitHub account), resolve the person by theName <email>fromgit 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. - 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
%aeset 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_humandatabase set up. Unlikefile-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 code | Meaning |
|---|---|
0 | Gate passed: reviewer found no blocking findings and the tamper guard found no test-weakening. |
1 | Gate failed: a blocking review finding or a tamper-guard finding (deleted/weakened tests). |
2 | Gate 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.yamlis read if it already exists (for reviewer backend/model settings); it is never created by this skill, and there is no on-demand~/.no_humansetup here, unlike othernhcommands. 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_humanis created or modified.- In
--prmode only, one additivegit fetchof the pull request's ref writesFETCH_HEADand the fetched objects into your checkout. It creates no branch and moves no ref you own. - Every invocation, default and
--pralike, also makes one localgit clone --local --sharedof your own checkout into a throwaway temp directory (see below) and agit checkoutinside 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