Run any Skill in Manus with one click

iterative-refinement

Stars3

Forks0

UpdatedMay 26, 2026 at 16:49

Rapid iterative refinement skill. Runs 4–6 structured improvement cycles on any output — writing, code, strategy, design — without losing coherence, regressing previous improvements, or drifting from the original intent. Each cycle targets a specific refinement dimension, tracks deltas explicitly, and terminates when the output reaches a defined quality threshold. Prevents the common failure where "make it better" produces sidewise movement instead of genuine improvement. Use when user says: refine this, iterate, make it better, run refinement cycles, improve this over multiple passes, keep improving, cycle through this, refine until good, multiple passes, polish this, iterate until done, run the loop, keep going until it's great, another pass, refine again. Do NOT activate for: first-draft generation, simple one-shot edits, structural rewrites that require rethinking from scratch. First response: "Iterative Refinement active. Paste the output to refine and describe what 'done' looks like — quality bar, inten

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

Sandeeprdy1729

Sandeeprdy1729/claude-design-skill

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Project Management SpecialistsBusiness and Financial Operations Occupations·SOC 13-1082

SKILL.md

readonly

More from this repository

same repository

constitutional-reasoning

Sandeeprdy1729/claude-design-skill

Self-critique and Constitutional AI reasoning skill. Makes Claude evaluate its own outputs against a set of user-defined or auto-generated principles, then revise until the output satisfies all of them. Reduces hallucination, over-confidence, and sycophancy by forcing Claude to argue against its own answer before finalising. Generates a principle set from the user's domain, runs critique passes, surfaces violations, revises, and repeats until no principles are violated or the user accepts the output. Use when user says: critique your own answer, check yourself, apply your principles, constitutional AI, self-review, fact-check this, argue against your own output, steelman the opposite, what are you getting wrong, is this actually correct, audit your answer, find your own mistakes, what assumptions are you making, reduce hallucination, double-check yourself, run a critique pass, apply a rubric. Do NOT activate for: creative work where principles would suppress quality, requests that explicitly want a single con

2026-05-263

constraint-solver

Sandeeprdy1729/claude-design-skill

Constraint-based problem solving skill. Finds elegant solutions when the design space is heavily restricted — budget caps, time limits, technology mandates, team size, ethical bounds, regulatory requirements. Treats constraints as the design material, not the obstacle. Surfaces constraint violations early, ranks constraints by hardness, and finds solutions that satisfy all hard constraints while optimizing within soft ones. The tighter the constraints, the sharper the solution. Use when user says: very limited budget, we can't use X, strict deadline, only N people, regulatory constraint, tech stack is fixed, solve with these restrictions, must work within these limits, strong constraints, can't change the requirements, work within the box, solve this but we can only, tiny budget, no budget, works with these limitations, solve under constraint. Do NOT activate for: open-ended problems with no constraints, problems where the first step is to challenge the constraints themselves (use pre-mortem instead). First r

2026-05-263

cross-domain-synthesis

Sandeeprdy1729/claude-design-skill

Cross-domain synthesis skill. Combines knowledge from completely different fields to generate novel, practical insights — not analogies for their own sake, but structural borrowings where the mechanism in domain A directly solves the problem in domain B. Activates when the user wants unconventional approaches, is stuck in their domain's standard thinking, or explicitly wants to borrow from another field. Finds the structural isomorphism — not just a surface metaphor. Use when user says: cross-domain, think outside my field, what would X think, borrow from another discipline, combine these fields, unconventional approach, think like a biologist / game designer / architect, apply X to Y, what does another field say about this, novel approach, think differently, synthesize across domains, first principles from another field. Do NOT activate for: domain-specific questions where conventional expertise is what the user actually needs, requests that are already cross-domain framed. First response: "Cross-Domain Synt

2026-05-263

large-doc-mastery

Sandeeprdy1729/claude-design-skill

Large document and codebase synthesis skill. Activates when the user provides 50k–200k+ tokens of context — codebases, PDFs, legal documents, transcripts, research corpora — and needs synthesis, cross-referencing, or insight extraction with perfect recall across the entire context. Not a summarizer. A precision instrument for finding patterns, contradictions, dependencies, and insights that only emerge when you hold the whole thing at once. Use when user says: analyze this codebase, read this whole document, find all references to X, synthesize across sections, what does this say about Y, find contradictions, extract all decisions, map the dependencies, read the whole thing, cross-reference, audit the entire document, what changed between sections, find every mention of, trace this through the code, what's missing. Do NOT activate for: small documents where a direct answer is more useful, tasks that don't require cross-document reasoning. First response: "Large Document Mode active. Paste or attach your docum

2026-05-263

precision-prompt-chaining

Sandeeprdy1729/claude-design-skill

Multi-step prompt chaining skill where each step's output becomes the next step's input, with explicit rules, constraints, and reference tokens between steps. Activates when the user needs to build a complex pipeline of dependent Claude calls — research → outline → draft → edit → publish — where downstream steps must be constrained by upstream outputs without hallucination or drift. Designs chains with named output variables, explicit pass rules, validation gates between steps, and failure recovery conditions. Use when user says: build a chain, multi-step prompt, pipeline of prompts, chain these steps, step by step with outputs, connect prompts, feed output into next prompt, automate a workflow, prompt pipeline, chained calls, sequential reasoning, dependent steps, chain of thought at scale, compound prompt. Do NOT activate for: single-turn questions, simple back-and-forth conversation, cases where one prompt is sufficient for the task. First response: "Prompt Chain Builder active. Describe the full workflow

2026-05-263

red-teaming

Sandeeprdy1729/claude-design-skill

Adversarial red-teaming skill for code, systems, strategies, and plans. Activates when the user wants their work attacked: finding security holes, edge cases, failure modes, logical flaws, incorrect assumptions, and risks they haven't considered. Different from pre-mortem (which focuses on pre-mortems for plans/proposals) — this skill covers technical systems, code correctness, API contracts, business logic, and strategies by explicitly playing the attacker, the adversarial user, or the skeptical engineer. Surfaces the most dangerous findings first. Use when user says: red team this, find the holes, attack this code, what could an attacker do, find the edge cases, break this, where does this fail, security review, find the bugs, what am I missing, adversarial review, how would you break this API, stress test, abuse cases, find the failure modes, exploit this, what's the worst that could happen, find the vulnerabilities, think like an attacker. Do NOT activate for: requests for improvements or feature suggesti

2026-05-263

name	iterative-refinement
description	Rapid iterative refinement skill. Runs 4–6 structured improvement cycles on any output — writing, code, strategy, design — without losing coherence, regressing previous improvements, or drifting from the original intent. Each cycle targets a specific refinement dimension, tracks deltas explicitly, and terminates when the output reaches a defined quality threshold. Prevents the common failure where "make it better" produces sidewise movement instead of genuine improvement. Use when user says: refine this, iterate, make it better, run refinement cycles, improve this over multiple passes, keep improving, cycle through this, refine until good, multiple passes, polish this, iterate until done, run the loop, keep going until it's great, another pass, refine again. Do NOT activate for: first-draft generation, simple one-shot edits, structural rewrites that require rethinking from scratch. First response: "Iterative Refinement active. Paste the output to refine and describe what 'done' looks like — quality bar, intended use, audience. I'll run targeted cycles and track deltas."
license	Apache 2.0

Iterative Refinement Loops

"Make it better" produces one of two failure modes: circular iteration (the output changes but doesn't improve, just moves sideways) or regression (fixing one dimension breaks another).

The solution is structured refinement: each cycle has a specific target dimension, an explicit delta from the previous version, and a quality gate. The model knows what it's optimizing for, knows what it changed, and knows when to stop.

SLASH COMMANDS

Command	Action
`/refine <output>`	Start a refinement loop with auto-selected dimensions
`/cycle <dimension>`	Run one targeted refinement cycle on a specific dimension
`/delta`	Show exactly what changed in the last cycle and why
`/score`	Score the current output against the quality target
`/target <description>`	Define or update the quality target
`/dimensions`	Show the active refinement queue and completed cycles
`/undo`	Revert to the previous cycle's output
`/lock <element>`	Lock a specific element — do not change this in future cycles
`/focus <dimension>`	Prioritize one dimension for the next N cycles
`/auto <n>`	Run n cycles automatically, picking the highest-value dimension each time
`/history`	Show all cycle deltas in sequence — full refinement log
`/done`	Declare the output final and output the refinement summary

HIGH-LEVEL WORKFLOW

User provides output and quality target
    │
    ├─ Phase 1: Baseline Assessment
    │     Score the input across all refinement dimensions
    │
    ├─ Phase 2: Dimension Prioritization
    │     Rank dimensions by gap from target and impact
    │
    ├─ Phase 3: Targeted Cycles
    │     Apply one cycle per dimension; track every delta
    │
    ├─ Phase 4: Regression Check
    │     Confirm each cycle didn't regress a previously-improved dimension
    │
    ├─ Phase 5: Quality Gate
    │     Score after each cycle; stop when target is met
    │
    └─ Phase 6: Refinement Summary
          Report what changed, what improved, and what was locked

PHASE 1 — REFINEMENT DIMENSIONS

Every output type has a set of refinement dimensions. Score each 1–5 before starting.

Writing dimensions

Dimension	Score 1	Score 5
Clarity	Reader must re-read to understand	First read is enough; meaning is immediate
Concision	Words don't earn their place	Every word is necessary
Impact	Opening and close are weak	First and last sentences are strongest
Specificity	Vague; could apply to anything	Concrete, specific, tied to this context
Flow	Sentence-to-sentence movement is rough	Transitions are invisible; reading is effortless
Tone	Doesn't match the target audience	Exactly right for the audience and purpose
Structure	Organization is unclear or wrong	Structure serves the reader's needs

Code dimensions

Dimension	Score 1	Score 5
Correctness	Has bugs	Handles all cases correctly
Readability	Hard to follow	Intent is obvious on first read
Robustness	Crashes on edge cases	Handles unexpected inputs gracefully
Performance	Obvious inefficiencies	Appropriate for the use case
Testability	Hard to test in isolation	Clean interfaces; easy to mock
Security	Obvious vulnerabilities	Input validated; no injection points

Strategy / plan dimensions

Dimension	Score 1	Score 5
Clarity of goal	Ambiguous success criteria	Concrete, measurable outcomes
Completeness	Missing key steps	Every necessary step is present
Risk coverage	Major risks unaddressed	Key risks named with mitigations
Feasibility	Resources or timeline unrealistic	Grounded in real constraints
Prioritization	All steps treated equally	Critical path is clear

PHASE 2 — CYCLE EXECUTION

Cycle structure

Each refinement cycle:

Identify the target dimension (highest gap × highest impact)
Describe the specific improvement before making it
Apply the improvement
Write the delta note — what changed and why
Run regression check — did this break anything previously improved?
Score the dimension — did it improve?

Cycle output format

CYCLE [N]: [dimension]
Target: [what this cycle is improving]
Gap before: [score]/5 → Target: [target score]/5

Changes made:
  · [specific change 1] — [why]
  · [specific change 2] — [why]

Delta:
  BEFORE: "[exact quote of changed section]"
  AFTER:  "[exact quote of new version]"

Regression check:
  [dimension previously improved]: [still holds / regressed — describe]

[Dimension] score: [before] → [after]

Cycle targeting rules

Never optimize two dimensions simultaneously in one cycle. Clarity + Tone in one cycle produces mediocre improvement in both.
Impact and opening/close first. For writing, the opening and closing sentences deliver the most return per cycle.
Correctness before readability. For code, never polish what might be wrong.
Lock wins. Once a dimension scores 5, mark it locked unless the user explicitly unlocks it.
Diminishing returns threshold. If two consecutive cycles on the same dimension produce less than 0.5 score improvement, move to the next dimension.

PHASE 3 — QUALITY GATE

After each cycle, calculate the overall quality score:

QUALITY GATE — CYCLE [N]

Scores:
  [Dimension 1]:  [N]/5  [LOCKED / ACTIVE / REGRESSED]
  [Dimension 2]:  [N]/5  [LOCKED / ACTIVE / REGRESSED]
  ...

Overall: [avg]/5
Target:  [user-defined threshold]/5

Status: CONTINUE | DONE | REGRESSION DETECTED

Stop conditions

Done: Overall score ≥ target threshold (default: 4.2/5)
Done: All active dimensions locked (all scored ≥ 4.5)
Stop and review: Any dimension regressed after being locked
Stop and reframe: 3+ consecutive cycles with < 0.3 total improvement

Regression handling

If a cycle causes a regression:

Immediately revert to previous cycle's output
Re-run the cycle with a tighter constraint: "Improve [dimension] without touching [locked dimensions]"
If regression persists after 2 attempts, surface the tension explicitly: "Improving [A] conflicts with [B] because [reason]. Which takes priority?"

PHASE 4 — DIMENSION-SPECIFIC TECHNIQUES

Clarity cycles

Replace abstract nouns with concrete verbs: "the implementation" → "the function that..."
Split sentences that contain more than one idea
Move the main clause first; subordinate clauses after
Replace "this," "it," "they" with the actual noun when the referent is more than 2 sentences back

Concision cycles

Remove every word that does not change meaning if deleted
Remove softeners: "somewhat," "quite," "rather," "a bit"
Remove throat-clearing openers: "It is important to note that," "As we can see,"
Replace prepositional phrases with a single word: "in the event that" → "if"
Merge two sentences that make the same point

Impact cycles

Move the most important sentence first in every paragraph
End the piece with the highest-stakes sentence, not a summary
Find the most generic sentence and make it the most specific
Find the most passive sentence and make it active

Specificity cycles

Replace every adjective that could apply to anything with one that couldn't
Add a number where an amount is described: "many users" → "72% of users"
Name the specific mechanism: "it improves performance" → "it reduces round trips by eliminating..."
Ground the abstract: "a better experience" → "opens in under 200ms"

PHASE 5 — REFINEMENT SUMMARY

When the loop completes:

REFINEMENT COMPLETE

Cycles run: [N]
Total iterations: [N]

Quality progression:
  Cycle 0 (baseline): [N]/5
  Cycle 1: [N]/5 (+[delta]) — [dimension improved]
  Cycle 2: [N]/5 (+[delta]) — [dimension improved]
  ...
  Final: [N]/5

Dimensions locked: [list with final scores]
Dimensions not reached: [list with current scores — why not improved]

Most impactful change: [which cycle, which dimension, what changed]
What held back further improvement: [honest assessment of ceiling]