BuilderIO/agent-native / packages/core/src/templates/factory/.agents/skills/review-latest-feedback
review-latest-feedback
VerifiedSweep recent feedback (the Slack feedback channels, GitHub issues, CI on main, Sentry, Analytics errors, chat run health, deploys), fix as many real bugs as possible, ship them in one PR, then close the loop on every Slack report with π/β /π« and one short plain-English reply. Use for scheduled or manual feedback sweeps, usually followed by /ship.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 25.1 KB |
| references/slack-reaction-replies.md | markdown | 19.6 KB |
references/slack-reaction-replies.md
View on GitHub# Slack Reaction Replies
Use the connected Slack integration for every Slack read and write. Never use a browser, screenshots, or UI automation to operate Slack.
At sweep exit, reconcile every report root in the scoped inventory that has
this task's `π`, `β
`, or `π«`, including marks left by earlier runs. Capture
the exact Slack actor ID used by the connected tool at sweep start. A mark is
owned by this task only when its reaction owner ID matches that actor ID and the
root is the workflow's by the parent skill's claim evidence. Investigate the
report before replying. A
matching reaction without that evidence is a manual mark: leave it alone. Keep
the disposition, evidence, scopes, and human actions in the internal inventory.
Post a reporter reply only in the two channels named by the parent skill, on a
report this workflow claimed with a verified root π and investigated. A previous
bot reply, reaction without verified claim and investigation, or a newer human
message alone does not authorize a reply. Leave the thread alone when a person
is handling it or has asked the workflow to stop. The reply is one short,
plain-language sentence (about 25 words at most), plus the exact bot disclosure, which does not count toward
that limit. If the root asks a question, that sentence answers
it first and also explains only the reaction(s) added in this run. An answer to a newer human message
answers only that message. Skip the reply when the only reaction added is the merged
`β
` close-out after an earlier "in review" reply; that close-out gets no second
reply. Do not send progress, merge, or deployment updates. Never explain absent or
unchanged reactions or whether a tracker ticket exists. If reporter input is
needed, add `π«` and ask one direct question in that reply. Read back each new
reaction and reply.
Keep prior replies as history. Do not edit or add a status reply merely to
describe changed evidence, an existing reaction, or completed follow-up work.
When a new reaction is added, use one short sentence plus the exact bot
disclosure.
When editing an ordinary Slack reply, pass its visible body as
`message.markdown_text` to `slack_edit_message`; `message.text` is a fallback
for structured block messages and may leave the visible reply unchanged. Treat
the returned message ID as acknowledgment only. Read the exact reply back with
`slack_read_thread` and compare the stored body to the intended status before
counting it as posted. Use `slack_send_message` only when a new reply is
needed, with its `message` field and the root `thread_ts`.
`slack_read_thread` may append a synthetic `Status marks:` summary after the
thread. That is connector metadata, not part of any Slack message; do not copy
it into a reply. Likewise, omit connector-added `Sent using ChatGPT` footer
text from the intended body. `slack_send_message` may append that footer to a
new reply; if it does, remove it by editing with `message.markdown_text`, then
read the reply back again. Include the exact bot disclosure in the visible body
yourself; the connector footer is not a substitute.
Apply reactions to the report root, not the status reply: call
`slack_add_reaction` with the root's `channel_id`, its timestamp as
`message_ts`, and the emoji name without colons (`eyes`, `white_check_mark`, or
`ticket`). A colon-coded emoji mentioned in reply text does not add a reaction.
After each reaction call, read the root with `slack_get_reactions` and verify
the intended emoji and this actor's ID are present before recording it or
moving to another report. A successful tool response is only an acknowledgment;
the readback is the proof. If a reaction cannot be reconciled, record the exact
blocker instead of treating the reply text as a substitute.
Channel reads may expose a thread reply as a separate row. Resolve its
`thread_ts` or permalink and inventory it as a reply to the root, not as a new
report. Put new reactions for an ordinary report on its root; do not add another
`π` to a reply just because it appears as a channel row. Preserve any legacy
reaction already on a reply, read it back, and reconcile the actual root
separately. A reply that raises a genuinely distinct issue stays in the source
manifest as a reply row, but scope, disposition, handoff, and checkoff evidence
belong to the actual root row. Record the distinct issue as a separate scope on
that root and verify it independently. Do not invent a second root or put a
root checkoff on the reply. Record both the source message timestamp and root
thread timestamp; if the connector hides `thread_ts`, resolve the permalink
before recording it.
The parent inventory must retain the reaction-owner IDs and the same-parent
reply timestamp, author ID, disposition, evidence, and read-back text for every
root this actor marks with `π`, `β
`, or `π«`. Record an explicit decision for
both `β
` and `π«` on every such root: `present` with its scope, or `none` with
the reason no mark applies. Record verified fixed scopes with their proof and
each distinct human handoff with its scope, owner, and action. Before the recap, reconcile every owned root in the inventory by hand. Incomplete
source coverage or owned-root reconciliation means the sweep is not done. For
explicitly narrowed scope, keep the active user request as a separate record in
the inventory. This step does not authorize
changing another actor's reactions or replies.
## Prior questions and reporter replies
At sweep start, search the exact bot disclosure in each scoped channel and
exhaust the pages to find prior questions and their context:
```text
slack_search: "this was sent from a bot." in:<#CHANNEL>
sort=timestamp sort_dir=asc include_context=true max_context_length=300
```
Also scan channel messages from the saved reply cursor; on the first run, scan
available history. Since `after:` is date-only, start one day before the cursor,
exhaust pages, resolve hits to their root, and advance the cursor only through
processed messages. Read inherited threads carrying any of this actor's root marks (`π`, `β
`,
or `π«`): a checkmark closes only its verified scope, not a newer reporter
answer or another open scope. Do not reply or react on another actor's root
when work is handed off for investigation; that handoff permits local
investigation only. A separate explicit authorization is required to post a
reporter-facing reply or change that actor's reactions.
Count an answer only when a human posts after the question, without this
workflow's disclosure, and the reply addresses it. Read the full thread to
exclude partial, unrelated, or deferred answers; a newer human post alone does
not reopen a question or authorize a reply. Attempt the fix with new evidence
before asking again. Do not send a
progress reply when no reaction is added. Do not ask again while the question
is less than four days old. At four days, record **Abandoned - no answer in 4
days** internally without re-asking, then carry any remaining defect as
internal work. For legacy replies without disclosure or eyes, search once per
connected actor and verify the author and thread.
End every new or edited Slack reply with the exact sentence
`this was sent from a bot.`. A connector-added `Sent using ChatGPT` footer is
not a substitute.
Reactions are permanent history and do not replace the internal disposition.
At the root, `π` records this workflow's claim, `β
` marks one or
more named scopes that passed direct post-change proof, and `π«` tracks distinct
human/team actions, including actions with no named owner yet. The eye alone
does not mean work remains open. One root `β
` covers every verified scope
listed in `fixedScopes[]`; one root `π«` covers every action listed in
`handoffs[]`, including unassigned, accepted, and completed actions. Completion
evidence changes its status, not the historical `π«` reaction. Unclaimed items
and another actor's marks are not ours to reply to. Reconcile each report as
one unit: update and read back applicable root reactions before advancing to
the next report. Add `β
` once a reported scope passes the direct post-change proof bar on `main`.
An open PR never gets `β
`. Use
**Partially fixed** for the internal disposition when another scope remains.
Do not wait for an entire multi-symptom report to be resolved before checking
off its verified scope. Keep all existing reactions after scopes close. Read
back every reaction and any reply sent. Never remove or clean up any reaction.
While a fix PR is open, `π` may remain; `β
` still waits for the merge to `main`.
The marks are independent. The current disposition says what remains.
For UI behavior, a focused
regression qualifies only if it exercises the changed component and asserts the
reported visible result or persisted state; callback-only assertions, mocked
children, class-name checks, and source inspection do not. For clipping,
wrapping, contrast, or alignment, inspect rendered geometry at the reported
viewport or replay the flow in the running app. Use an app/preview replay when
the regression does not meet that bar. For non-UI scopes, use the area-specific
action, query, or test proof. Record merge or rollout state in the internal
inventory; the checkmark records a verified scope and does not claim it is
shipped or live.
Before leaving each report, compare verified scopes and human/team handoffs
with a fresh root-reaction read. Ensure one `β
` is present when any scope is fixed on `main`, and one `π«` whenever any distinct unfinished action requires another
person or team to act, even before ownership is assigned or accepted. Keep the
mark as history after completion; read back each changed root reaction and
verify its owner. Record whether each mark applies and any historical-reaction
details in the internal inventory only; never explain missing reactions in a
reporter reply. Emoji text in a reply is not a reaction. Preserve every
existing reaction. If later proof invalidates a prior checkmark, move that
scope out of active `fixedScopes[]` and add a `historicalReactionMarks[]` entry
with `emoji`, `scope`, `reason`, and the exact prior `previousStatus`. If the
owner withdraws an accepted action tracked by `π«`, preserve the exact earlier
accepted `handoff` and owner `withdrawalReply`, then update the internal record.
Keep these records consistent with the captured thread; never remove
or clean up a reaction.
Add `π«` for each distinct unfinished team or engineering action that another
person or team must perform outside this workflow, whether or not a named
person has accepted it or an external tracker ticket exists. Record each such
action in `handoffs[]`
with its exact scope, action, and responsible person or team. A team or role owner, or no owner
at all, keeps `status: "unassigned"` until a named person commits. Another person's
reply never changes an existing named owner. Do not invent a
person, Slack ID, request, or acceptance. A handoff becomes `accepted` only when a named person makes an explicit first-person
commitment to the recorded action in the thread. That person becomes its owner: record
their Slack ID and exact reply, and change the status to
`"accepted"`; when the accepted action is done, use `status: "completed"` with
completion evidence. The `π«` reaction remains as history after completion and
no longer counts as an open blocker. An owner withdrawal sets the handoff back to `status: "unassigned"` and keeps it in
`handoffs[]` with its `π«`, so unfinished work stays tracked. It leaves current
handoffs only when the action is completed. An
unambiguous contextual βyesβ/βsureβ may accept a
preceding direct request when it names the human and exact action. That request
may ask whether the named person's TODO or PR already includes the action; a
clear βyes, it's on my PRβ with a stated next step such as βtaking a look nowβ
counts. Record both
the request and acceptance reply, including timestamps and actor IDs. The
human's explicit first-person commitment to the recorded action also counts,
even without a preceding request (for example, βI'll test this todayβ or βI'll
expand it to all appsβ). Record that exact acceptance reply. Tentative language
such as βI might test thisβ is not acceptance. Keep acceptance and refusal verbs
consistent with the examples in this file.
The `π«` reaction covers only that recorded action: do not infer a broader fix,
PR, or delivery promise. A role assignment, generic team ping, or ask without a reply
is not acceptance, but it still gets `π«` when a distinct team action remains
unfinished. Ambiguous or hedged assent does not change `status: "unassigned"`.
A partial fix with a separately unfinished human/team action can have both
`β
` and `π«`.
Work that remains with this workflow is active and needs no `π«` by itself, but a fix
this workflow could not land gets `π«` as a human handoff, matching the parent skill.
Requests for a reporter-provided URL, evidence, or clarification are separate human
actions, not team handoffs. Access, credentials, admin rights, and account changes
are never asked of the reporter. They are internal work for someone with access: record them in `handoffs[]` with a `π«`, owner `"unassigned"`,
and `status: "unassigned"` until a maintainer explicitly commits in the thread; describe
what's needed in the action text without naming anyone. They
are not in `reporterRequests[]`, so they do not expire with the reporter-request
lifecycle.
When this workflow asks a reporter for a URL, evidence, or clarification,
record the requested action in `reporterRequests[]` and add/read back `π«` while
that request is open. This tracks a requested human action; it is not a team
handoff and does not claim accepted ownership. When the reporter answers, or
after four days with no later human reply, move it out of active
`reporterRequests[]` and preserve the root mark in `historicalReactionMarks[]`.
Keep its original `scope`, `action`, `requestReply`, and ticket-bearing
`previousStatus` under `closedReporterRequest`. For an answer, set
`resolution: "answered"` and include the exact human `closureReply` from the
same thread. For an unanswered request,
set `resolution: "abandoned_no_answer"` only after four days with no later human
reply, and omit `closureReply`. Keep the historical action and its evidence in
the internal inventory. Link an external tracker ticket only
if one already exists; do not create or promise one without authorization. If a
human later refuses the accepted action, preserve `π«` as history and record
the refusal and blocker in the internal inventory.
Use the same connected Slack identity for reactions, replies, and read-back.
Compare exact actor IDs returned for the reaction and reply; do not describe a
separate βworkflow identityβ when the connector posts as the invoking user. An
explicit handoff from another eye owner permits investigation only; it does
not transfer the eye or authorize changing that actor's reactions. If the eye
owner differs from the connected actor, or an actor ID cannot be verified,
record the mismatch internally and leave the item unreconciled for its owner.
Do not claim that eye or create a duplicate reply under another actor.
Never remove or clean up another person's or this workflow's reaction. When
new evidence changes the meaning of an existing mark, preserve it and update
the internal disposition and inventory. Read back every new reaction and reply.
An unanswered request for a reporter-provided URL, evidence, or
clarification is **Asked** or **Clarification needed** and remains an open
requested human action: record it in `reporterRequests[]`, keep `π`, and
add/read back `π«`. Ask the direct question in the short reply that accompanies
the new `π«`. It is not a team handoff, so it does not require or imply an
accepted owner in `handoffs[]`.
When no other person needs to act and only this workflow owns the next step, do
not add `π«`.
Resolve duplicate clusters before claiming. Record non-owner duplicates by
permalink and **Clustered** in the internal inventory; do not send a status
reply solely to report clustering. For a late duplicate that already has `π`,
recheck ownership. If this task still owns it, keep the eye and record its
owner permalink; do not send a second owner update. If another task owns it or
ownership is unclear, preserve the eye, record the source in your run notes, and
stop. Keep
distinct scopes and their status clear.
Compare each reported symptom with the evidence in the internal inventory.
Use one root `β
` when at least one fixed scope is merged to `main` and verified; it covers every
verified scope listed in `fixedScopes[]`, with proof recorded internally. Use
one root `π«` whenever at least one distinct unfinished action
requires another person to act; it covers the actions listed in `handoffs[]`
and active requests in `reporterRequests[]`. Handoffs include unassigned
actions and completed actions whose evidence and `status: "completed"` remain
in your run notes; reporter requests stay active only while the requested input is
outstanding.
Do not add duplicate copies of either reaction for additional scopes. Link an
external tracker ticket if there is one. Record a person's Slack ID and exact reply
only after that person accepts; until then record the responsible team/role or
`unassigned` and set `status: "unassigned"`. Keep `π` while work remains. An open reporter request gets `π«` even though it is not a team handoff; a
team handoff also gets `π«`. Do not create or promise an external tracker
ticket without authorization. Never imply a
partial fix resolved the whole report.
For beta and package fixes, verify publisher and release state and keep the
details in the internal recap. Do not send progress or deployment narration.
If this run adds a reaction, explain only that new reaction in the short reply.
Keep technical details, IDs, CI, workflow details, and run IDs out of reporter
replies.
For every reply in each final full-thread snapshot, record a read-back of the
workflow reactions on that reply. If the connector shows `π`, `β
`, or `π«`,
call `slack_get_reactions` for the reply's own timestamp and record exact owner
IDs for those workflow emoji; record `"none"` with `{}` when none appears and
omit unrelated emoji. These reads are separate from the root read-back. Do not
add new workflow reactions to replies. Preserve any legacy reply-level mark and
record its exact message timestamp and owner; then audit the report root
independently. A reply mark never checks off the root scope. Keep it attributed; never move
or remove it.
Read back the reaction and any reply through the same connector, and verify
their actor IDs match the recorded sweep identity before recording the item as
replied. Keep the full mark, scope, and action inventory internally. In the
user-facing recap, mention only reactions added in this run and explain them
briefly. Do not explain absent or unchanged reactions or whether a tracker
ticket exists. Keep any existing ticket link in the internal inventory. Do not
balance reactions for appearance. Treat
reaction text in a reply, another actor's mark, or a reply-row reaction as no
substitute for the required root read-back.
## Backstop for unclaimed roots
Every run, also search `in:<#channel> -has::eyes: -from:<@connected-profile-id>
after:<YYYY-MM-DD>` and page through every result. Slack's `after:` is
date-only and excludes that day, so use the day before the window starts,
then discard any root older than the window's exact start. The filter also
hides roots someone else reacted π to; the channel read's
`slack_get_reactions` check covers those.
Treat each root it returns as a candidate, even one older than your last-seen
point. A last-seen timestamp alone skips reports: one was set to the bot's own
reply and silently dropped three roots posted minutes earlier. Advance a
last-seen point only to the newest report root handled, never to a bot reply.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path β even casually (like "the xlsx in my downloads") β and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |