Agent skill

Transaction Protocol Reasoning

by benchflow-ai in benchflow-ai/skillsbench

Teaches how to reason from a transaction protocol’s rules to a working model.

Apache-2.0Auto-check passed

Install Transaction Protocol Reasoning

skills CLI
$ npx skills add benchflow-ai/skillsbench --skill transaction-protocol-reasoning -a claude-code

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

GitHub CLI
$ gh skill install benchflow-ai/skillsbench transaction-protocol-reasoning --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/benchflow-ai/skillsbench.git skills-src && mkdir -p .claude/skills && cp -r skills-src/tasks/tictoc-unnecessary-abort-detection/environment/skills/transaction-protocol-reasoning .claude/skills/transaction-protocol-reasoning && 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
transaction-protocol-reasoning
GitHub stars
1.8k
Token cost
~1k tokens
SKILL.md length
365 words
Files
8 (incl. references)
Skills in repo
178
Repo updated
First seen
Licence
Apache-2.0

At a glance

Teaches how to reason from a transaction protocol’s rules to a working model.

  • Works in 6 steps: Extract the contract: what does… → Inventory state: list each field, its… → Restate rules: convert prose/pseudocode… → …
  • Analyzing a concurrency-control paper
  • SKILL.md covers What “done” looks like, Quick Reference (pick the next…, Protocol Ledger (the “shape… and Workflow (operational), plus 1 more section
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Transaction Protocol Reasoning is an agent skill from benchflow-ai/skillsbench. Teaches how to reason from a transaction protocol’s rules to a working model. Use when analyzing a concurrency-control paper, spec, or algorithm to identify state, metadata, invariants, operation rules, examples, counterexamples, guarantees, false aborts, unsafe commits, or tradeoffs before inspecting concrete traces.

Its SKILL.md is about 1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 8 other files, including reference files (for example `references/counterexample-construction.md`, `references/example-construction.md` and `references/invariant-extraction.md`).

The repository describes itself as: SkillsBench evaluates how well skills work and how effective agents are at using them. The licence is Apache-2.0.

When your agent uses it

  • Analyzing a concurrency-control paper
  • Algorithm to identify state
  • Operation rules
  • Counterexamples

Example prompts

  • “Use the transaction-protocol-reasoning skill to teach how to reason from a transaction protocol’s rules to a working model”
  • “/transaction-protocol-reasoning”

Workflow steps

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

  1. Extract the contract: what does “correct” mean and what is in-scope?
  2. Inventory state: list each field, its scope, and what history fact it is intended to prove.
  3. Restate rules: convert prose/pseudocode into explicit “if … then … else abort/block” rules.
  4. Derive invariants: state what must always be true if the rules are correct.
  5. Run the example pack: step through 3–6 tiny histories and apply the rules mechanically.
  6. Locate conservative vs unsafe edges

What it can do on your machine

Read from SKILL.md and the folder at commit 9a1f4dd. 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

Transaction Protocol Reasoning loads about 1k tokens when it runs, and up to ~6.7k if it reads all its reference files. Until then it costs about 88 tokens; SKILL.md has 365 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~88
When it runs · the whole SKILL.md, loaded when a task matches
~1k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~6.7k

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 benchflow-ai/skillsbench at commit 9a1f4dd, republished under its Apache-2.0 licence (© benchflow-ai). 365 words, ~1,027 tokens.

Download SKILL.mdSave it as .claude/skills/transaction-protocol-reasoning/SKILL.md (or your agent's skills folder). This skill also uses 7 other files; get the full folder from GitHub.
name
transaction-protocol-reasoning
description
Teaches how to reason from a transaction protocol’s rules to a working model. Use when analyzing a concurrency-control paper, spec, or algorithm to identify state, metadata, invariants, operation rules, examples, counterexamples, guarantees, false aborts, unsafe commits, or tradeoffs before inspecting concrete traces.

Transaction Protocol Reasoning

Use this skill when a protocol is already given (paper, spec, pseudocode, implementation notes) and you need to understand what it guarantees and how its rules imply commit/abort behavior.

This skill does not ask you to invent a protocol. It teaches how to read a protocol description as a set of rules, turn those rules into checkable predicates/invariants, and then reason about safety vs conservatism.

What “done” looks like

By the end you should have:

  • a one-page Protocol Ledger (state + rules + invariants)
  • a minimal example pack (3–6 tiny histories) that exercises boundaries
  • a clear statement of:
    • the protocol’s proof object (what metadata it relies on), and
    • its likely false-abort and unsafe-commit failure modes

Quick Reference (pick the next file to read)

If you need…Read
A step-by-step protocol reading workflowprotocol-analysis-workflow.md
Inventory protocol state + what each field provesstate-and-metadata-modeling.md
Restate read/write/validate/commit/abort as explicit rulesoperation-rule-analysis.md
Extract invariants from rules (and distinguish conservative ones)invariant-extraction.md
Build a small history suite that hits boundary behaviorexample-construction.md
Build minimal counterexamples (unsafe commit vs conservative abort)counterexample-construction.md
Compare two protocols by guarantees + metadata + allowed historiesprotocol-comparison.md

Protocol Ledger (the “shape ledger” equivalent)

Before you chase details, build a one-page protocol ledger:

text
Claimed guarantee:

Global state:
  - per-object metadata: ...
  - global clock/counters: ...

Per-transaction state:
  - read set entries: (key, version-id?, local ts fields?, ...)
  - write set entries: (key, buffered value?, lock?, ...)
  - timestamps: start_ts?, commit_ts?, bounds?

Operations (as rules/predicates):
  read(key): preconditions, version selection, metadata recorded/updated, failure modes
  write(key): ...
  validate(txn): ...
  commit(txn): ...
  abort/retry(txn): ...

Proof object:
  - what metadata/rules constitute the correctness argument?
  - what does the protocol “check” to justify commits?

If you cannot fill a ledger line item without hand-waving (“it probably…”), you have found an underspecified part of the protocol. That is often where conservative aborts come from.

Show full SKILL.md (136 more words)Show less

Workflow (operational)

  1. Extract the contract: what does “correct” mean and what is in-scope?
  2. Inventory state: list each field, its scope, and what history fact it is intended to prove.
  3. Restate rules: convert prose/pseudocode into explicit “if … then … else abort/block” rules.
  4. Derive invariants: state what must always be true if the rules are correct.
  5. Run the example pack: step through 3–6 tiny histories and apply the rules mechanically.
  6. Locate conservative vs unsafe edges:
    • conservative: rules reject a safe history (false abort / blocking)
    • unsafe: rules accept a history that violates the contract

Common Failure Modes To Look For

  • Metadata insufficiency: protocol needs old-version validity but stores only latest.
  • Scope mismatch: uses per-key evidence to enforce cross-key ordering claims.
  • Over-approx validation: uses a sufficient condition (safe) that is not necessary (causes false aborts).

© benchflow-ai, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 7 other files (references) in tasks/tictoc-unnecessary-abort-detection/environment/skills/transaction-protocol-reasoning of benchflow-ai/skillsbench.

  • SKILL.md
  • references/counterexample-construction.md
  • references/example-construction.md
  • references/invariant-extraction.md
  • references/operation-rule-analysis.md
  • references/protocol-analysis-workflow.md
  • references/protocol-comparison.md
  • references/state-and-metadata-modeling.md

Open the folder on GitHubat commit 9a1f4dd

Compare with similar skills

Transaction Protocol Reasoning 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.

Transaction Protocol Reasoning compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Transaction Protocol Reasoning this skillbenchflow-ai/skillsbench1.8k—~1kAutomated safety check: PassApache-2.0
Deepseek Reasonruvnet/ruflo74k—~626Automated safety check: NotesMIT
Teachcursor/plugins10k9 repos~1.4kAutomated safety check: PassNone
Crossframe Teachsickn33/agentic-awesome-skills47k1 repos~943Automated safety check: PassMIT
Teachvinvcn/mattpocock-skills-zh-CN4.7k—~1.4kAutomated safety check: PassMIT
Ejentum Reasoning Harnesssickn33/agentic-awesome-skills47k1 repos~1.9kAutomated safety check: PassMIT

Similar skills

  • Deepseek Reason

    ruvnet/ruflo

    Reasoning-mode completion against DeepSeek's deepseek-reasoner model (R1) via /v1/chat/completions.

    74k GitHub stars~626 tokensUpdated today
    AI & LLM EngineeringAuto-check: notes
  • Teach

    cursor/plugins

    Official

    Explain a body of work plainly so a person actually understands it.

    10k GitHub starsUsed in 9 repos~1.4k tokens
    EducationAuto-check passed
  • Crossframe Teach

    sickn33/agentic-awesome-skills

    A skill your agent uses when CrossFrame Suite routes explicit Chinese teaching of CrossFrame concepts, misreading boundaries, plain-language examples, signals, or exercises.

    47k GitHub starsUsed in 1 repo~943 tokens
    Writing & ContentAuto-check passed
  • Teach

    vinvcn/mattpocock-skills-zh-CN

    在这个工作区中教用户一个新技能或概念。

    4.7k GitHub stars~1.4k tokensUpdated 10 days ago
    Auto-check passed
  • Ejentum Reasoning Harness

    sickn33/agentic-awesome-skills

    MCP server exposing four cognitive harness modes (reasoning, code, anti-deception, memory).

    47k GitHub starsUsed in 1 repo~1.9k tokens
    DevelopmentAuto-check passed
  • Teach

    ccplugins/awesome-claude-code-plugins

    Teaches the Second Brain to recognize a new external data source.

    968 GitHub stars~5.9k tokensUpdated 1 mo ago
    Documents & OfficeAuto-check: notes

More from benchflow-ai/skillsbench

All 178 skills in this repo
  • Lean4 Memories

    benchflow-ai/skillsbench

    This skill should be used when working on Lean 4 formalization projects to maintain persistent memory of successful proof patterns, failed approaches, project conventions, and user preferences…

    1.8k GitHub stars~3.2k tokensUpdated 2 mo ago
    Auto-check passed
  • Senior Data Engineer

    benchflow-ai/skillsbench

    World-class data engineering skill for building scalable data pipelines, ETL/ELT systems, real-time streaming, and data infrastructure.

    1.8k GitHub stars~5.9k tokensUpdated 2 mo ago
    Auto-check passed
  • Ac Branch Pi Model

    benchflow-ai/skillsbench

    AC branch pi-model power flow equations (P/Q and |S|) with transformer tap ratio and phase shift, matching acopf-math-model.md and MATPOWER branch fields.

    1.8k GitHub stars~1.1k tokensUpdated 2 mo ago
    Auto-check passed
  • Civ6lib

    benchflow-ai/skillsbench

    Civilization 6 district mechanics library. An agent skill from benchflow-ai/skillsbench.

    1.8k GitHub stars~1.7k tokensUpdated 2 mo ago
    Auto-check passed
  • D3 Visualization

    benchflow-ai/skillsbench

    Build deterministic, verifiable data visualizations with D3.js (v6).

    1.8k GitHub stars~1.5k tokensUpdated 2 mo ago
    Auto-check passed
  • Dc Power Flow

    benchflow-ai/skillsbench

    DC power flow analysis for power systems. An agent skill from benchflow-ai/skillsbench.

    1.8k GitHub stars~717 tokensUpdated 2 mo ago
    Auto-check passed

Questions about Transaction Protocol Reasoning

What does Transaction Protocol Reasoning do?

Teaches how to reason from a transaction protocol’s rules to a working model. Transaction Protocol Reasoning is an agent skill from benchflow-ai/skillsbench. Teaches how to reason from a transaction protocol’s rules to a working model.

When should I use Transaction Protocol Reasoning?

Transaction Protocol Reasoning fits situations like: analyzing a concurrency-control paper; algorithm to identify state; operation rules; counterexamples.

How do I install Transaction Protocol Reasoning in Claude Code?

Run `npx skills add benchflow-ai/skillsbench --skill transaction-protocol-reasoning -a claude-code`. Or copy the skill folder (tasks/tictoc-unnecessary-abort-detection/environment/skills/transaction-protocol-reasoning in benchflow-ai/skillsbench) into .claude/skills/transaction-protocol-reasoning in your project. Claude Code loads it when a task matches its description.

How do I install Transaction Protocol Reasoning in Codex?

Run `npx skills add benchflow-ai/skillsbench --skill transaction-protocol-reasoning -a codex`. Or copy the skill folder (tasks/tictoc-unnecessary-abort-detection/environment/skills/transaction-protocol-reasoning in benchflow-ai/skillsbench) into .agents/skills/transaction-protocol-reasoning in your project. Codex loads it when a task matches its description.

Can I use Transaction Protocol Reasoning 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 benchflow-ai/skillsbench --skill transaction-protocol-reasoning -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/transaction-protocol-reasoning, .gemini/skills/transaction-protocol-reasoning, .github/skills/transaction-protocol-reasoning and .opencode/skills/transaction-protocol-reasoning in your project.

What does Transaction Protocol Reasoning need to run?

SKILL.md names no scripts, command-line tools or credentials: Transaction Protocol Reasoning is instructions for the agent only.

Does Transaction Protocol Reasoning 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 Transaction Protocol Reasoning 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 Transaction Protocol Reasoning use?

Transaction Protocol Reasoning is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Transaction Protocol Reasoning use?

About 1k tokens (SKILL.md is roughly 4.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 5.7k tokens, read only when the agent opens those files.

What are the alternatives to Transaction Protocol Reasoning?

Skills that share tags, products or a category with Transaction Protocol Reasoning: Deepseek Reason (ruvnet/ruflo, 74k stars), Teach (cursor/plugins, 10k stars), Crossframe Teach (sickn33/agentic-awesome-skills, 47k stars) and Teach (vinvcn/mattpocock-skills-zh-CN, 4.7k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Transaction Protocol Reasoning?

benchflow-ai (a GitHub organization) maintains it in benchflow-ai/skillsbench, which has 1,832 GitHub stars. The repository holds 178 skills in this directory. The repository was last updated on July 23, 2026.

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