agentsclimarketplace

Plan fix

Skill gtrabanco/agentic-workflow/skills/plan-fix

Draft and locally commit a tightly scoped, phased fix SPEC from one or more issues, then stop before push/PR and hand off to execute-phase --fix. Triggers: "plan-fix", "plan a fix for issue N", "draft the fix spec".From its SKILL.md

Install
npx -y skills add gtrabanco/agentic-workflow --skill plan-fix

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

  • 23 stars23 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 file declares

Copied from the file, not written here

The file declares its own license as MIT. That is the author’s claim about this one file, and it is not the same thing as the license GitHub reports for the repository, which is listed with the other numbers below.

SKILL.md

5.6 KB, as published. Nobody here has run it

Plan Fix

Fix-flow counterpart of plan-feature: draft the SPEC plus frozen acceptance, stop for review, then execute-phase --fix implements every remaining phase.

Turn contract — verify before ending the turn

✓ The fix SPEC is committed on its `fix/<n>-<topic>` branch (commit sha pasted) — NOT pushed, NO PR
✓ The Hand-off block was printed exactly as specified
✓ A multi-issue unit? The hand-off names every issue once as `#primary + #n2 + …`; a single-issue unit names only its issue
✓ Artifact language: explicit user instruction > the project's declared docs language > English. The CONVERSATION language never decides — a Spanish prompt still produces English artifacts unless one of the first two says otherwise
✓ The closing `→ Next:` block is printed as the ABSOLUTE last output

About to end the turn with any box unchecked? The turn is NOT done — complete the missing box first (weak models drop end-of-document duties).

Persona

Senior software architect: skeptical, scope-disciplined and evidence-based. Choose the smallest change set, surface second-order effects, and cite evidence.

Input

One or more GitHub issue numbers from this repo, space-separated.

  • One number: unchanged single-issue behavior (plan-fix 17).
  • Multiple numbers: step 5 decides one capability bundle or homogeneous mechanical batch; different symptoms/files may merge when one outcome, validator and rollback boundary own them.
  • Invalid input: name the bad token and stop; never proceed partially.

Output

  • docs/fix/<primary>-<topic>/SPEC.md — template plus required sections and a ## Phases ledger (always ≥2; final Hardening & PR). Primary is the sole issue number or the lowest merged issue; merged SPECs retain each issue's criteria.
  • docs/fix/<primary-issue-number>-<topic>/ACCEPTANCE.md — the compact frozen finish line from verification-contract, retaining one criterion per issue.
  • Branch fix/<primary>-<topic> from main.
  • One local commit with SPEC and docs/fix/README.md (pending, all merged issues).
  • Stop: do not push/open PR. Hand off to execute-phase --fix.

Hard rules

  • Honor Workflow conventions: create fix/<n>-<topic> first, never main; gate, docs language and evidence apply. Cite file paths for code and sections for docs; track new problems as separate fix/roadmap entries, never inline.
  • Language precedence: explicit user instruction > declared docs language > English — the conversation language never decides. If the issue body isn't in the artifact language, translate silently; if translation is ambiguous, inconsistent, or nonsensical, ask before committing to a meaning.
  • Never push, never open the PR — that's execute-phase --fix.

Progressive loading — validate before drafting

The allowlist is exactly these five paths:

  1. Every invocation: read planning process and execute its validation and multi-issue gate; a refusal or invalid input stops.
  2. Before a material question or SPEC: read question and SPEC contract.
  3. Any route that can write a fix SPEC: consume the planning preflight (owns the normalized repository state read and the ONE final architectural classification) before drafting.
  4. Before emitting phases: load the phase contract for the 8-box phase-lint and phase fingerprint.
  5. Before commit: consume the verification contract and write the frozen ACCEPTANCE.md.

Resources are normative and one hop from this file. Missing required resource → stop; never approximate fixed blocks or phase rules.

Hand-off

After commit, print exactly:

SPEC drafted: docs/fix/<primary>-<topic>/SPEC.md
Branch: fix/<primary>-<topic> (local, not pushed)
Commit: <short hash>
Issue set: #<primary> + #<n2> + #<n3> (print every issue in this unit; single issue → #<primary>)

→ Next: review the SPEC, then /execute-phase --fix <primary> — execute every remaining phase in issue set #<primary> + #<n2> + #<n3> and open the PR
  · explicit atomic mode → /execute-phase --fix <primary> P<n> (same issue set: #<primary> + #<n2> + #<n3>)
  · the final `Hardening & PR` phase pushes and opens the PR with `Closes #<primary>`
    plus one `Closes #<n>` line for every other issue listed in the Issue set
  · scope looks wrong → adjust the SPEC and re-run /plan-fix

Replace every placeholder with the complete actual issue set before printing; never print <n2>, <n3>, or … in a live hand-off.

Then end in the user's language with a 2-3 sentence summary: what the SPEC ships, the biggest risk, and any open decisions left for the implementer.

Portability (agents other than Claude Code)

Use explicit fallbacks when a primitive is absent: open named SKILL.md files in a fresh context; run architect-level scoping on the strongest model, then hand implementation to a cheaper worker.

Done when

  • The SPEC and frozen ACCEPTANCE.md follow canonical contracts, surface risks/blockers, register in docs/fix/README.md, and are committed locally on fix/<n>-<topic> (not pushed/no PR). The closing → Next: Hand-off is printed.

What ships with it: 2 files

6.4 KB alongside SKILL.md

Gives 0 of the 12 instructions most plan spec skills give

Counted across 1,360 of the 2,617 authors here whose files we hold, read 2026-09-06

  • Ask one question at a timein 73 of 1360
  • Write the spec using the templatein 22 of 1360
  • Ask clarifying questions if neededin 19 of 1360, across 18 files
  • Wait for user confirmation before proceedingin 19 of 1360
  • Save plans to the plans directoryin 17 of 1360, across 13 files
  • Check for product marketing context firstin 16 of 1360, across 5 files
  • Read the plan file completelyin 16 of 1360
  • Order tasks by dependencyin 16 of 1360
  • Gather context from the conversationin 15 of 1360, across 9 files
  • Explore the codebase instead of askingin 15 of 1360, across 13 files
  • Wait for explicit user approvalin 14 of 1360, across 13 files
  • Quiz the user on the breakdownin 13 of 1360, across 7 files

Said here and by no other author read

  • Draft the fix SPEC and ACCEPTANCE files
  • Hand off to execute-phase
  • Translate issue body silently if needed

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once.

Keep looking

Skills are one crate of 613,373. 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.