---
name: proceed-with-the-recommendation
tier: featured
description: "Orchestrator for all 7 Laws of AI Agent Discipline. Walks an agent-emitted recommendation list top-to-bottom under the 7 Laws — restate, route per item, verify before advancing, reflect at the end, close with the mandatory three-section block. Standalone with inline fallbacks; trigger phrases are matched by the companion hook, not enumerated here."
origin: https://github.com/naimkatiman/continuous-improvement
---

# Proceed With The Recommendation

## Overview

One reusable skill that ties the continuous-improvement framework to a concrete execution engine. When the user greenlights a list of recommendations, this skill walks them in order under the **7 Laws**, routes each item to the best companion (`workspace-surface-audit`, `superpowers:*`, `ralph`, continuous-improvement helpers), and falls back to explicit inline behavior when a companion is not installed. Never silent no-op, never drive-by, never skip verification.

Core principle: **execute in order, one concern at a time, verify before advancing, reflect at the end.**

## The 7 Laws (inline summary)

This skill is the execution engine for the continuous-improvement framework. Mirrored from `continuous-improvement/SKILL.md` so this file stands alone if that companion is not installed:

1. **Research Before Executing** — what exists, what constrains, what breaks, simplest path. If you can't answer, research first.
2. **Plan Is Sacred** — state WILL build / Will NOT build / Verification / Fallback before any edit.
3. **One Thing at a Time** — finish and verify one item before the next. No "also quickly add" drive-bys. Parallel only when items share no state.
4. **Verify Before Reporting** — "Done" requires actual output checked, not assumed. "Should work" is not verification.
5. **Reflect After Every Session** — what worked / what failed / what you'd do differently / rule to add / next 3 ranked moves.
6. **Iterate Means One Thing** — one change → verify → next. Never bundle untested edits.
7. **Learn From Every Session** — capture patterns as instincts; corrections weaken, confirmations strengthen.

The Loop: `Research → Plan → Execute → Verify → Reflect → Learn → Iterate`. Skipped step = the step you needed most.

## Composition Map

This skill is the orchestrator for the other companions in this repo. It does not duplicate them — it calls them.

| Phase | Companion invoked | 7 Laws alignment |
|---|---|---|
| Pre-flight environment check (optional, first-time or big session) | `workspace-surface-audit` | Law 1: Research Before Executing |
| Plan restatement + tagging + routing decision | `superpowers:writing-plans` (if plan > 3 items or > 150 LOC) else inline | Law 2: Plan Is Sacred |
| Per-item specialist routing | `superpowers:*` / `simplify` / `schedule` / `loop` / `security-review` / `documentation-lookup` / `update-config` / `commit-commands:*` (see routing table) | Law 3: One Thing at a Time |
| Per-item verification | `superpowers:verification-before-completion` or inline smallest-check | Law 4: Verify Before Reporting |
| Long-running or autonomous execution (PRD-style, multi-iteration) | `ralph` | Laws 3 + 6 at scale |
| End-of-run reflection | Write a Reflection block + append to `~/.claude/instincts/<hash>/observations.jsonl` | Laws 5 + 7: Reflect, Learn |
| Iterate if user course-corrects | Restart from Phase 2 with the corrected list | Law 6: Iterate Means One Thing |

## When to Use

**Hard precondition (must be true before this skill runs):** The agent emitted a numbered, bulleted, or otherwise enumerated list of recommendations / next steps / suggested actions in the **immediately prior turn**. If no such list exists in the prior turn, this skill MUST NOT activate — the trigger phrases are ambiguous on their own and "yes do it" / "all of them" can refer to anything.

If the precondition holds, activate when:
- User invokes `/proceed-with-the-recommendation`
- User says "proceed with your recommendation", "do all of it", "go ahead with the plan", "execute the recommendations"
- User confirms with "yes do it" or "all of them"
- Auto mode is active AND the recommendation list is unambiguous

Do NOT use when:
- No enumerated recommendation list exists in the prior turn — ask what to proceed with instead of guessing
- Recommendations include destructive actions (deploy, force-push, DB drops, secret changes) without prior explicit authorization
- User scoped the work ("just the first one", "only the safe ones") — honor the scope
- Recommendations conflict with project agent-instruction files (CLAUDE.md / AGENTS.md / GEMINI.md / equivalent)

## Fast-Path: `--once` Mode

For single-item, low-risk confirmations, the seven-phase flow below is overkill — P-MAG + plan-restate + reflect + three-section close add more ceremony than the work itself. `--once` is an opt-in fast path that runs **Phase 1 (Pre-Flight) + Phase 3 (Execute) + Phase 4 (Verify) only**. Phase 0 (P-MAG), Phase 2 (Plan), Phase 5 (Iterate-on-failure restart), Phase 6 (Reflect), and Phase 7 (three-section close) are skipped.

### When `--once` applies

Invoke `--once` only when ALL of the following hold:

- The prior turn's recommendation list contained **exactly one** item.
- The item is tagged **`safe`** in Phase 1 (not `caution`, not `needs-approval`).
- The item is fully verifiable with a single smallest check (one typecheck, one curl, one read-back, one command output snippet).
- The user explicitly added `--once` to the trigger or invoked `/proceed-with-the-recommendation --once`.

### Trigger phrases for `--once`

- `/proceed-with-the-recommendation --once`
- `/proceed --once`
- "proceed once with that"
- "just do that one"
- Any standard trigger phrase plus the literal `--once` suffix anywhere in the user message

### What runs under `--once`

| Phase | Status under `--once` |
|---|---|
| Phase 0 — P-MAG | **Skipped.** Reason: single-item runs do not accumulate enough state to need a past-mistake gate; running it twice on the same surface within minutes is wasted ceremony. |
| Phase 1 — Pre-Flight | **Runs.** Restate the one item, tag it `safe`, route it. |
| Phase 2 — Plan | **Skipped.** Reason: a one-line item does not need a `docs/plans/` artifact. |
| Phase 3 — Execute | **Runs.** Route to the preferred skill or inline fallback. |
| Phase 4 — Verify | **Runs.** Smallest check, with the output snippet quoted verbatim. |
| Phase 5 — Iterate | **Halts on failure.** If Phase 4 fails, do NOT silently restart — report the failure and stop. The operator decides whether to re-invoke the full flow. |
| Phase 6 — Reflect | **Skipped.** No Reflection block, no `observations.jsonl` append, no `Will NOT repeat:` carry-forward. |
| Phase 7 — Three-section close | **Skipped.** The reply ends with a single line: `Done: <item>. Verified: <check + output>.` No tiered tables, no WILD/RISA, no `Want me to: A or B?` closer. |

### Hard preconditions (refuse `--once` if any fail)

`--once` MUST refuse and fall back to the full flow if:

- The recommendation list has more than one item. The seven-phase flow exists because multi-item runs accumulate state across items; the fast path cannot guarantee that.
- The item is tagged `caution` or `needs-approval`. P-MAG is the gate that catches "we already broke this last week"; skipping it on caution-tagged work is exactly the failure pattern the gate was built for.
- The item touches `>3` files, `>150` LOC, or any of `.github/`, `bin/`, `lib/`, `src/`, `third-party/`. Those surfaces have explicit invariants (`verify:all`, the third-party vendor contract, the `.mts` build pipeline) that the seven-phase flow protects.
- The item is destructive (deploy, force-push, DB drop, secret rotation, file delete that is not a generated artifact). These always route through the full flow regardless of size.

If a precondition fails, emit one line: `--once refused: <reason>. Falling back to full proceed flow.` and continue with Phase 0.

### What you give up

`--once` trades reflection + learning + close-discipline for speed. Concrete losses per skipped phase:

- **No P-MAG read** — past mistakes from prior sessions are not surfaced. Acceptable on single-file safe edits; risky on anything touching code paths the operator has corrected before.
- **No Reflect block** — the run does not append to `observations.jsonl`. Mulahazah will not learn from this iteration.
- **No three-section close** — the next turn cannot use `wild-risa-balance` tier inference from a `## Recommendation (expert|beginner)` heading because no such heading shipped.

`--once` is the right call when the work is genuinely smaller than the ceremony. For anything larger, the seven-phase flow is the discipline.

### Example

Prior turn (last item from a five-item recommendation block):

> 5. Run `npm run verify:docs-substrings` and confirm green before committing.

Operator: `/proceed --once`

Under `--once`, the entire response is two lines:

```
Routed to: inline (Bash). Item: "Run npm run verify:docs-substrings and confirm green." Tag: safe.
Done: ran `npm run verify:docs-substrings`. Verified: `OK docs-substrings: all 150 substring assertion(s) match their target files.`
```

No Phase 0 quote, no `Will NOT repeat:`, no Reflection, no tiered tables, no `Want me to:` closer.

## Phase 0: Acknowledge (Past Mistake Acknowledgment Gate / P-MAG)

Before research begins, the skill must read its own track record. The instinct system records corrections; this gate forces the read at the moment they actually matter — before a new recommendation list is touched. **Three rules, in order. None is optional.**

### Rule 1 — Acknowledge before context (right context from the beginning)

Run [`scripts/scan-past-mistakes.mjs`](../scripts/scan-past-mistakes.mjs) at the project root. Scan three surfaces in one pass and surface every entry with a citation:

- `~/.claude/instincts/<project-hash>/observations.jsonl` — last N (default 10) entries with `type: failure` or `correction` (legacy `event` field also matched for pre-2026-05-06 rows)
- `~/.claude/projects/<project-hash>/memory/feedback_*.md` — every file whose frontmatter declares `type: feedback`; the canonical home of the operator's named corrections (e.g. `feedback_past_mistake_gate.md`, `feedback_no_git_add_all_on_windows.md`)
- `<project-root>/CLAUDE.md` "## Past Mistakes" table rows (if present)

Pass `--json` for machine consumption, or override paths via `--observations <path>`, `--memory-dir <dir>`, `--claude-md <path>` (the auto-detection derives all three from the project root via the standard `<hash>` convention). If the script outputs `No prior mistakes recorded — proceed.`, all three surfaces were empty and Rule 1 is satisfied.

For each scanned entry, emit one line: `Past mistake observed: <quote>. Source: <file:line>. Active in current scope: yes|no.` The script provides the quote + source citation; the active-in-scope judgment is yours — read each surface against the recommendation list and decide.

Skipping this scan because the surface paths are project-host-specific is the historically most common silent failure of this gate; the script removes that excuse. If the script must run, a skip surfaces as no output emitted at all — making the bypass detectable rather than invisible.

### Rule 2 — Clearance gate (don't proceed until the mistake is gone)

Hard halt before Phase 1 if any of these hold:

- The past mistake's residue is **still present** in the working tree (unrotated key, stale README dates, unreverted bug, broken migration)
- The verification step from the prior fix was never run
- A `needs-approval` item from a prior session sits unresolved

Halt output: `BLOCKED on prior mistake: <X>. Residue: <Y at file:line>. Required clearance: <Z>. New recommendation list will not start until cleared.` This is also enumerated under Stop Conditions below.

### Rule 3 — Negative prompt (determine not to do it again)

Carry one named past failure forward into Phase 2 as `Will NOT repeat: <pattern>`. The pattern must cite a specific prior session — generic anti-patterns ("will not skip verification") do not qualify. Concrete shape: `Will NOT repeat: skipped per-item typecheck on lib/ extraction the way item 3 did 2026-04-26`.

Phase 6 reflection scores the run against this declared negative prompt — if honored, instincts strengthen; if violated, the violation itself becomes the next session's Rule 1 quote.

## Phase 1: Pre-Flight (Law 1 — Research)

**If** the recommendation list references files, plugins, or MCP servers not obviously present in the current repo, **then** call `workspace-surface-audit` for a quick scan. Otherwise skip.

Restate the recommendation list back in one compact block:

1. Numbered list of recommendations (original order, never silently reordered)
2. Tag each: `safe` / `caution` / `needs-approval`
3. For each item, declare: "Routed to `<skill>`" OR "Inline fallback: `<behavior>`"
4. Proceed without waiting ONLY if every item is `safe` AND the user already said "all of them" / auto mode is active
5. For any `needs-approval` item (deploy, force-push, DB drop, secret change), stop and ask — even if other items are safe

**Upstream block-shape contract:** if the recommendation list was composed under `wild-risa-balance`, expect a **tier-shaped** block:

- **Expert tier (default):** ≥7 items split as exactly 2 WILD + at least 5 RISA.
- **Beginner tier:** 3 ≤ n ≤ 5 goal-driven items, no WILD/RISA labels (see `wild-risa-balance` → "Audience Tiers").

Detect the tier from the prior turn's `## Recommendation (expert|beginner)` header signal first; if the suffix is absent, infer from item count + label presence (≥7 with WILD/RISA labels = expert; 3–5 unlabeled items = beginner; anything else = malformed).

Shorter-than-tier or wrong-split blocks mean the upstream skill was bypassed or violated — flag the gap to the user (one line: `block arrived as N items; expected expert ≥7 (2 WILD + ≥5 RISA) or beginner 3–5 unlabeled; was wild-risa-balance applied?`) before walking. Do not silently proceed. A 3-item beginner block is **not** "below floor" — it is a legitimate tier shape and walks normally.

## Phase 2: Plan (Law 2 — Plan Is Sacred)

If the list has **>3 items OR touches >150 LOC**, call `superpowers:writing-plans` to generate a bite-sized task breakdown. Save the plan to `docs/plans/YYYY-MM-DD-<slug>.md`.

Otherwise, inline: restate each item as `WILL build: <X>`, `Will NOT build: <Y>`, `Verification: <Z>`, `Fallback: <W>`, `Will NOT repeat: <named past failure pattern carried in from P-MAG Rule 3>`.

Create a `TodoWrite` list mirroring the plan.

## Phase 3: Execute (Law 3 — One Thing at a Time)

For each item in the ORIGINAL order:

1. If `needs-approval` — STOP. Ask. Wait. Do not proceed to later items until the user explicitly greenlights this one.
2. Match to a preferred skill via the routing table below; if not installed, apply the inline fallback. Never silent no-op.
3. Finish this item completely before touching the next. No "also quickly add" drive-bys — log them as deferred follow-ups instead.

### Routing Table (with Inline Fallbacks)

Run [`scripts/route-recommendation.mjs "<item>"`](../scripts/route-recommendation.mjs) to match a single recommendation item to its preferred chain + inline fallback. Default mode prints the matched row; `--json` for programmatic consumption; `--list` enumerates every row. The programmatic source of truth is [`scripts/route-recommendation.routes.json`](../scripts/route-recommendation.routes.json) — the table below is the human-readable documentation that mirrors it. If they drift, the routes.json file wins.

Rows whose **Preferred skill** is not bundled with the `continuous-improvement` plugin carry a `(Reference behavior — does not require <skill>.)` marker on the fallback cell. The marker makes the soft-dependency contract visible at point of use: the inline fallback is fully self-contained and runs without that skill installed. Rows whose preferred skill ships with the plugin (`ralph`, `tdd-workflow`, `continuous-improvement`) carry no marker — the dedicated skill is always available.

| Recommendation type | Preferred skill | Inline fallback |
|---|---|---|
| Long-running / PRD-style autonomous execution | `ralph` (companion in this repo) | Break into sub-recommendations, run this skill recursively per sub-item |
| Implement feature / add capability | `superpowers:brainstorming` → `superpowers:writing-plans` | Restate goal → list 3 design options → pick one → outline files to touch → build. (Reference behavior — does not require `superpowers`.) |
| Fix bug / investigate failure | `superpowers:systematic-debugging` | Hypothesis → add logs/tests → reproduce → smallest fix → verify with the failing repro. (Reference behavior — does not require `superpowers:systematic-debugging`.) |
| Write tests / add coverage | `superpowers:test-driven-development` or `tdd-workflow` | RED (failing test) → GREEN (minimal code) → REFACTOR; one test, one behavior |
| Refactor / dead code cleanup | `simplify` | Find dupes/unused exports, delete in place, re-run type check and smallest test. (Reference behavior — does not require `simplify`.) |
| Security review / auth audit | `security-review` | Scan for hardcoded secrets, unsanitized input, missing authz, SQL string concat, open CORS. (Reference behavior — does not require `security-review`.) |
| Code review before merge | `superpowers:requesting-code-review` or `code-review` | Read diff top-to-bottom, flag CRITICAL / HIGH / MEDIUM. (Reference behavior — does not require `code-review`.) |
| Verify before shipping | `superpowers:verification-before-completion` | Smallest check that proves correctness: typecheck + one test + one curl. (Reference behavior — does not require `superpowers:verification-before-completion`.) |
| Multiple independent tasks | `superpowers:dispatching-parallel-agents` | Launch N parallel `Agent` tool calls in one message; reconcile results after. (Reference behavior — does not require `superpowers:dispatching-parallel-agents`.) |
| Merge / close branch | `superpowers:finishing-a-development-branch` | Verify clean tree, rebase on main, green CI, open PR with summary + test plan. (Reference behavior — does not require `superpowers:finishing-a-development-branch`.) |
| Post-merge deploy receipt (auto-deploy projects) | `deploy-receipt` (companion in this repo) | Confirm deployed SHA == merge SHA via provider CLI, GitHub Deployments API, or version-endpoint curl, plus a 200 from a documented healthcheck. INCOMPLETE receipt blocks the merge from being reported as done. |
| Schedule a follow-up | `schedule` | Tell user the exact action + cadence; if no scheduler, write a dated TODO/memory entry. (Reference behavior — does not require `schedule`.) |
| Recurring poll / interval task | `loop` | Tell user the cadence + how to re-run manually. (Reference behavior — does not require `loop`.) |
| Library / API docs lookup | `documentation-lookup` | Use `WebFetch` against the official docs URL, cite what changed. (Reference behavior — does not require `documentation-lookup`.) |
| Frontend / UI design work | `frontend-design:frontend-design` | Build smallest vertical slice first, verify in browser before styling. (Reference behavior — does not require `frontend-design`.) |
| Settings / hooks / permission change | `update-config` | Edit `~/.claude/settings.json` with a minimal patch; restart session. (Reference behavior — does not require `update-config`.) |
| Commit and push | `commit-commands:commit` or `commit-commands:commit-push-pr` | `git add <specific files>` → commit with `type(scope): outcome` → push when asked. (Reference behavior — does not require `commit-commands`.) |
| Continuous-improvement analysis / instinct update | `continuous-improvement` (core 7-Laws skill) | Run the 7-Laws Reflection block manually; append to `observations.jsonl` |
| Spec-first contract before code | `agent-skills:spec-driven-development` | Restate the contract as a testable spec; downstream tests/code regenerate from it. (Reference behavior — does not require `agent-skills`.) |
| Source-first reading before writing | `agent-skills:source-driven-development` | Read the existing implementation top-to-bottom first; never write blind. (Reference behavior — does not require `agent-skills`.) |
| Curate context window before answering | `agent-skills:context-engineering` → `context-budget` | Trim irrelevant context; keep only the load-bearing files in scope. (Reference behavior — does not require `agent-skills`.) |
| Slice atomic increment with safe deploy | `agent-skills:incremental-implementation` | Smallest reviewable change; ship behind a flag if the full scope is too big. (Reference behavior — does not require `agent-skills`.) |
| Refine vague request into ranked options | `agent-skills:idea-refine` → `superpowers:brainstorming` | Compress N ideas to 1 with explicit scoring criteria. (Reference behavior — does not require `agent-skills`.) |
| Fan out N agents on isolated worktrees with shared contract | `superpowers:dispatching-parallel-agents` → `ruflo-swarm:swarm-init` | Use the swarm contract: fixed roles + base ref + shared contract test; reconcile results after. (Reference behavior — does not require `ruflo-swarm`.) |
| Stream live observation of long agent runs | `ruflo-swarm:monitor-stream` | Push-based event log; poll fallback if the MCP server is offline. (Reference behavior — does not require `ruflo-swarm`.) |
| Visual regression / browser-level diff | `oh-my-claudecode:visual-verdict` | Playwright screenshot diff against staging baseline. (Reference behavior — does not require `oh-my-claudecode`.) |
| Multi-session retrospective across a sprint | `oh-my-claudecode:retrospective` → `learn-eval` | What worked / what failed / what to do differently / 3 ranked next moves. (Reference behavior — does not require `oh-my-claudecode`.) |
| Long autonomous run with quality gates | `oh-my-claudecode:ultrawork` → `ralph` | PRD-shaped autonomous loop with verify-between-iterations. (Reference behavior — does not require `oh-my-claudecode`.) |
| Product-management work (PRD, user stories, acceptance criteria, OKRs, experiments, personas, JTBD, lean canvas, market sizing, competitive analysis, meetings family, launch checklist) | Install phuryn/pm-skills via Claude Code marketplace — see docs/THIRD_PARTY.md | Out-of-band install (`claude plugin marketplace add phuryn/pm-skills` + the eight `pm-*@pm-skills` plugins). Inline fallback: keep the work shape (problem → user → goal → metric → scope; Given/When/Then per story; objective + 3-5 measurable KRs; we-believe / we'll-know hypothesis; TAM/SAM/SOM bottom-up; cross-cutting meetings agenda/brief/recap/synthesize) without depending on a specific routing target. |

## Phase 4: Verify (Law 4 — Verify Before Reporting)

Before moving to the next item, run the smallest check that proves correctness:

- Code change → typecheck + the one targeted unit test
- Migration → apply to dev DB, read back schema
- Config → parse + one consuming command
- UI → start dev server, visit the page in a browser
- API → one curl with expected status and body

Emit one line per item: `Done: <item>. Verified: <actual check + output snippet>. Routed to: <skill|inline>.`

"Should work" is NOT verification. If verification is impossible, explicitly mark the item as unverified and explain why — do not claim done.

**Verification is per-item and non-transitive.** A later item's broader check (e.g. an end-to-end test exercising a mid-stack route) never retroactively verifies an earlier item. If item #2 has a 3-minute typecheck and item #3 would exercise the same code path, you still run #2's typecheck before moving on. Coverage-at-the-suite-level is not a substitute for per-item proof.

## Phase 5: Iterate (Law 6 — One Change → Verify → Next)

If verification fails:
- Fix the smallest thing
- Re-verify
- Do NOT move on to the next item until this one is green

If the user course-corrects mid-loop, stop cleanly and restart from Phase 2 with the updated list. Never carry forward silently.

## Phase 6: Reflect (Laws 5 + 7 — Reflect, Learn)

At end-of-run, emit a Reflection block:

```
## Reflection
- What worked: <concrete behaviors that saved time or caught bugs>
- What failed: <concrete slips, skipped verifications, missed approvals>
- What I'd do differently: <specific change for next time>
- Rule to add: <one-line instinct candidate>
- Iteration — Next best recommendations (ranked, top 3):
  1. <primary — strongest next core-development move>
  2. <alternative — different angle>
  3. <alternative — smaller/larger scope>
```

The "Iteration — Next best recommendations" field is the Law 6 handoff. List the **top 3 ranked** core-development moves that advance the system based on what is now true in the codebase — what to build, fix, refactor, or investigate next. Item #1 is the strongest recommendation; #2 and #3 give the user alternative directions to pick from. NOT git steps (commit, push, PR), NOT verification re-runs (tests, type-check), NOT deploy actions — those belong in the Phase 7 end-of-run summary.

Format per item: `<verb> <object at path:line> (<why, one clause grounded in current context>)`.

Good examples (development progression):
- `Wire the quiz prize-line writer in src/scheduled.ts (real_contest writer is wired; quiz path is recognized but inert)`
- `Refactor the duplicated 4-mode switch shared by /admin/mode and contestModeGuard (drift risk after this session's mode add)`
- `Investigate the intermittent Saturday cron skip in src/scheduled.ts:625 (one missed activation last week, root cause unknown)`

Anti-examples (rejected — these are workflow, not development):
- `Commit and push the changes` → Phase 7 summary, not here
- `Re-run the full test suite` → already done in Phase 4 verification
- `Deploy to prod` → operational, needs-approval

Rules:
- Always exactly 3 items, ranked. Not 2, not 5.
- All 3 must be distinct directions — do not pad with rephrases of #1.
- If fewer than 3 real moves exist, fill remaining slots with `None — goal met from this angle.` rather than inventing busywork.
- If the original recommendation list is fully resolved across all angles, write `1. None — goal met, stop.` and omit #2 and #3.

If an `~/.claude/instincts/<project-hash>/observations.jsonl` exists, append this reflection as one JSONL line. This feeds the instinct system (Law 7) per the core `continuous-improvement` skill.

## Phase 7: End-of-Run Summary (User-Facing Close)

Emit exactly three sections, in this order, as the final user-facing block. Use these heading names verbatim — the shape is not optional.

### 1. What has been done

One bulleted line per completed item: `<item> — Verified: <actual check + output snippet>`. No "should work" claims, no aggregate phrasing like "all tests green" without naming the suite. Files touched and commits created (one concern per commit) belong in this section, grouped under the item they implemented.

### 2. What is next

Three optional subsections — include only the ones that apply, in this order:

- **Deferred** — drive-bys logged, scope-creep avoided. One line per item with the reason it is not being done now.
- **Blocked** — `needs-approval` items, verification failures with non-obvious fixes, user input required. One line per item with the exact blocker AND the next action the user must take.
- **Immediate operator action** — push, deploy, review, cherry-pick, file rotation. Only include if the goal cannot advance without it. Name the exact command or step.

If everything is fully complete and there is no blocker, deferred item, or operator action, write `Nothing — goal met, stop.` and skip section 3.

### 3. Recommendation

**Tier signal in the heading.** When `wild-risa-balance` is in play, the heading carries an explicit tier suffix so the audit trail is self-describing:

- Expert: `## Recommendation (expert)`
- Beginner: `## Recommendation (beginner)`

The Stop hook regex (`^#+ +Recommendation(?:\s|$)`) accepts both forms — the suffix is documentation, not a gate. If the upstream block was beginner-tier, render the lite shape (3–5 items, no WILD/RISA labels, no tiered tables) inside this section instead of the expert tiered-table format described below.

**The "no" escape valve (both tiers).** If you cannot produce a real recommendation under the active tier — expert cannot reach 7 items without padding, or beginner cannot reach 3 items without inventing busywork — write the literal `no` on its own line as the entire body of this section. The tier-suffixed heading still ships (so the audit trail records which tier exhausted itself), but no tiered tables, no WILD/RISA blocks, no "My recommendation" paragraph, and no "Want me to: A or B?" closer follow. `no` is an explicit handoff signal: the current session/perspective is exhausted and the operator should switch context (fresh session, different specialist agent, different framing, sleep on it). Padding to hit the floor is the failure mode this escape exists to prevent.

**Tiny-list exemption:** if the original list had **≤1 item AND the goal is fully resolved with no deferred / blocked / operator items**, omit section 3 entirely and end after section 2's `Nothing — goal met, stop.` line. The tiered table + binary closer is forcing-function discipline for multi-item runs; on a 1-item win it is ceremony. Phase 6's Reflection block still happens internally (Laws 5+7 require it) — it just isn't user-facing-rendered here.

For all other runs (≥2 items, or 1 item with deferred/blocked/operator follow-ups), this is the user-facing rendering of Phase 6's reflection. Use the **tiered table format** below — never a flat ranked list. Tier 1 must cite **direct evidence** from the current session, repo, global rules, or prior commits. Tier 2 is optional polish. The Skip section names items the user might reasonably assume belong, but which are already covered elsewhere (prevents duplicate-suggestion noise).

```
**Tier 1 — strong fit, you already operate this way**

| Item | Why it belongs | Evidence from this session/setup |
|---|---|---|
| <name> | <one-clause rationale> | <concrete file/line/rule citation> |

**Tier 2 — high-fit complements (optional polish)**

| Item | Why |
|---|---|
| <name> | <one-clause rationale> |

**Skip these — already covered**
- <name> — <where it is already handled>
```

Then a **My recommendation** paragraph — one short, decisive paragraph picking a side. Name the single highest-value move and why everything else in the list points at it. No hedging, no "you could do either."

End with a **Want me to:** block — exactly two options, A and B, each one line. A is typically the larger / bundled action; B is typically the smaller / focused first step. Format:

```
**Want me to:**
- **A** — <larger / bundled action — name the artifact + cadence>; or
- **B** — <smaller / focused first step — name the single concrete commit/file>?
```

### Rules for the close

- Tier 1 evidence must be a real citation — filename, line number, rule path, prior commit SHA, or a verbatim quote from the user's global instructions. No "best practices say…", no "industry standard…" — those are fabricated citations and violate Law 4 + the global rule against invented facts.
- Tier 2 may be empty. If it is, omit the section entirely — do not write a stub.
- Skip section is mandatory whenever the recommendation overlaps with anything the user already runs (e.g. existing skills, hooks, scheduled agents). Listing nothing in Skip when overlap exists is itself a fabrication.
- "My recommendation" is **one** decisive paragraph. Recommending both Tier 1 + Tier 2 together is not a recommendation — it is a punt.
- "Want me to:" is exactly **two** options. Never three, never zero, never an open-ended "what would you like next?".
- If no real next move exists across all three tiers, write `Nothing — goal met, stop.` in section 2 and omit section 3 entirely.

## Stop Conditions (Hard Halt)

Stop immediately on any of:
- A `needs-approval` item (deploy, force-push, DB drop, secret change, shared-state mutation)
- Verification failed and the fix is non-obvious
- User course-corrects mid-loop
- New information contradicts the remaining list (root-cause shifted)
- Context >80% full — write a Context Bridge before clearing
- Any drive-by temptation that is NOT in the original list
- Prior-mistake residue still present in working tree or operator queue (P-MAG Rule 2 — clear it before starting the new list)

### Definitions (close common rationalization routes)

- **Drive-by** = any edit outside the exact lines, files, or symbols named in the recommendation, even if the edit is in the same file or "obviously related." A missing null-check three lines away from a unit-test target is still a drive-by. Log it as deferred.
- **Prior explicit authorization** (for destructive actions) = the user named the specific destructive action ("yes deploy to prod", "force-push the rebase", "drop the old table") in this turn or a prior turn. General urgency cues ("I'm in a hurry", "ship today", "just do it") are NOT authorization for any specific destructive action. Stop and ask.
- **"Routed" item** = one that was successfully handled by a preferred skill. "Inline fallback" items are NOT second-class — they get the same verification and summary treatment.

## Red Flags — STOP and Ask

- "I'll deploy to check" — run local verification instead
- "Skip verification for speed" — smallest check is 30 seconds; unacceptable shortcut
- "Batch these into one commit" — one concern per commit, always
- "Also fix this drive-by thing, it's only 3 lines" — log as deferred, do NOT silently implement
- "The null check is really just part of a *good* unit test for #1" — no. It is a drive-by. See Definitions.
- "User will probably be fine with me doing X" — X was not in the list
- "The later step will test this anyway" — no. Verification is per-item and non-transitive.
- "#3 will exercise the same code as #2 end-to-end, so #2's typecheck is redundant" — no. Run #2's typecheck before moving on.
- "User said they're in a hurry, that counts as authorization" — no. Urgency is not authorization. Stop. Ask.
- "I'll proceed past the needs-approval item since the user seems in a hurry" — never. Stop. Ask.

## Common Mistakes

The five failure modes that actually bite. (Stop Conditions and Red Flags above already cover the rest — `needs-approval` halts, drive-by edits, urgency-as-authorization, transitive-verification rationalization.)

| Mistake | Fix |
|---|---|
| Skipping verification on "easy" items | Every item gets the smallest proof. "Should work" is not verification (Law 4). |
| Adding new items not in the list | Log as deferred follow-up. Even one drive-by line is out of scope. |
| Forgetting the end-of-run summary | Always emit the 3-section close: **What has been done → What is next → Recommendation**. |
| Tier 1 recommendation with no real citation | Tier 1 requires a concrete file/line/rule/commit citation — no "best practices say…", no "industry standard…". |
| "Want me to:" with 0, 1, or 3+ options | Always exactly two: A (bundled) and B (focused first step). Three options is a punt, one is a leading question. |

## Installation

```bash
mkdir -p ~/.claude/skills/proceed-with-the-recommendation
curl -L https://raw.githubusercontent.com/naimkatiman/continuous-improvement/main/skills/proceed-with-the-recommendation.md \
  -o ~/.claude/skills/proceed-with-the-recommendation/SKILL.md
```

Restart the Claude Code session so the registry picks it up. **No other plugins required** — the skill falls back to inline behavior for any specialist that is not present.

## Pairs best with (all in this repo)

- `SKILL.md` (core) — the 7 Laws of AI Agent Discipline; this skill is its execution engine
- `ralph.md` — autonomous multi-iteration loops for PRD-scale work
- `superpowers.md` — mandatory-workflow skill framework that routes most specialist calls
- `workspace-surface-audit.md` — environment + plugin scan for the Law 1 pre-flight

Install them together for the full continuous-improvement experience, or use this skill alone — it is self-contained.

## Worked Example

A concrete trace covering the most-failed paths: a `needs-approval` halt, a verification failure-and-retry, and the Phase 7 close. Use this to calibrate output shape — don't copy the wording.

**Prior turn (the agent's recommendation block):**
```
1. Add input validation to the /api/users POST handler
2. Drop the unused `legacy_users` table
3. Refactor the duplicated paginate() helper in lib/db.ts and lib/api.ts
```

**This turn (user):** "yes do it"

**Phase 1 — Restated:**
```
1. Add input validation to /api/users POST  → safe → Inline fallback (security-review pattern)
2. Drop legacy_users table                  → needs-approval → STOP at this item
3. Refactor duplicated paginate()           → safe → Routed to `simplify`
```

**Phase 2 — Plan (inline, ≤3 items):**
- Item 1: WILL add zod schema for body, reject 400 with field-level errors. Will NOT change response shape on success. Verification: one curl with bad payload → 400. Fallback: revert if existing tests break. Will NOT repeat: shipping a POST handler without input validation the way `/api/orders` did 2026-04-15.
- Item 2: needs-approval — stop and ask the user before touching D1.
- Item 3: WILL extract `paginate()` to `lib/pagination.ts`, update both callsites. Will NOT change behavior. Verification: typecheck + the existing paginate unit test green. Fallback: revert if test count drops. Will NOT repeat: extracting a shared helper without diffing both callsite signatures first (the lib/api.ts vs lib/db.ts drift from this same example).

**Phase 3 — Execute item 1:**
Edit `routes/users.ts` adding zod schema. Run `curl -X POST .../api/users -d '{}'` → returns `400 {"errors":[{"field":"email","msg":"required"}]}`. ✓
**Phase 4 verification line:** `Done: input validation. Verified: curl bad-payload → 400 with field error. Routed to: inline.`

**Phase 3 — Execute item 2:**
HALT. Item 2 is `needs-approval`. Emit:
> Item 2 (drop `legacy_users` table) is destructive — D1 schema change. Need explicit "drop the legacy_users table" from you before I touch this. Continuing to item 3 in the meantime.

(NOTE: continuing past a `needs-approval` item to LATER `safe` items is allowed, per Phase 3 rule 1 — what's forbidden is silently skipping or silently doing the destructive item. The user is told and the destructive item is parked.)

**Phase 3 — Execute item 3:**
Extract `paginate()`, update callsites. Run `npx tsc --noEmit` → ❌ fails: `lib/api.ts` had a slightly different signature (`limit?: number` vs `limit: number = 20`). Phase 5 kicks in:
- Fix the smallest thing: keep the more permissive `limit?: number` signature in the extracted helper.
- Re-run typecheck → ✓ clean.
- Run the targeted unit test → ✓ green.

**Phase 4 verification line:** `Done: paginate refactor. Verified: tsc clean + paginate.test.ts → 1 passing. Routed to: simplify.`

**Phase 6 — Reflection (internal):**
- What worked: stopping at item 2 instead of guessing on the destructive op.
- What failed: missed the signature mismatch in plan — should have grepped both callsites first.
- What I'd do differently: pre-check signature compatibility before extracting shared helpers.
- Rule to add: when extracting a helper used in 2+ places, diff the signatures first.
- Iteration — Next 3:
  1. Add a smoke test for the new paginate helper covering both callsite shapes (regression guard).
  2. Audit other duplicated helpers in `lib/` for the same signature-drift pattern.
  3. Investigate whether `legacy_users` is referenced in any cron or migration before the user authorizes the drop.

**Phase 7 — Close:**

### 1. What has been done
- Item 1: input validation on /api/users POST — Verified: curl bad-payload → 400 with field error. Files: `routes/users.ts`, `schemas/users.ts`. Commit: `feat(users): validate POST body, return 400 on missing fields`.
- Item 3: paginate() refactor — Verified: `tsc --noEmit` clean + `paginate.test.ts` 1/1 passing. Files: `lib/pagination.ts` (new), `lib/db.ts`, `lib/api.ts`. Commit: `refactor(lib): extract shared paginate() helper`.

### 2. What is next
- **Blocked**: Item 2 (drop `legacy_users` table) — needs explicit "yes drop legacy_users" from you. Next action: confirm the table is unreferenced in cron/migrations, then authorize.
- **Immediate operator action**: push the two commits — `git push origin <branch>`.

### 3. Recommendation

**Tier 1 — strong fit, you already operate this way**

| Item | Why it belongs | Evidence from this session/setup |
|---|---|---|
| Add a paginate() smoke test covering both callsite shapes | Closes the signature-drift gap that just bit us | This session's failed `tsc` on item 3 |
| Audit other duplicated helpers in `lib/` for signature drift | Same pattern likely lurks elsewhere | The drift was invisible until extraction; suggests a class of bugs |

**Skip these — already covered**
- Re-run the full test suite — already done in Phase 4 verification
- Open a PR — Phase 7 operator action handles this once `legacy_users` is resolved

**My recommendation:** Land the smoke test for paginate first. The signature-drift bug nearly shipped because the refactor relied on the type checker rather than a behavioral test, and that gap will recur on the next shared-helper extraction.

**Want me to:**
- **A** — bundle the smoke test + a quick grep-pass for similar drift across `lib/` into one cleanup PR; or
- **B** — open a focused commit adding just the paginate smoke test against both callsites?

---

What this example demonstrates:
- Original-order walk preserved through a `needs-approval` halt
- Per-item verification (curl, then tsc + targeted test) — non-transitive
- Phase 5 retry on a real failure, smallest fix, re-verify before moving on
- Reflection feeds Phase 7 with concrete citations (the actual `tsc` failure)
- "Want me to" is exactly two options, not three; the tiered close is mandatory because this run had ≥2 items completed
