agentleFS
epamepam/ai-dial-chat/.claude/skills/address-current-branch-review/SKILL.md

address-current-branch-review

Skill501 starsChanged 18 days agoApache-2.0View on GitHub

Read unresolved GitHub code review threads for the pull request associated with the current branch, classify each comment, and implement and verify required code fixes. Post inline replies only when the user explicitly asks to reply after the changes have been pushed and are visible in the PR.

The file

Show its rules and text

We split this skill into the rules it gives an agent

39 rules. About 0 are common, 34 are distinctive, and 5 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈34

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 5

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Before posting a fix reply, verify that the relevant commit is pushed and included in the PR head.

    line 14
  2. Distinctive:

    If the fix is not visible in the PR, do not post.

    line 15
  3. Distinctive:

    Read repository instructions before editing.

    line 20
  4. Very specific:

    Read root AGENTS.md and openspec/config.yaml.

    line 21
  5. Very specific:

    Read the current branch and origin repository from local git.

    line 26
  6. Distinctive:

    Prefer the GitHub app to find the open PR whose head matches the branch.

    line 27
  7. Very specific:

    Use gh pr view only when the GitHub app cannot resolve it.

    line 28
  8. Distinctive:

    Stop if there is no unique open PR for the branch.

    line 29
  9. Very specific:

    Use the GitHub app review-thread action to get is_resolved, is_outdated, path, line, and replies.

    line 32
  10. Distinctive:

    Do not assume flat comments represent thread resolution state.

    line 35
  11. Distinctive:

    Read every reply already present in the thread.

    line 38
  12. Distinctive:

    If code is fixed but unanswered, report that status.

    line 40
  13. Distinctive:

    Keep every change traceable to a specific review thread.

    line 54
  14. Distinctive:

    Do not commit, push, or force-update branches unless explicitly requested.

    line 56
  15. Distinctive:

    Use Nx through the workspace package manager.

    line 59
  16. Distinctive:

    Never claim a fix passed if the required command failed or was not run.

    line 61
  17. Distinctive:

    If verification fails, continue fixing and do not post a success reply.

    line 62
  18. Distinctive:

    Keep it concise and technical.

    line 66
  19. Distinctive:

    Do not be defensive, over-apologetic, or vague.

    line 69
  20. Distinctive:

    Do not use local-only or future-tense wording.

    line 70
  21. Distinctive:

    Stop after implementation unless replies were explicitly requested.

    line 72
  22. Distinctive:

    Do not call any GitHub reply/comment mutation.

    line 74
  23. Distinctive:

    If and only if replies were explicitly requested, check PR visibility and post.

    line 76
  24. Distinctive:

    Verify that the pushed PR head contains the relevant fix commit and that the fix appears in the PR diff.

    line 78
  25. Distinctive:

    If the local fix is uncommitted, unpushed, or absent from the PR diff, stop without posting.

    line 79
  26. Distinctive:

    Prefer the GitHub app inline reply action using the thread's top-level numeric review comment ID.

    line 80
  27. Very specific:

    Use gh api graphql only as a fallback.

    line 82
  28. Distinctive:

    Do not resolve threads, submit a review, approve, request changes, commit, or push unless explicitly requested.

    line 84
  29. Distinctive:

    No code change needed:

    line 101
  30. Distinctive:

    Never treat a request to fix review feedback as permission to post a GitHub reply.

    line 109
  31. Distinctive:

    Never post a fix reply until the user explicitly asks for it after pushing.

    line 110
  32. Distinctive:

    Never post a fix reply when the change is only local or unpushed.

    line 111
  33. Distinctive:

    Never use “prepared locally,” “will appear after push,” or equivalent wording in a review reply.

    line 112
  34. Distinctive:

    Never reply before understanding the full thread and current code.

    line 113
  35. Distinctive:

    Never post a success reply for an unverified fix.

    line 114
  36. Distinctive:

    Never fabricate test results, commit SHAs, or PR visibility.

    line 115
  37. Distinctive:

    Never silently resolve a conversation.

    line 116
  38. Distinctive:

    Never answer an ambiguous behavioral request on the reviewer's behalf.

    line 117
  39. Distinctive:

    Never overwrite, unstage, or revert unrelated changes.

    line 118

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Address Current Branch Review

Process current-branch review feedback: inspect thread state, decide whether code must change, and verify any fix. Treat posting review replies as a separate, explicitly authorized action after push.

Reply Authorization Gate

  • A request to fix, handle, address, or process review comments authorizes code changes only. It does not authorize posting GitHub comments.
  • Post replies only when the user separately and explicitly asks to reply or answer the review comments.
  • Before posting a fix reply, verify that the relevant commit is pushed and included in the PR head. Local working-tree changes or unpushed commits are never sufficient.
  • If the fix is not visible in the PR, do not post. Tell the user to push first.
  • Replies must describe the current PR state as already updated or fixed. Never post wording such as “prepared locally,” “will appear after push,” or any other future-tense visibility disclaimer.

Workflow

  1. Read repository instructions before editing.
    • Read root AGENTS.md and openspec/config.yaml.
    • Invoke nx-workspace before exploring project ownership or targets.
    • Apply any area-specific skill required by the touched files.
  2. Resolve the current pull request.
    • Read the current branch and origin repository from local git.
    • Prefer the GitHub app to find the open PR whose head matches the branch.
    • Use gh pr view only when the GitHub app cannot resolve it.
    • Stop if there is no unique open PR for the branch.
  3. Load thread-aware review data.
    • Use the GitHub app review-thread action to get is_resolved, is_outdated, path, line, and replies.
    • Fetch flat PR comments for numeric comment IDs only when the user explicitly asked to post replies.
    • Ignore resolved, outdated, approval-only, informational, bot-only, and duplicate threads.
    • Do not assume flat comments represent thread resolution state.
  4. Prevent duplicate work.
    • Read every reply already present in the thread.
    • Skip a thread if the requested change is already present in the current code and an adequate answer was already posted.
    • If code is fixed but unanswered, report that status. Post the missing reply only after explicit reply authorization and the push check.
  5. Classify each active thread.

    ClassificationAction
    fix-requiredChange code, add or update tests, and verify. Do not reply unless authorized.
    reply-onlyDraft a technical explanation. Post it only when explicitly authorized.
    ambiguousDo not guess or post; ask the user for the missing decision.
    conflictingExplain the conflict and ask before changing behavior.
  6. Implement fix-required threads.
    • Inspect the full affected file and related tests, not only the diff hunk.
    • For multi-file work, build in thin vertical slices and verify each slice (see the task rules in openspec/config.yaml).
    • Keep every change traceable to a specific review thread.
    • Preserve unrelated user changes and staged files.
    • Do not commit, push, or force-update branches unless explicitly requested.
  7. Verify each fix.
    • Use Nx through the workspace package manager.
    • Choose the smallest relevant tests first, then run project lint and build when appropriate.
    • Never claim a fix passed if the required command failed or was not run.
    • If verification fails, continue fixing and do not post a success reply.
  8. Draft a reply without posting it.
    • Match the reviewer's language when practical.
    • Keep it concise and technical.
    • For a verified fix, state what changed and the relevant check.
    • For reply-only, explain why no code change is needed and reference the existing behavior or contract.
    • Do not be defensive, over-apologetic, or vague.
    • Do not use local-only or future-tense wording.
  9. Stop after implementation unless replies were explicitly requested.
    • Summarize local changes and verification to the user.
    • Do not call any GitHub reply/comment mutation.
  10. If and only if replies were explicitly requested, check PR visibility and post.
    • Fetch the current PR head SHA immediately before posting.
    • Verify that the pushed PR head contains the relevant fix commit and that the fix appears in the PR diff.
    • If the local fix is uncommitted, unpushed, or absent from the PR diff, stop without posting.
    • Prefer the GitHub app inline reply action using the thread's top-level numeric review comment ID.
    • Map GraphQL thread comments to numeric IDs through the flat PR comment list when necessary.
    • Use gh api graphql only as a fallback.
    • Post at most one new reply per processed thread.
    • Do not resolve threads, submit a review, approve, request changes, commit, or push unless explicitly requested.
  11. Summarize.
    • List fixed threads and whether each fix is visible in the PR.
    • List replies posted only when posting was explicitly requested.
    • List reply-only threads.
    • List skipped or ambiguous threads.
    • Report verification commands and any remaining warnings.

Reply Patterns

Verified and visible:

Updated: moved error handling to the global NotificationContext. Verified with `npm exec nx test chat` and `npm exec nx lint chat`.

No code change needed:

No code change is needed here: the value is provided through an app-level adapter, so the library remains unaware of the REST path and preserves isolation.

Safety Rules

  • Never treat a request to fix review feedback as permission to post a GitHub reply.
  • Never post a fix reply until the user explicitly asks for it after pushing.
  • Never post a fix reply when the change is only local or unpushed.
  • Never use “prepared locally,” “will appear after push,” or equivalent wording in a review reply.
  • Never reply before understanding the full thread and current code.
  • Never post a success reply for an unverified fix.
  • Never fabricate test results, commit SHAs, or PR visibility.
  • Never silently resolve a conversation.
  • Never answer an ambiguous behavioral request on the reviewer's behalf.
  • Never overwrite, unstage, or revert unrelated changes.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.