Agent skill

Rulebook For Arguments

by gnurio in gnurio/nurijanian-skills

Construct, critique, and audit arguments using the complete methodology from Weston's "A Rulebook for Arguments".

MITAuto-check passedTesting & QA

Install Rulebook For Arguments

skills CLI
$ npx skills add gnurio/nurijanian-skills --skill rulebook-for-arguments -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install gnurio/nurijanian-skills rulebook-for-arguments --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/gnurio/nurijanian-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/rulebook-for-arguments .claude/skills/rulebook-for-arguments && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
rulebook-for-arguments
GitHub stars
124
Token cost
~6.5k tokens
SKILL.md length
3,456 words
Files
1
Skills in repo
15
Repo updated
First seen
Licence
MIT

At a glance

Construct, critique, and audit arguments using the complete methodology from Weston's "A Rulebook for Arguments".

  • Works in 4 steps: A causes B (your claim) → B causes A (reversed causation) → A third factor C causes both A and B → …
  • Building a position
  • SKILL.md covers What This Skill Does, Core Philosophy (from the book), THE COMPLETE RULEBOOK and OPERATING MODES — HOW TO RUN…, plus 2 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Rulebook For Arguments is an agent skill from gnurio/nurijanian-skills. Construct, critique, and audit arguments using the complete methodology from Weston's "A Rulebook for Arguments". Use when building a position, stress-testing logic, identifying fallacies, writing argumentative essays, or preparing for debate. Covers all 45 rules, 19 fallacies, 3 definition rules, deductive forms, causal reasoning, and analogy evaluation.

Its SKILL.md is about 6.5k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Testing & QA, covering Load testing. The repository describes itself as: Claude Code and Cursor skills for product managers — PM coaching, verbalized sampling, tech sensemaking, and more. The licence is MIT.

When your agent uses it

  • Building a position
  • Stress-testing logic
  • Identifying fallacies
  • Writing argumentative essays

Example prompts

  • “A Rulebook for Arguments”
  • “/rulebook-for-arguments”

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. A causes B (your claim)
  2. B causes A (reversed causation)
  3. A third factor C causes both A and B
  4. The correlation is coincidental

What it can do on your machine

Read from SKILL.md and the folder at commit 43a0566. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Rulebook For Arguments loads about 6.5k tokens when it runs. Until then it costs about 95 tokens; SKILL.md has 3,456 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~95
When it runs · the whole SKILL.md, loaded when a task matches
~6.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from gnurio/nurijanian-skills at commit 43a0566, republished under its MIT licence (© gnurio). 3,456 words, ~6,491 tokens.

Download SKILL.mdSave it as .claude/skills/rulebook-for-arguments/SKILL.md (or your agent's skills folder).
name
rulebook-for-arguments
description
Construct, critique, and audit arguments using the complete methodology from Weston's "A Rulebook for Arguments". Use when building a position, stress-testing logic, identifying fallacies, writing argumentative essays, or preparing for debate. Covers all 45 rules, 19 fallacies, 3 definition rules, deductive forms, causal reasoning, and analogy evaluation.
user-invocable
true
argument-hint
[MODE=build|audit|essay|debate] [TOPIC=<value>]

What This Skill Does

You are now operating as a master of structured argumentation trained on the complete methodology of A Rulebook for Arguments (Weston). You can:

  • BUILD — Construct a logically sound argument from scratch on any topic
  • AUDIT — Evaluate an existing argument for validity, soundness, fallacies, and weaknesses
  • ESSAY — Draft or improve an argumentative essay using the full extended-argument rules
  • DEBATE — Steelman both sides, then identify the stronger position with justification

Always identify which mode you're in at the start of your response. If the user hasn't specified, infer from context or ask in one sentence.


Core Philosophy (from the book)

An argument is not a verbal fight. It is a set of reasons offered in support of a conclusion — a means of inquiry that helps determine which views have the strongest support. Not all views are equal. The goal is to organize reasons clearly and fairly so others can evaluate them independently.

The two failure modes: (1) asserting conclusions without reasons, (2) substituting emotional language for evidence.


THE COMPLETE RULEBOOK

PART I — Short Arguments: General Rules (Rules 1–6)

Rule 1 — Identify premises and conclusion Every argument has a conclusion (what you're trying to prove) and premises (the reasons offered). Before anything else, know which is which. Label them explicitly if helpful. Watch for indicator words: "therefore," "so," "because," "since," "thus."

Rule 2 — Develop ideas in a natural order Structure so the line of thought unfolds clearly. In short arguments: either state the conclusion first then the reasons, or build premises toward the conclusion at the end. Never bury or reverse the logic without purpose.

Rule 3 — Start from reliable premises No matter how valid the reasoning, a weak conclusion follows from weak premises. Every premise needs to be either: (a) well-established fact, (b) reasonable assumption, or (c) defended by its own supporting argument. If you're uncertain about a premise, say so or defend it separately.

Rule 4 — Be concrete and concise Abstract, vague, or general terms weaken arguments. Use specific, measurable language. Eliminate padding — airy elaboration makes readers lose the thread. One clear claim > three fuzzy ones.

Rule 5 — Build on substance, not overtone Do not rely on emotionally charged words to do argumentative work. "Ruthless corporate greed" is not a reason; it is a label. Offer actual evidence and reasons. Language should clarify, not manipulate. This is the most violated rule in public discourse.

Rule 6 — Use consistent terms Use the same key terms throughout. Switching terms for the same concept breaks logical connections. If you use "liberty" in premise 1, don't switch to "freedom" in premise 3 unless you've established they mean the same thing here. Equivocation (sliding meanings) is a common fallacy lurking here.


PART II — Generalizations (Rules 7–11)

Generalizations argue from examples to a broad claim. They are inductive — strong, not certain.

Rule 7 — Use more than one example A single example provides almost no support for a generalization. One counterexample to your rule doesn't disprove it; one example doesn't prove it.

Rule 8 — Use representative examples Even many examples fail if they are not representative. A sample drawn from one group (e.g., only athletes, only one city, only one era) can't support a claim about all groups. Look for a genuine cross-section.

Rule 9 — Background rates may be crucial A vivid example is seductive but potentially misleading without the base rate. Always ask: hits ÷ total tries — not just how many times something happened, but how often it could have happened.

Four patterns that reveal a missing background rate:

  • The "vivid hit" trap: Someone shows one perfect result — ask how many attempts it took. An archer who hit the bullseye on attempt #1,000 is not impressive.
  • The "horoscope" loop: One prediction came true — but how many predictions were made total? One hit out of 30 tries is just chance.
  • The "Bermuda Triangle" error: Dozens of disappearances sounds alarming — but if hundreds of thousands of ships passed through safely, the rate is unremarkable.
  • The "doubling" deception: "Thefts doubled!" — check if it went from 1 to 2. Percentage changes are meaningless without the base number.

When auditing: if an argument uses a dramatic or vivid example without stating the base rate, flag it. The example may be misleading.

Rule 10 — Statistics need a critical eye Numbers look authoritative but can mislead. Ask: How was this measured? Who gathered it? Is it over-precise (false accuracy)? Is it based on extrapolation or guesswork? Is the comparison group the right one?

Rule 11 — Consider counterexamples Actively seek examples that contradict your generalization. If you find them, you must either (a) adjust or limit your claim, or (b) explain why those counterexamples don't apply. Ignoring counterexamples is intellectual dishonesty.


PART III — Arguments by Analogy (Rule 12)

Analogies argue: because X and Y are alike in known ways, they are likely alike in this new specific way.

Rule 12 — Analogies require relevantly similar examples The analogy doesn't need the two things to be identical — just relevantly similar to the conclusion you're drawing. Identify the key similarity and test whether it actually supports the specific claim. Irrelevant differences don't weaken analogies; relevant differences do.

How to evaluate an analogy: List (a) the key similarities, (b) any relevant differences. If relevant differences exist that break the connection being claimed, the analogy fails. If the similarities are surface-level or irrelevant to the conclusion, the analogy fails.


PART IV — Sources (Rules 13–17)

Rule 13 — Cite your sources Unless it's common knowledge, provide citations so others can verify. An uncited statistic is an assertion, not evidence.

Rule 14 — Seek informed sources Only use experts with the right background for the specific claim. A Nobel physicist opining on economic policy is not an authority on economics. Credentials must match the domain of the claim.

Rule 15 — Seek impartial sources Prefer sources without a direct stake in the outcome. A tobacco company's study on tobacco safety, a real estate agent's market assessment — these have built-in biases. Look for independent corroboration.

Rule 16 — Cross-check sources See if equally qualified authorities agree. If experts are sharply divided, you cannot confidently appeal to consensus — acknowledge the division and explain why you find one side more credible.

Rule 17 — Use the web with care The internet has no quality filter. Only rely on identifiable, independently reputable sources. Anonymous blogs, Wikipedia without verification, and viral statistics are not reliable premises.


PART V — Arguments about Causes (Rules 18–21)

Rule 18 — Causal arguments start with correlations Evidence for causation begins as a correlation (regular association between events A and B). Correlation is necessary but not sufficient for causation.

Rule 19 — Correlations may have alternative explanations Four possibilities when A and B correlate:

  1. A causes B (your claim)
  2. B causes A (reversed causation)
  3. A third factor C causes both A and B
  4. The correlation is coincidental

Always consider all four before concluding causation.

Rule 20 — Work toward the most likely explanation When multiple explanations exist, evaluate their plausibility. Which is most consistent with other known facts? Which requires fewer assumptions? You may need additional evidence to decide. State your uncertainty honestly.

Rule 21 — Expect complexity Most real-world causes are multi-factorial. Multiple causes can operate simultaneously, interact, and reinforce each other. Resist single-cause explanations for complex outcomes. Assign relative weight to contributing causes.


PART VI — Deductive Arguments (Rules 22–28)

A valid deductive argument is one where if the premises are true, the conclusion must be true. Unlike inductive arguments, validity is a structural property — you can assess it without knowing if the premises are actually true. A sound argument is valid AND has true premises.

Rule 22 — Modus ponens

If P then Q.
P.
∴ Q.

Example: If there are no chance factors in chess, chess is a game of pure skill. There are no chance factors in chess. Therefore, chess is a game of pure skill.

Rule 23 — Modus tollens

If P then Q.
Not-Q.
∴ Not-P.

Example (Sherlock Holmes): If the visitor were a stranger, the dog would have barked. The dog did not bark. Therefore, the visitor was not a stranger.

Rule 24 — Hypothetical syllogism

If P then Q.
If Q then R.
∴ If P then R.

Chain conditionals together. The middle term Q links P to R.

Rule 25 — Disjunctive syllogism

P or Q.
Not-P.
∴ Q.

Process of elimination. Note: the "or" must be exclusive — verify that both options cannot both be true.

Rule 26 — Dilemma

P or Q.
If P then R.
If Q then S.
∴ R or S.

Forces a conclusion regardless of which horn is true. Classic debate move — put your opponent in a lose-lose.

Rule 27 — Reductio ad absurdum

To prove P: assume Not-P.
Show Not-P leads to a contradiction or absurdity.
∴ P must be true.

Indirect proof. Establish a conclusion by showing its denial is impossible or self-defeating.

Rule 28 — Deductive arguments in several steps Complex arguments chain these forms together. Each step must be one of the valid forms above. Map the chain explicitly: each conclusion becomes a premise for the next step.


PART VII — Extended Arguments (Rules 29–33)

For complex topics that can't be settled in a paragraph.

Rule 29 — Explore the issue Before writing, read widely. Understand the strongest versions of all positions. Map the landscape of the debate. Know what has already been argued, conceded, and refuted.

Rule 30 — Spell out basic ideas as arguments Frame your core idea as an explicit argument: a short (3–5 premise) structured argument using the forms from Rules 1–28. This core argument becomes the skeleton of everything that follows.

Rule 31 — Defend basic premises with arguments of their own Any premise that a reasonable person might doubt needs its own supporting argument. Trace back as far as necessary. The extended argument is a network of connected shorter arguments.

Rule 32 — Consider objections Anticipate the strongest objections to your argument. Present them honestly and in their best form. Then answer them. Ignoring objections doesn't make them disappear — it makes your argument weaker.

Rule 33 — Consider alternatives If proposing a solution, show it's better than other plausible solutions. Demonstrating that a problem exists is insufficient — you must show your answer is superior. This may require revising your original conclusion.


PART VIII — Argumentative Essays (Rules 34–39)

Rule 34 — Jump right in Don't begin with "Throughout history..." or "Many people have debated..." Open with your argument. State the issue and your position immediately. The reader's time is valuable.

Rule 35 — Make a definite claim or proposal Be specific. "Something should be done about X" is not a thesis. "X should be done by Y because Z" is. Vague claims cannot be argued for or against — they are rhetorical fog.

Rule 36 — Your argument is your outline After a brief summary of the core argument (one paragraph), the body of the essay advances and defends each premise in turn. The argument's structure IS the structure of the essay. Don't pad with background that doesn't support a premise.

Rule 37 — Detail objections and meet them A good essay addresses the strongest counterarguments in full. This is not weakness — it demonstrates thorough thinking and makes your conclusion more persuasive. Place objections after establishing your case, not before.

Rule 38 — Get feedback and use it Arguments have blind spots invisible to the author. Feedback reveals where the logic is unclear, where premises need defense, and where objections haven't been addressed. Treat feedback as a reality check, not a threat.

Rule 39 — Modesty, please Conclude only what your argument actually establishes. Don't overclaim. If you've shown X is likely, don't claim certainty. The world is uncertain. Epistemic humility is a sign of rigorous thinking, not weakness.


PART IX — Oral Arguments (Rules 40–45)

Rule 40 — Reach out to your audience Know who you're speaking to. Tailor examples, vocabulary, and level of technicality to them. An argument perfectly crafted for academic philosophers fails in a town hall.

Rule 41 — Be fully present Oral arguments live and die on attention. Engage, don't recite. Respond to the room. Eye contact and genuine engagement signal confidence and conviction.

Rule 42 — Signpost your argument Tell the audience where you are in the argument: "First... Second... Finally..." This prevents them from getting lost as the argument builds. Oral arguments need more explicit signposting than written ones.

Rule 43 — Offer something positive Lead with what you are for, not just what you oppose. Purely critical arguments feel reactive. Make a positive case for your position.

Rule 44 — Use visual aids sparingly Only if they genuinely clarify the argument. Never let the visual aid become the presentation. A bad chart is worse than no chart.

Rule 45 — End in style The conclusion is what the audience remembers. Don't trail off. Return to your core claim, show what's been established, and give the audience something memorable — a call to action, a challenge, a vivid image that crystallizes the argument.


Show full SKILL.md (1,382 more words)Show less
APPENDIX I — The 19 Common Fallacies

These are structurally invalid argument moves. Learning to name them is the first step to refuting them.

FallacyDefinitionHow to spot it
Ad hominemAttacking the person rather than the argument"You can't trust X's argument because X is [personal attribute]"
Ad ignorantiamClaiming something is true because it hasn't been proved false"No one has disproved it, therefore it's true"
Ad misericordiamUsing a sob story as an argument for special treatmentEmotional appeal substituted for logical reason
Ad populumAppealing to crowd emotion or popular opinion"Everyone believes X, so X must be true"
Affirming the consequentIf P then Q; Q; therefore P — invalid formOverlooks that Q might have other causes besides P
Begging the question (petitio principii)Implicitly using the conclusion as a premiseThe argument assumes what it is trying to prove
Circular argumentA form of begging the question — conclusion restates the premiseStart and end in the same place
Complex questionFraming a question so any answer affirms a hidden premise"Have you stopped cheating?" — both yes/no are damning
Denying the antecedentIf P then Q; not-P; therefore not-Q — invalid formOverlooks that Q might hold for other reasons
EquivocationUsing the same word with two different meanings in the same argumentKey term shifts meaning between premise and conclusion
False causeDrawing a questionable causal conclusionAny of the errors in Rules 18–21
False dilemmaReducing the options to only two when more exist"Love it or leave it" — ignores middle ground
Loaded languageLanguage that primarily plays on emotions rather than providing evidenceViolates Rule 5 — substitutes overtone for substance
Non sequiturConclusion doesn't follow from the evidenceThe premises are irrelevant to the conclusion
OvergeneralizingDrawing a broad conclusion from too few or non-representative examplesViolates Rules 7–8
Overlooking alternativesAssuming only one explanation when multiple are possibleClassic error in causal reasoning (Rule 19) and false dilemmas
Persuasive definitionDefining a term in a loaded way to win by assumption"Evolution is the atheistic view" — bias is built into the definition
Red herringIntroducing an irrelevant topic to distract from the real issueThe introduced topic doesn't bear on the actual question
Straw manMisrepresenting an opposing view to make it easier to attackRefuting a position the opponent doesn't actually hold

APPENDIX II — Definitions (D1–D3)

D1 — When terms are unclear, get specific Find the core meaning (check a dictionary), then make it more precise for your specific context. Abstract terms that do double-duty (e.g., "freedom," "justice") need explicit scoping.

D2 — When terms are contested, work from clear cases A good definition must: (a) include what clearly fits, (b) exclude what clearly doesn't, (c) draw the most defensible line through contested cases, and (d) explain why that line makes sense.

D3 — Definitions don't replace arguments Defining "coffee" as a drug doesn't settle whether coffee should be regulated like a drug. Definitions clarify the terrain; arguments are still needed. Never treat a definitional move as if it wins the substantive debate.


OPERATING MODES — HOW TO RUN EACH MODE

MODE: BUILD an Argument
  1. Clarify the claim: Restate what is being argued for as a precise, specific conclusion (Rule 35). If it's vague, sharpen it first.
  2. Identify argument type: Is this primarily a generalization? An argument from analogy? A causal claim? A deductive argument? A proposal? Different types need different rules.
  3. Draft the core argument: 3–5 premises leading to the conclusion. Use a deductive form (Rules 22–28) where possible — they offer certainty rather than probability.
  4. Stress-test premises: Is each premise reliable (Rule 3)? Would a skeptic accept it? Which need sub-arguments?
  5. Check for fallacies: Run through the 19 fallacies. Does any premise or inference commit one?
  6. Consider objections and alternatives (Rules 32–33): What's the strongest counterargument? How does the argument survive it?
  7. Apply rule-by-rule checklist: Concrete language (R4)? No emotional substitution (R5)? Consistent terms (R6)? Representative evidence (R8)? Impartial sources (R15)?
  8. State the argument with appropriate modesty (Rule 39).

Output format for BUILD mode:

CLAIM: [precise conclusion]
ARGUMENT TYPE: [deductive / inductive generalization / analogy / causal]
CORE ARGUMENT:
  P1: ...
  P2: ...
  P3: ...
  ∴ C: [conclusion]
PREMISE DEFENSE: [which premises need support and why]
SOURCES NEEDED: [which premises require citations or expert backing — Rule 13]
STRONGEST OBJECTION: [stated fairly]
RESPONSE TO OBJECTION: [how the argument survives]
FALLACY CHECK: [any risks flagged]
CONFIDENCE: [what the argument establishes with what degree of certainty — be modest, Rule 39]

MODE: AUDIT an Argument

Go through every dimension systematically:

  1. Identify structure: What is the conclusion? What are the premises? Is the structure explicit or buried?
  2. Check validity: If deductive — does the form match Rules 22–28? Is it actually valid?
  3. Check premise reliability: Are premises well-established, assumed, or contested?
  4. Check argument type: Is it a generalization? Apply Rules 7–11. Is it an analogy? Apply Rule 12. Is it causal? Apply Rules 18–21.
  5. Scan for all 19 fallacies: Go through each. Name any found.
  6. Check language: Loaded language (R5)? Inconsistent terms / equivocation (R6)?
  7. Check sources: Cited? Informed? Impartial? Cross-checked (Rules 13–17)?
  8. Check counterarguments: Are objections considered (R32)? Alternatives addressed (R33)?
  9. Check modesty: Does the conclusion overclaim beyond what the argument establishes (R39)?

Output format for AUDIT mode:

VERDICT: [Sound / Valid but unsound / Invalid / Weak inductive]

STRUCTURE:
  Conclusion: ...
  Premises: P1, P2, P3...
  Implicit premises: ...

VALIDITY CHECK: [pass/fail with explanation]
PREMISE RELIABILITY: [each premise rated and commented]
FALLACIES FOUND: [list with specific location in argument]
LANGUAGE ISSUES: [loaded terms, equivocations]
SOURCE QUALITY: [assessment]
MISSING OBJECTIONS: [strongest counterargument not addressed]
OVERCLAIMING: [yes/no with specifics]

OVERALL: [summary assessment — what the argument actually establishes]
STRONGEST FIX: [the single most important repair]

MODE: ESSAY — Argumentative Writing

Follow the full Rules 29–39 workflow:

  1. Explore the issue (R29): Confirm you understand the full debate landscape.
  2. Draft core argument (R30): 3–5 premise skeleton argument first — this becomes the outline.
  3. Open with the argument (R34): No preamble, no "throughout history" — state the claim immediately.
  4. Make a definite claim (R35): Specific, falsifiable, arguable.
  5. Let argument = outline (R36): Each section of the essay defends one premise.
  6. Defend premises (R31): Sub-arguments for any premise a reader might doubt.
  7. Address objections (R32, R37): The strongest counterarguments, stated fairly, then rebutted.
  8. Consider alternatives (R33): Show why your solution beats alternatives.
  9. Conclude with modesty (R39): State exactly what has been established, no more.

MODE: DEBATE — Steelman Both Sides

Critical requirement: both sides must receive the full BUILD + AUDIT treatment. This is not a summary of common views — it is two complete arguments, each constructed as if you were an advocate for that side, then evaluated impartially.

Step 1 — Build Position A (complete BUILD mode)

  • State a precise, specific conclusion for Position A (Rule 35)
  • Write 3–5 premises supporting it (Rules 1–3)
  • Use the most valid deductive or strongest inductive form available (Rules 22–28)
  • State the most powerful objection to Position A and answer it (Rule 32)
  • Note what evidence or facts would strengthen Position A further

Step 2 — Build Position B (complete BUILD mode)

  • Do the same for Position B — same depth, same rigor
  • Do NOT reduce Position B to a caricature of Position A (straw man fallacy)
  • Present Position B's best evidence and strongest premises
  • State the most powerful objection to Position B and answer it (Rule 32)

Step 3 — AUDIT both arguments For each side:

  • Check for fallacies (run the 19-fallacy checklist)
  • Check premise reliability (Rule 3)
  • Check for overclaiming (Rule 39)
  • Check for missing alternatives (Rule 33)

Step 4 — Compare and conclude

  • Which side starts from more reliable/better-supported premises?
  • Which side has fewer undefended assumptions?
  • Which side better addresses objections?
  • Which side is more modest and precise in its claims?
  • Declare which argument is currently stronger and explain why in 2–3 sentences
  • If the debate is genuinely close, say so honestly — state what evidence would tip the balance (Rule 39)

Output format for DEBATE mode:

POSITION A: [precise claim]
  Core argument:
    P1: ...
    P2: ...
    P3: ...
    ∴ C: ...
  Best objection & response: ...
  Fallacies/weaknesses found: ...

POSITION B: [precise claim]
  Core argument:
    P1: ...
    P2: ...
    P3: ...
    ∴ C: ...
  Best objection & response: ...
  Fallacies/weaknesses found: ...

VERDICT: [which is stronger and why, with appropriate modesty]

QUALITY CHECKLIST — Run before finalizing any argument

  • Is the conclusion precise and specific? (R35)
  • Are all premises stated explicitly? (R1)
  • Does the reasoning flow naturally? (R2)
  • Are all premises reliable or defended? (R3)
  • Is the language concrete and concise? (R4)
  • Are we reasoning from substance, not emotional language? (R5)
  • Are key terms used consistently throughout? (R6)
  • If generalizing: multiple, representative examples with base rates? (R7–R10)
  • Counterexamples considered? (R11)
  • If analogy: relevant similarities checked, relevant differences addressed? (R12)
  • Sources cited, informed, impartial, cross-checked? (R13–R16)
  • If causal: four alternative explanations considered? (R18–R21)
  • If deductive: argument form is valid (Rules 22–28)?
  • Strongest objections addressed? (R32)
  • Alternatives compared? (R33)
  • No fallacies from the 19 (see table above)?
  • Conclusion is modest — claims only what the argument establishes? (R39)

INVOCATION EXAMPLES

Build: "Use rulebook-for-arguments to build an argument for a four-day work week." Audit: "Use rulebook-for-arguments to audit this argument: [paste argument]" Essay: "Use rulebook-for-arguments to help me write an argumentative essay on AI regulation." Debate: "Use rulebook-for-arguments to debate both sides of mandatory voting." Fallacy check: "Use rulebook-for-arguments to check this paragraph for fallacies: [paste text]" Deductive form: "Use rulebook-for-arguments to construct a modus tollens argument that X implies Y."

© gnurio, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/rulebook-for-arguments of gnurio/nurijanian-skills.

Open the folder on GitHubat commit 43a0566

Compare with similar skills

Rulebook For Arguments next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Rulebook For Arguments compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Rulebook For Arguments this skillgnurio/nurijanian-skills124—~6.5kAutomated safety check: PassMIT
Writing Livekit Scenarioslivekit-examples/agent-starter-python2641 repos~2.5kAutomated safety check: PassMIT
Go Testingcxuu/golang-skills1731 repos~1.3kAutomated safety check: PassApache-2.0
Goalcraftgrp06/goalcraft102—~3.8kAutomated safety check: PassMIT
Thinking Partnermattnowdev/thinking-partner206—~4.4kAutomated safety check: PassMIT
Visionkunchenguid/vision331—~2.9kAutomated safety check: PassMIT

Similar skills

  • Writing Livekit Scenarios

    livekit-examples/agent-starter-python

    Creates and maintains the scenarios a LiveKit agent simulation runs, and wires the agent to consume them.

    264 GitHub starsUsed in 1 repo~2.5k tokens
    Testing & QAAuto-check passed
  • Go Testing

    cxuu/golang-skills

    A skill your agent uses when writing, reviewing, or improving Go test code — including table-driven tests, subtests, parallel tests, test helpers, test doubles, and assertions with cmp.Diff.

    173 GitHub starsUsed in 1 repo~1.3k tokens
    Testing & QAAuto-check passed
  • Goalcraft

    grp06/goalcraft

    Turn a rough draft, vague ambition, or messy task brief into a powerful Codex /goal objective for persistent, evidence-checked work.

    102 GitHub stars~3.8k tokensUpdated 4 mo ago
    Testing & QAAuto-check passed
  • Thinking Partner

    mattnowdev/thinking-partner

    A deterministic thinking partner that challenges assumptions and applies mental models to sharpen decisions, solve problems, and think more clearly.

    206 GitHub stars~4.4k tokensUpdated 6 mo ago
    Testing & QAAuto-check passed
  • Vision

    kunchenguid/vision

    Draft and stress-test a VISION.md for a repository, then iterate with the author on an interactive review board until approved.

    331 GitHub stars~2.9k tokensUpdated 1 mo ago
    Testing & QAAuto-check passed
  • Volt Load Testing

    owenHochwald/volt

    Safely exercise and evaluate HTTP APIs with the Volt CLI, including authenticated requests, JSON bodies, staged load, machine-readable results, performance baselines, and before/after comparisons.

    141 GitHub stars~1.2k tokensUpdated 2 mo ago
    Testing & QAAuto-check passed

More from gnurio/nurijanian-skills

All 15 skills in this repo
  • Vibe Code Leaf Finder

    gnurio/nurijanian-skills

    This skill should be used when a user wants to identify which parts of a codebase are safe to modify with AI ("vibe code") and which require careful human engineering.

    124 GitHub stars~1.9k tokensUpdated 1 mo ago
    Auto-check: notes
  • Corporate Misalignment Finder

    gnurio/nurijanian-skills

    Find, diagnose, and fix misalignment in corporate settings. An agent skill from gnurio/nurijanian-skills.

    124 GitHub stars~2.1k tokensUpdated 1 mo ago
    Auto-check passed
  • Verbalized Sampling

    gnurio/nurijanian-skills

    Generate diverse outputs by prompting for a probability distribution instead of a single response.

    124 GitHub stars~2k tokensUpdated 1 mo ago
    Auto-check: warnings
  • Focal Point Finder

    gnurio/nurijanian-skills

    This skill should be used when someone needs to find, propose, or evaluate a focal point in a coordination, negotiation, or alignment problem.

    124 GitHub stars~3.2k tokensUpdated 1 mo ago
    Auto-check passed
  • Orchestrate Pm Alignment

    gnurio/nurijanian-skills

    PM alignment coach and router. An agent skill from gnurio/nurijanian-skills.

    124 GitHub stars~1.5k tokensUpdated 1 mo ago
    Auto-check passed
  • Tech Sensemaking

    gnurio/nurijanian-skills

    Analyze technology announcements to surface non-obvious strategic implications using Verbalized Sampling.

    124 GitHub stars~1.8k tokensUpdated 1 mo ago
    Auto-check passed

Categories

Questions about Rulebook For Arguments

What does Rulebook For Arguments do?

Construct, critique, and audit arguments using the complete methodology from Weston's "A Rulebook for Arguments". Rulebook For Arguments is an agent skill from gnurio/nurijanian-skills. Construct, critique, and audit arguments using the complete methodology from Weston's "A Rulebook for Arguments".

When should I use Rulebook For Arguments?

Rulebook For Arguments fits situations like: building a position; stress-testing logic; identifying fallacies; writing argumentative essays.

How do I install Rulebook For Arguments in Claude Code?

Run `npx skills add gnurio/nurijanian-skills --skill rulebook-for-arguments -a claude-code`. Or copy the skill folder (skills/rulebook-for-arguments in gnurio/nurijanian-skills) into .claude/skills/rulebook-for-arguments in your project. Claude Code loads it when a task matches its description.

How do I install Rulebook For Arguments in Codex?

Run `npx skills add gnurio/nurijanian-skills --skill rulebook-for-arguments -a codex`. Or copy the skill folder (skills/rulebook-for-arguments in gnurio/nurijanian-skills) into .agents/skills/rulebook-for-arguments in your project. Codex loads it when a task matches its description.

Can I use Rulebook For Arguments in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add gnurio/nurijanian-skills --skill rulebook-for-arguments -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/rulebook-for-arguments, .gemini/skills/rulebook-for-arguments, .github/skills/rulebook-for-arguments and .opencode/skills/rulebook-for-arguments in your project.

What does Rulebook For Arguments need to run?

SKILL.md names no scripts, command-line tools or credentials: Rulebook For Arguments is instructions for the agent only.

Does Rulebook For Arguments access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Rulebook For Arguments safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Rulebook For Arguments use?

Rulebook For Arguments is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Rulebook For Arguments use?

About 6.5k tokens (SKILL.md is roughly 26k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Rulebook For Arguments?

Skills that share tags, products or a category with Rulebook For Arguments: Writing Livekit Scenarios (livekit-examples/agent-starter-python, 264 stars), Go Testing (cxuu/golang-skills, 173 stars), Goalcraft (grp06/goalcraft, 102 stars) and Thinking Partner (mattnowdev/thinking-partner, 206 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Rulebook For Arguments?

gnurio (a GitHub user) maintains it in gnurio/nurijanian-skills, which has 124 GitHub stars. The repository holds 15 skills in this directory. The repository was last updated on August 13, 2026.

Source: gnurio/nurijanian-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.