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.
Construct, critique, and audit arguments using the complete methodology from Weston's "A Rulebook for Arguments".
$ npx skills add gnurio/nurijanian-skills --skill rulebook-for-arguments -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install gnurio/nurijanian-skills rulebook-for-arguments --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ 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-srcUse ~/.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/
Install the "rulebook-for-arguments" agent skill from https://github.com/gnurio/nurijanian-skills/tree/main/skills/rulebook-for-arguments into .claude/skills/rulebook-for-arguments/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "rulebook-for-arguments", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/gnurio/nurijanian-skills/tree/main/skills/rulebook-for-argumentsType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add gnurio/nurijanian-skills --skill rulebook-for-arguments -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install gnurio/nurijanian-skills rulebook-for-arguments --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/gnurio/nurijanian-skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/rulebook-for-arguments .agents/skills/rulebook-for-arguments && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "rulebook-for-arguments" agent skill from https://github.com/gnurio/nurijanian-skills/tree/main/skills/rulebook-for-arguments into .agents/skills/rulebook-for-arguments/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "rulebook-for-arguments", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add gnurio/nurijanian-skills --skill rulebook-for-arguments -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install gnurio/nurijanian-skills rulebook-for-arguments --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/gnurio/nurijanian-skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/rulebook-for-arguments .cursor/skills/rulebook-for-arguments && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "rulebook-for-arguments" agent skill from https://github.com/gnurio/nurijanian-skills/tree/main/skills/rulebook-for-arguments into .cursor/skills/rulebook-for-arguments/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "rulebook-for-arguments", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/gnurio/nurijanian-skills.git --path skills/rulebook-for-arguments--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add gnurio/nurijanian-skills --skill rulebook-for-arguments -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install gnurio/nurijanian-skills rulebook-for-arguments --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/gnurio/nurijanian-skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/rulebook-for-arguments .gemini/skills/rulebook-for-arguments && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "rulebook-for-arguments" agent skill from https://github.com/gnurio/nurijanian-skills/tree/main/skills/rulebook-for-arguments into .gemini/skills/rulebook-for-arguments/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "rulebook-for-arguments", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install gnurio/nurijanian-skills rulebook-for-argumentsInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add gnurio/nurijanian-skills --skill rulebook-for-arguments -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/gnurio/nurijanian-skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/rulebook-for-arguments .github/skills/rulebook-for-arguments && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "rulebook-for-arguments" agent skill from https://github.com/gnurio/nurijanian-skills/tree/main/skills/rulebook-for-arguments into .github/skills/rulebook-for-arguments/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "rulebook-for-arguments", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add gnurio/nurijanian-skills --skill rulebook-for-arguments -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install gnurio/nurijanian-skills rulebook-for-arguments --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/gnurio/nurijanian-skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/rulebook-for-arguments .opencode/skills/rulebook-for-arguments && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "rulebook-for-arguments" agent skill from https://github.com/gnurio/nurijanian-skills/tree/main/skills/rulebook-for-arguments into .opencode/skills/rulebook-for-arguments/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "rulebook-for-arguments", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
rulebook-for-argumentsConstruct, 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". 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.
4 steps, taken from the first numbered list in SKILL.md.
Read from SKILL.md and the folder at commit 43a0566. It shows what the files ask for, not the result of running them.
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.
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.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
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.
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.
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.
The full file from gnurio/nurijanian-skills at commit 43a0566, republished under its MIT licence (© gnurio). 3,456 words, ~6,491 tokens.
.claude/skills/rulebook-for-arguments/SKILL.md (or your agent's skills folder).You are now operating as a master of structured argumentation trained on the complete methodology of A Rulebook for Arguments (Weston). You can:
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.
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.
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.
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:
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.
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.
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.
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:
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.
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.
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.
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.
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.
These are structurally invalid argument moves. Learning to name them is the first step to refuting them.
| Fallacy | Definition | How to spot it |
|---|---|---|
| Ad hominem | Attacking the person rather than the argument | "You can't trust X's argument because X is [personal attribute]" |
| Ad ignorantiam | Claiming something is true because it hasn't been proved false | "No one has disproved it, therefore it's true" |
| Ad misericordiam | Using a sob story as an argument for special treatment | Emotional appeal substituted for logical reason |
| Ad populum | Appealing to crowd emotion or popular opinion | "Everyone believes X, so X must be true" |
| Affirming the consequent | If P then Q; Q; therefore P — invalid form | Overlooks that Q might have other causes besides P |
| Begging the question (petitio principii) | Implicitly using the conclusion as a premise | The argument assumes what it is trying to prove |
| Circular argument | A form of begging the question — conclusion restates the premise | Start and end in the same place |
| Complex question | Framing a question so any answer affirms a hidden premise | "Have you stopped cheating?" — both yes/no are damning |
| Denying the antecedent | If P then Q; not-P; therefore not-Q — invalid form | Overlooks that Q might hold for other reasons |
| Equivocation | Using the same word with two different meanings in the same argument | Key term shifts meaning between premise and conclusion |
| False cause | Drawing a questionable causal conclusion | Any of the errors in Rules 18–21 |
| False dilemma | Reducing the options to only two when more exist | "Love it or leave it" — ignores middle ground |
| Loaded language | Language that primarily plays on emotions rather than providing evidence | Violates Rule 5 — substitutes overtone for substance |
| Non sequitur | Conclusion doesn't follow from the evidence | The premises are irrelevant to the conclusion |
| Overgeneralizing | Drawing a broad conclusion from too few or non-representative examples | Violates Rules 7–8 |
| Overlooking alternatives | Assuming only one explanation when multiple are possible | Classic error in causal reasoning (Rule 19) and false dilemmas |
| Persuasive definition | Defining a term in a loaded way to win by assumption | "Evolution is the atheistic view" — bias is built into the definition |
| Red herring | Introducing an irrelevant topic to distract from the real issue | The introduced topic doesn't bear on the actual question |
| Straw man | Misrepresenting an opposing view to make it easier to attack | Refuting a position the opponent doesn't actually hold |
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.
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]Go through every dimension systematically:
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]Follow the full Rules 29–39 workflow:
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)
Step 2 — Build Position B (complete BUILD mode)
Step 3 — AUDIT both arguments For each side:
Step 4 — Compare and conclude
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]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
Just SKILL.md in skills/rulebook-for-arguments of gnurio/nurijanian-skills.
Open the folder on GitHubat commit 43a0566
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.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Rulebook For Arguments this skillgnurio/nurijanian-skills | 124 | — | ~6.5k | Automated safety check: Pass | MIT | |
| Writing Livekit Scenarioslivekit-examples/agent-starter-python | 264 | 1 repos | ~2.5k | Automated safety check: Pass | MIT | |
| Go Testingcxuu/golang-skills | 173 | 1 repos | ~1.3k | Automated safety check: Pass | Apache-2.0 | |
| Goalcraftgrp06/goalcraft | 102 | — | ~3.8k | Automated safety check: Pass | MIT | |
| Thinking Partnermattnowdev/thinking-partner | 206 | — | ~4.4k | Automated safety check: Pass | MIT | |
| Visionkunchenguid/vision | 331 | — | ~2.9k | Automated safety check: Pass | MIT |
livekit-examples/agent-starter-python
Creates and maintains the scenarios a LiveKit agent simulation runs, and wires the agent to consume them.
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.
grp06/goalcraft
Turn a rough draft, vague ambition, or messy task brief into a powerful Codex /goal objective for persistent, evidence-checked work.
mattnowdev/thinking-partner
A deterministic thinking partner that challenges assumptions and applies mental models to sharpen decisions, solve problems, and think more clearly.
kunchenguid/vision
Draft and stress-test a VISION.md for a repository, then iterate with the author on an interactive review board until approved.
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.
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.
gnurio/nurijanian-skills
Find, diagnose, and fix misalignment in corporate settings. An agent skill from gnurio/nurijanian-skills.
gnurio/nurijanian-skills
Generate diverse outputs by prompting for a probability distribution instead of a single response.
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.
gnurio/nurijanian-skills
PM alignment coach and router. An agent skill from gnurio/nurijanian-skills.
gnurio/nurijanian-skills
Analyze technology announcements to surface non-obvious strategic implications using Verbalized Sampling.
Categories
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".
Rulebook For Arguments fits situations like: building a position; stress-testing logic; identifying fallacies; writing argumentative essays.
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.
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.
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.
SKILL.md names no scripts, command-line tools or credentials: Rulebook For Arguments is instructions for the agent only.
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.
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.
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.
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.
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.
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.