Undo

Nyann (ငြမ်း) is Burmese for scaffolding. Nyann is a Claude Code plugin that sets up and maintains project governance.

Install

npx -y skills add thettwe/nyann --skill undo

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

6 stars6 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Safely undo the most recent git commit(s) on a feature branch. TRIGGER when the user says "undo my last commit", "undo last N commits", "oops revert that commit", "undo the commit but keep my changes", "uncommit", "revert my last change", "take back that commit", "/nyann:undo". Trigger on "revert" only when the user clearly means undoing a local commit (not `git revert` on a published one — see DISAMBIGUATION). DISAMBIGUATION: if the user says "revert a commit that's already on main" / "revert a pushed commit" / mentions a specific remote SHA, this is the `git revert` workflow — undo-skill refuses pushed commits by default. Explain the difference and either use --allow-pushed (risky) or direct them to `git revert <sha>`. Do NOT trigger on "undo the last edit" (that's editor-level) or "rollback the deploy" (that's infrastructure, out of scope). Do NOT trigger on main/master/develop — long-lived branches should never be history-rewritten; use `git revert` instead.

SKILL.md

4.3 KB, 906 tokens by cl100k_base, as published. Nobody here has run it

undo

Wraps bin/undo.sh. History-mutating operation — treat as destructive.

1. Always preview first

Before any mutation, run bin/undo.sh --dry-run and show the user which commits will be undone. The preview JSON lists them newest- first with SHA and subject. Read it back and ask the user to confirm — even for a single-commit undo.

Exception: the user's request explicitly included "don't ask" / "just do it" AND --count is 1 AND --strategy is soft (the safest default). For anything multi-commit or non-soft, always confirm.

2. Decide strategy

Default is soft (safest — all changes stay staged). When the user's intent is unclear, you MUST call the AskUserQuestion tool (not plain text):

{
  "questions": [
    {
      "question": "How should the commit be undone?",
      "header": "Strategy",
      "multiSelect": false,
      "options": [
        { "label": "Soft (Recommended)", "description": "Undo commit, keep changes staged" },
        { "label": "Mixed", "description": "Undo commit, keep changes in working tree (unstaged)" },
        { "label": "Hard", "description": "Undo commit AND discard all changes permanently" }
      ]
    }
  ]
}

For hard, warn the user twice: the work is gone after hard reset. Confirm before executing even after the picker selection.

3. Decide scope

last-commit (default) — one commit.
last-N-commits with --count <N> — multiple commits. Use when the user says "undo the last 3 commits" or similar.

last-N-commits is more dangerous because commits partway down the stack are harder to recover. For N > 3, suggest using git reflog

targeted revert instead of a bulk reset.

4. Pre-flight safety (script enforces; relay messages)

Refusal reason	What to tell the user
`long-lived branch`	"Can't undo on main/master/develop. Use `git revert <sha>` to create a reverting commit."
`merge commit`	"HEAD is a merge commit — undo with `git revert -m 1 <merge-sha>` manually."
`already on upstream`	"The commit is already pushed to `<upstream>`. Either `git revert` it (safe) or pass `--allow-pushed` to force-push after the reset (only if nobody else pulled)."
`detached HEAD`	"Detached HEAD — checkout a branch first."
`fewer than N commits`	"Branch only has M commits; can't undo N."

5. Invoke

bin/undo.sh --target <cwd> \
  [--scope last-commit|last-N-commits] [--count N] \
  [--strategy soft|mixed|hard] [--allow-pushed] [--dry-run]

6. Post-undo report

On success, echo back:

What was undone (subjects from undone_commits).
The new HEAD SHA.
Where the changes are now: staged (soft), in working tree (mixed), or gone (hard).
For soft/mixed: suggest git status to see what's pending.
For multi-commit undo: remind the user that git reflog can recover the discarded history if they change their mind soon.

7. Hand-off

"Re-commit with a new message" → commit skill after undo.
"Now push the rewrite" → if undo required force-push (pushed commit with --allow-pushed), they'll need git push --force-with-lease. Don't run this automatically; explain and let them decide.
"Undo the undo" → git reflog + git reset --hard <prior-sha>. Handle this as a separate one-off; don't add reflog logic to the undo skill itself.