agentleFS
AI-Degen-69AI-Degen-69/issue-to-pr-skills/skills/iiib-iterate-after-build/SKILL.md

iiib-iterate-after-build

Skill0 starsChanged 54 days agoMITView on GitHub

Station III-B (Iterate After Build) — human feedback fix loop between build and review. Use after iii-build-plan when the operator reports bugs, dead buttons, UI changes, slowness, or security concerns in freshly built code. Classifies each free-text comment, routes to the right specialist skill, fixes locally with atomic commits and no push, then hands off to iv-review-build-and-pr. Invoke whenever the operator lists corrections after a build.

The file

We split this skill into the rules it gives an agent

1 rule. About 0 are common, 1 is distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Unclear: treat as a bug, ask exactly one focused question, never guess.

    line 34

≈ “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

Station III-B: Iterate After Build (iiib-iterate-after-build)

The router for Path B. The operator describes corrections in free text after a build, and this skill classifies each item, fixes it with the right specialist skill, and loops until the build is clean. Nothing is pushed and no PR is opened here — pushing stays in Station IV.

Pipeline Position

  • Station: Station III-B of VI (human feedback loop)
  • Previous Station: iii-build-plan (Build)
  • Next Station: iv-review-build-and-pr (Review & Verify)

1. Invocation

/iiib-iterate-after-build <free-text corrections>   # e.g. the save button does nothing and the title is off-center on mobile
/iiib-iterate-after-build                           # no text: ask the operator for the correction list, then proceed

The operator never picks a skill. They describe what they saw. Classification is this skill's job.

2. Classify & Route

Split the operator message into separate items (one bug or change each). For every item, state one line: "Item N → Lane X because [observable reason]". The full matrix lives in references/routing.md:

  • Bug / error / regression (crash, console error, worked before and broke): diagnosing-bugs for the full diagnosis loop (feedback loop, minimise, hypothesise, instrument, fix, regression test), then debugging-and-error-recovery for reproduce, localize, fix, and guard.
  • Dead button (click does nothing, no error): follow the dead-button checklist in references/click-path-audit.md — trace the handler call by call and find the state write that undoes an earlier one.
  • UI / styling / mobile change (works but looks wrong): frontend-ui-engineering (plus tailwind-design-system when design tokens apply).
  • Slow: performance-optimization — profile before optimizing.
  • Auth / secrets / untrusted input: security-and-hardening.
  • Unclear: treat as a bug, ask exactly one focused question, never guess.

3. Per-Item Fix Loop

For every item, in order:

  1. Reproduce the item as the operator described it (click path, error text, screen size).
  2. Name the root cause, not the symptom. No fix without a named cause.
  3. Apply the minimal fix with the routed skill. One item, one fix.
  4. Simplify with code-simplification: no dead code, no extra abstractions.
  5. Commit locally: <type>(<scope>): <summary> (#<issue>). Never push, never open a PR.
  6. Verify: browser check for UI via playwright-cli (live DOM, console, network — zero uncaught errors; no other browser tool, browser-testing-with-devtools only for profiling), and targeted test runner for logic via test-driven-development covering modified files, following verification-before-completion for what counts as proven. Batch all DOM checks into one playwright-cli eval; a tool failing twice is abandoned, not retried — tooling that cannot verify leaves the item unverified, which is reported, not looped on forever. Do NOT run full test suites or redundant VBC sweeps per fix; the final pre-push gate in Station IV validates the overall state. Regression tests go at the seam that actually reproduces the bug (unit, integration, or e2e — whatever reaches the real pattern at the call site); when no correct seam exists, that itself is an architectural finding — record it in the commit and surface it in the report. During interactive/prototyping turns, or on explicit opt-out ("just build", "no browser check"), skip the browser check entirely and report the item as not browser-verified — the Station IV gate (or an explicit request) is where visual proof happens. Time-boxed: 5 minutes total from the first browser call, 90s per call — on expiry stop and report the item as unverified ("time-box expired"), never loop.
  7. Next item. A red verification stops the loop until green.

4. Guardrails

Respect CONSTRAINTS.md (no skipped tests, no new external dependencies without approval, zero regressions in touched modules). Never touch code outside the reported items. Never push to origin — iv-review-build-and-pr is the only station that pushes.

Final check walkthrough (mandatory input to the report)

Pre-IV verification gate — after the fixes, guide the operator through re-checking the change with their own eyes so they can loop again via /iiib-iterate-after-build or advance to Station IV. Build the walkthrough from the live product: name the real screen / tab / button, use as many short steps as it takes for clarity — no step cap — each step one quick action in the shape where → what to do → what to see, with → arrows and a direct link when one exists. Plain words, no jargon. Say exactly what to look at (text, state, count). Prefer visual proof. Nothing visual → one line saying so plus how it was checked automatically.

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.