# Hs Sw Repeat

> Hs Sw Repeat

- Skill: `harpreetsingh/hs-sw-repeat` (Agent Skill)
- Install (CLI): `npx skillmds@latest add harpreetsingh/hs-sw-repeat`
- Raw SKILL.md: https://api.skillmd.com/api/skills/harpreetsingh/hs-sw-repeat/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: harpreetsingh (https://skillmd.com/u/harpreetsingh)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/harpreetsingh/hs-sw-repeat

---


# /repeat — Iterative Skill Runner

Run a skill multiple times until it converges (finds nothing left to fix) or
hits a round cap.

## Usage

```
/repeat /plan-review PLAN.md             → run until convergence
/repeat 3 /fresh-eyes src/               → exactly 3 rounds
/repeat /beads-review                    → run until convergence
/repeat 5 /ux-polish src/components/     → exactly 5 rounds
```

## Parse Arguments

1. If `$ARGUMENTS` starts with a number → that's the **round cap** (extract it)
2. Next token starting with `/` → that's the **skill name** (extract it)
3. Everything remaining → passed as **skill arguments**
4. If no round cap specified → default cap is **5 rounds**

## Process

### Before starting

Report:
```
Repeat: running /<skill> <args> for up to N rounds.
```

### Each round

1. **Announce:** `Round N/cap:`
2. **Invoke the skill** with its arguments (run it as you normally would)
3. **Collect results.** The skill will produce output — typically an issues table
   if it follows the Output Protocol, or a report/fixes if it doesn't.
4. **Score the round:**
   - Count issues found (High / Med / Low)
   - Count fixes applied
   - Note if the skill itself signaled convergence (e.g., "this plan has
     likely converged", or "clean — no issues found")

### After each round — convergence check

A round is **converged** if ANY of these are true:
- The skill found **0 issues** (clean pass)
- The skill explicitly signaled convergence in its output
- All issues found were **Low** severity only (no High or Med remaining)
- The issue count **did not decrease** from the previous round (plateau —
  the skill is finding the same things repeatedly)

If converged → stop, go to summary.
If not converged → apply fixes (or get user approval per the skill's rules),
then start the next round.

If the round cap is hit without convergence → stop, go to summary, and flag
that convergence was not reached.

### Interaction model between rounds

- **For skills that auto-fix** (fresh-eyes on code, beads-review): apply fixes
  during the round, then re-run. No user interaction between rounds.
- **For skills that propose changes** (plan-review, fresh-eyes on plans):
  present all proposals at the end of each round. Wait for user approval
  before starting the next round. The user may approve all, approve some,
  or say "stop here."
- **User can interrupt** at any point by saying "stop" or "enough" — go
  directly to the summary.

## Summary

After all rounds complete (or convergence / user stop), present:

```
## Repeat Summary: /<skill>

| Round | Issues Found | High | Med | Low | Fixes Applied |
|-------|-------------|------|-----|-----|---------------|
| 1     | 8           | 3    | 4   | 1   | 8             |
| 2     | 3           | 0    | 2   | 1   | 3             |
| 3     | 0           | 0    | 0   | 0   | —             |

Result: **Converged** after 3 rounds (12 total issues fixed).
```

Or if cap was hit:

```
Result: **Did not converge** after 5 rounds (still finding Med issues).
Consider: different approach, manual review, or splitting the artifact.
```

## Rules

- Never skip the convergence check. Even if the user asked for exactly N rounds,
  stop early if round N-1 was clean.
- The inner skill runs normally — all its rules, output protocols, and checklists
  apply. /repeat is a wrapper, not a replacement.
- Do NOT collapse rounds into one giant review. Each round is a fresh pass —
  the point is that fixing round 1 issues may reveal round 2 issues.
- Between rounds, re-read changed files. Do not rely on memory of the previous
  round's state — the fixes may have changed things.
- Max absolute cap: 7 rounds. Even if the user asks for more, cap at 7 and
  recommend a different approach if still not converging.
- Use extended thinking for convergence analysis.