agentsclimarketplace

Finishing a development branch

Skill bensonmaxai/minis-coding-success-skills/skills/finishing-a-development-branch

Coding-success skills for Minis on iOS: review risk, plan, isolate, trace, test, verify, optimize, finish, release, deploy, triage incidents, plan rollback, write postmortems, and use observability more effectively.

Install
npx -y skills add bensonmaxai/minis-coding-success-skills --skill finishing-a-development-branch

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

2 things to look at

  • no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
  • 0 stars0 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

Use when implementation or debugging work is mostly done and you need to safely finish the branch. Optimized for Minis on iOS: verify tests, inspect diffs, remove debug residue, check scope creep, summarize changes, and prepare a clean commit or handoff. Helps raise coding success rate by preventing rushed, messy, or incomplete finishes.

SKILL.md

4.5 KB, as published. Nobody here has run it

Finishing a Development Branch

Use this skill when coding work is mostly complete and needs to be turned into a clean, reviewable, low-risk change.

Goal

Increase delivery success rate by checking that the work is:

  1. behaviorally correct
  2. minimally scoped
  3. free of obvious residue
  4. clearly summarized
  5. ready to commit, review, or hand off

Core Rules

1. Verify before declaring done

Do not treat code as finished just because the main bug seems fixed or the feature seems visible.

Before finishing, verify:

  • targeted tests pass
  • nearby relevant tests pass when practical
  • any needed manual/browser verification was done
  • the change matches the requested scope

2. Inspect the actual diff

Always inspect what changed before finalizing.

Look for:

  • unrelated edits
  • accidental formatting-only noise
  • debug prints/logging
  • commented-out code left behind
  • temporary files or scratch scripts
  • config changes the user may not expect

3. Prefer minimal, reviewable scope

If the branch includes unrelated cleanup or speculative changes, separate them or remove them before calling the work complete.

The final change should be easy to explain in one short summary.

4. Check for incomplete edges

Ask whether the change still needs:

  • regression tests
  • error handling
  • docs or usage notes
  • input validation
  • cleanup of temporary workarounds
  • follow-up tasks explicitly called out

5. Summarize with evidence

The final handoff should say:

  • what changed
  • why it changed
  • how it was validated
  • anything not validated yet
  • any remaining risk or next step

Minis-Specific Workflow

Shell checks

Use shell commands to:

  • inspect git diff/status
  • run targeted tests
  • search for debug residue
  • confirm changed files are expected
  • check for temporary files created during debugging

Browser checks

For web work:

  • verify the visible behavior in the browser if relevant
  • make sure the final visible state matches the intended fix
  • do not rely on browser verification alone when runnable tests exist

Git hygiene

Before finishing:

  • check git status
  • inspect git diff --stat and git diff
  • confirm only intended files changed
  • prepare a clean commit message or handoff note

Finish Sequence

Use this order:

  1. Restate what was supposed to be delivered.
  2. Run the smallest validating tests first.
  3. Run nearby relevant validation if practical.
  4. Inspect changed files and diff.
  5. Remove debug residue and accidental changes.
  6. Confirm scope is still aligned with the request.
  7. Summarize validation and remaining risk.
  8. Prepare commit, PR summary, or handoff.

Common Finish Failures

Watch for:

  • fixed main path but broke edge case
  • tests never rerun after final edit
  • debug logs left in place
  • partial refactor mixed into bugfix
  • generated files committed unintentionally
  • docs/examples now stale
  • changed behavior not mentioned in summary
  • hidden dependency/config changes

Integration with Other Skills

  • Use test-driven-development earlier in the task to drive implementation safely.
  • Use root-cause-tracing if the work is not actually stable yet and the real cause may still be unclear.
  • Use agent-security-guard if finishing involves risky file operations, uploads, secrets, or production-affecting changes.

Completion Checklist

Before calling the branch finished, check:

  • Does the result match the requested task?
  • Were the most relevant tests rerun after the final code edit?
  • Were manual/browser checks done if needed?
  • Is the diff free of obvious unrelated noise?
  • Were debug prints, scratch files, and temporary code removed?
  • Are changed files limited to what you would expect?
  • Is the summary clear enough for a reviewer or future self?

Response Template

  • Intended outcome:
  • Validation run:
  • Diff review:
  • Residue removed:
  • Remaining risk:
  • Suggested commit/handoff summary:
  • Suggested next step:

Example Triggers

  • "Help me finish this branch cleanly."
  • "Before I commit, do a final development pass."
  • "Check whether this change is actually ready to ship."
  • "Inspect the diff and make sure I didn't leave junk behind."
  • "Prepare a clean handoff summary for this coding task."

Keep looking

Skills are one crate of 328,083. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.