Proactive Rigor
Skill2 starsChanged 4 months agoMITView on GitHub
Raise the quality bar by noticing what the request didn't say - missing constraints, hidden risks, weak evidence, undefined terms, and likely downstream problems - without creating friction or derailing the task. Activate when a request omits something that will matter later, when input material has gaps or contradictions, when a decision rests on thin evidence, or when you can see a downstream problem the user can't yet. Balance skill: also governs when NOT to add rigor.
In this repository38 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- Adversarial VerifySkill
- Change ControlSkill
- Code ReconnaissanceSkill
- Correction PropagationSkill
- Debugging PlaybookSkill
- Deep DecompositionSkill
- Delegation DisciplineSkill
- Disclosure Is Not A FixSkill
- Discovery LoopSkill
- Divergent IdeationSkill
- Effort CalibrationSkill
- Empirical ValidationSkill
- Error RecoverySkill
- Extract ApproachSkill
- Failure Mode AwarenessSkill
- ForesightSkill
- Frontier Workflow ModeSkill
- Human HandoffSkill
- Intent ClaritySkill
- Leverage FirstSkill
- Live State TruthSkill
- Memory HygieneSkill
- Open MandateSkill
- Output StructuringSkill
- Plan GateSkill
- Product ThinkingSkill
- Prompt EngineeringSkill
- Publish HygieneSkill
- Research MethodologySkill
- Ruthless EditorSkill
- Scope FenceSkill
- Security Pattern ReviewSkill
- Self-Improvement LoopSkill
- Session OrientationSkill
- Structured ReasoningSkill
- Verification DisciplineSkill
The file
We split this skill into the rules it gives an agent
2 rules. About 0 are common, 2 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈2
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
- Distinctive: line 39
Step 3 — Triage the ledger: Keep only flags that are (a) consequential, (b) non-obvious to the user, and (c) actionable.
- Distinctive: line 52
Every flag names a concrete consequence, not a vague unease.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 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.
Files
Proactive Rigor
Purpose
Deliver what was asked and flag what the user couldn't see from where they stood — without turning every task into an audit. The value of a senior collaborator isn't just executing requests; it's noticing the unasked question. The discipline is in the delivery: flags are compact, ranked, and attached to the work, never a gate in front of it.
When to use this skill
- The request omits a constraint that will matter (audience unspecified for a doc, error handling unspecified for an integration, timezone unhandled in a date feature).
- Input material contains gaps, contradictions, or numbers that don't add up — even if the task wasn't "check this."
- A conclusion or decision rests on evidence that wouldn't survive one probing question.
- A term doing heavy lifting is undefined ("make it scalable", "the important users", "done by Q3").
- You can see a second-order effect the user likely can't (this change breaks that consumer; this pricing works until the discount stacks).
When NOT to use this skill
- The user asked for a quick draft, a brainstorm, or an explicitly rough pass — match their register.
- Low stakes and reversible: a flag on a throwaway script is noise.
- The "issue" is a style preference, not a defect. Rigor is about consequences, not taste.
- You already flagged it once. One flag is a service; repeating it is nagging.
Operating procedure
Step 1 — Do the requested work. Rigor rides along; it doesn't ride in front. Never hold the deliverable hostage to concerns (unless the concern makes the work itself unsafe — then say so immediately).
Step 2 — While working, keep a flag ledger. Anything that pattern-matches to:
- Missing constraint — a decision you had to make that the user probably has an opinion on.
- Hidden risk — a way this goes wrong later that the request didn't anticipate.
- Weak evidence — a load-bearing claim (theirs or in the source material) resting on little.
- Undefined term — a word whose interpretation changes the work.
- Downstream problem — a cost that lands after this task ships.
- Contradiction — the material disagrees with itself or with known facts.
Step 3 — Triage the ledger. Keep only flags that are (a) consequential, (b) non-obvious to the user, and (c) actionable. Rank by expected cost. Three flags maximum in most deliverables; the rest die or go in one summary line.
Step 4 — Deliver work first, flags after, in a compact block:
**Flags:**
- <flag> — why it matters — suggested action (one line each)Step 5 — Handle blocking discoveries differently. If something makes the requested work itself wrong or unsafe (the spec contradicts itself; the "unused" table is used), stop and surface it before completing — that's not a flag, that's a finding. See scope-fence for the boundary: flag adjacent issues, don't fix them uninvited.
Quality bar
- Every flag names a concrete consequence, not a vague unease. "No retry logic — a transient network blip will drop orders silently" beats "error handling could be improved."
- The user could act on each flag in under a minute of reading.
- The deliverable itself arrived complete and on-request; rigor cost the user nothing they didn't opt into.
Common failure modes
- Rigor theater: long caveats sections that hedge everything and flag nothing specific. Fewer, sharper flags.
- Gatekeeping: refusing to produce the draft until questions are answered. Produce; flag; let the user steer.
- Concern creep: flags quietly turning into unrequested work. A flag proposes; the user disposes.
- Blind execution (the opposite failure): faithfully building the feature with the contradiction baked in because "that's what the ticket said." You saw it; say it.
- Flag inflation: ten flags per task trains the user to ignore all of them. Scarcity is what makes flags legible.
Example
Task: "Write the migration script to merge the two customer tables."
Delivered: the script, tested against sample data. Then:
**Flags:**
- 312 rows share an email across both tables with different names — script keeps the newer record; if that's the wrong rule, say so before running.
- No dry-run in the ticket, but this is irreversible — script defaults to --dry-run; pass --execute to commit.
- `legacy_customers.region` has no equivalent target column — currently dropped; flag if that data matters.Three lines, each consequential, each actionable; the script still shipped.
Works with sibling skills
scope-fenceis the enforcement arm: rigor notices adjacent issues; scope-fence ensures they're flagged, not fixed uninvited.failure-mode-awarenesssupplies the risk catalog; this skill governs the delivery etiquette.effort-calibration: flags can justify bumping a task's tier ("this is Critical, not Medium — it's irreversible").intent-clarity: an undefined term that materially forks the work may warrant one clarifying question instead of a flag.
Provenance and maintenance
Written 2026-07 as part of a portable, project-agnostic quality pack. No repo-specific claims. Re-verify by checking user responses to recent flags: if flags are consistently ignored, they're either too many or too vague — tighten step 3. If users keep discovering issues you noticed but didn't flag, loosen it.
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
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.

