Agent skill

Collab Proof

by alirezarezvani in alirezarezvani/claude-skills

A skill your agent uses when you want to understand what Claude contributed vs what you drove in a session.

MITAuto-check passedProduct & Project Management

Install Collab Proof

skills CLI
$ npx skills add alirezarezvani/claude-skills --skill collab-proof -a claude-code

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

GitHub CLI
$ gh skill install alirezarezvani/claude-skills collab-proof --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/alirezarezvani/claude-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/engineering/collab-proof/skills/collab-proof .claude/skills/collab-proof && 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
collab-proof
GitHub stars
28k
Token cost
~3.6k tokens
SKILL.md length
895 words
Files
5 (incl. references)
Skills in repo
342
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when you want to understand what Claude contributed vs what you drove in a session.

  • Works in 3 steps: Compute current Layer 01 signal level… → Score all four frames against what's… → Write a snapshot to…
  • You want to understand what Claude contributed vs what you drove in a session
  • SKILL.md covers Layer 01 — Signal detection, Layer 02 — WorkIntentClassifier, Layer 03 — Output and Honesty rules, plus 1 more section
  • Calls git and python3

What it does

Collab Proof is an agent skill from alirezarezvani/claude-skills. Use when you want to understand what Claude contributed vs what you drove in a session. Triggers on: /collab-proof, session retrospective, ai contribution analysis, collaboration evidence, what did claude do.

Its SKILL.md is about 3.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including reference files (for example `references/ai-collaboration-evidence.md`, `references/developer-portfolio-proof.md` and `references/session-documentation-patterns.md`).

It sits in Product & Project Management, covering Retrospectives. It works with Git. The repository describes itself as: 380 Claude Code skills & agent skills & plugins (30+ Agents, 70+ custom commands, 380+ skills, customizable references, scripts)for Claude Code, Codex, Gemini CLI, Cursor, and 8… The licence is MIT.

When your agent uses it

  • You want to understand what Claude contributed vs what you drove in a session
  • : /collab-proof
  • Session retrospective
  • Ai contribution analysis

Example prompts

  • “/collab-proof”

Requirements

  • Python 3

Workflow steps

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

  1. Compute current Layer 01 signal level from available context
  2. Score all four frames against what's visible now
  3. Write a snapshot to session-history/.tmp-TIMESTAMP.json

What it can do on your machine

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

    Shell commands in SKILL.md call:

    • git
    • python3

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

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    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

Collab Proof loads about 3.6k tokens when it runs, and up to ~7k if it reads all its reference files. Until then it costs about 55 tokens; SKILL.md has 895 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~55
When it runs · the whole SKILL.md, loaded when a task matches
~3.6k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~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 alirezarezvani/claude-skills at commit 19392f7, republished under its MIT licence (© alirezarezvani). 895 words, ~3,605 tokens.

Download SKILL.mdSave it as .claude/skills/collab-proof/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
collab-proof
description
Use when you want to understand what Claude contributed vs what you drove in a session. Triggers on: /collab-proof, session retrospective, ai contribution analysis, collaboration evidence, what did claude do.
license
MIT

collab-proof

Surfaces AI collaboration evidence the developer didn't consciously record. Vela 3-layer pipeline × ADHD 4-frame reasoning — prompt-native, zero dependencies.


Layer 01 — Signal detection

Run git log --oneline -10 and git diff --stat HEAD~3..HEAD first.

Classify signal level using this rubric (pick the highest that matches):

HIGH → full artifacts (DECISIONS.md + session-history + WORKLOG + HTML)

  • New file created, OR
  • 4+ files modified, OR
  • Explicit option comparison in conversation ("vs", "instead of", "chose X over Y"), OR
  • Design discussion lasted 15+ exchanges, OR
  • Bug with root cause diagnosis — conversation contains WHY the bug happened (not just "fixed X" but "the bug was caused by Y because Z")

BUG_FIXING special rule — override file count: Even if only 1 file changed, classify as HIGH if the conversation contains:

  • Root cause explanation ("the bug was...", "this happened because...", "the issue is...")
  • Diagnosis process ("I checked...", "turned out...", "the problem was...")
  • Fix rationale ("chose this approach because...", "instead of X, used Y because...") File count doesn't matter for bugs — a well-diagnosed single-file fix is more valuable than a 10-file feature with no discussion.

MEDIUM → WORKLOG only

  • 1–3 files modified with no root cause discussion, OR
  • Minor feature added, no tradeoffs discussed

LOW → silence, tell user "Routine session — nothing recorded."

  • No code changes, only planning/discussion, OR
  • Single trivial change with no context ("change this text", "fix typo", "rename variable")

Show the user: Signal: HIGH / MEDIUM / LOW — [one-line reason]


Layer 02 — WorkIntentClassifier

Run all four frames simultaneously against conversation context + git diff. Score each frame 0.0–1.0 using the rubric below. Then apply pruning and classification rules.

Frame scoring rubric

Frame A — Technical (code churn complexity)

  • 1.0 New module/file created, complex logic added (state machine, Lua script, novel algorithm)
  • 0.5 Existing function logic modified, simple API endpoint added
  • 0.1 Typo fix, comment change, plain text edit

Frame B — Uncertainty (developer doubt signals)

  • 1.0 Code written then fully rolled back, explicit doubt expressed ("이게 맞나?", "동작 안 하네"), git revert
  • 0.5 Advice sought from Claude mid-implementation, 2+ revision requests on same area
  • 0.0 Uninterrupted directive execution — developer knew exactly what to build

Frame C — Fork (decision branch presence)

  • 1.0 Two or more alternatives explicitly compared in conversation (A vs B)
  • 0.5 No explicit comparison but tradeoff mentioned (performance vs readability)
  • 0.0 Single standard approach applied, no alternatives considered

Frame D — AI contribution (Claude's actual impact)

  • 1.0 Claude identified a bug/edge case the developer hadn't noticed and proposed the fix
  • 0.6 Claude generated structural boilerplate/skeleton that significantly accelerated execution
  • 0.2 Claude reformatted or transcribed developer-directed code without independent contribution

Pruning rule

Prune any frame scoring < 0.4.

Exception — High-Speed Execution Guard: If Frame A >= 0.8 AND Frame D >= 0.6, do NOT prune and do NOT silence the session, even if Frame B = 0.0 and Frame C = 0.0. This is a boilerplate-heavy FEATURE_BUILDING session. Classify immediately as FEATURE_BUILDING with HIGH signal. Rationale: zero uncertainty in a fast-moving session is a feature, not a reason to discard it.


Intent classification
Surviving framesDominant intentMeaning
A high + D mid-high (B, C low)FEATURE_BUILDINGHigh-velocity feature generation, Claude scaffolding
B high + A/D highBUG_FIXING or STUCKActive debugging or unresolved looping
C high + A highREFACTORING or EXPLORINGArchitecture exploration, weighing alternatives
All frames < 0.4FLOW_STATE or LOWRoutine typing, silence unless Layer 01 was HIGH

If multiple intents tie, pick the one with the highest combined frame score. Record the runner-up — it belongs in the session narrative.


Show full SKILL.md (334 more words)Show less
Internal output format

Before proceeding to Layer 03, resolve to this structure (show it to the user):

json
{
  "frames": {
    "technical": 0.0,
    "uncertainty": 0.0,
    "fork": 0.0,
    "ai_contribution": 0.0
  },
  "pruned": ["list of pruned frame names"],
  "intent": "FEATURE_BUILDING",
  "signal": "HIGH",
  "calibration_note": "one sentence explaining any exception rule applied"
}

Layer 03 — Output

If HIGH signal

Append to DECISIONS.md — one entry per real fork (Frame C must confirm alternatives existed):

markdown
## [YYYY-MM-DD] <title>

**Context**: [Frame A — what forced this choice]
**Decision**: what was chosen
**Alternatives considered**: [Frame C — road not taken]
**Reasoning**: why — prefix "inferred:" if reconstructed from context
**AI contribution**:
  - Identified: [Frame D — something developer missed]
  - Suggested: [Frame D — approach or alternative]
  - Developer-driven: [what the developer decided independently]
**Intent class**: [from Layer 02]
**Signal score**: HIGH
**Outcome**: implemented | pending | reversed

If no real fork existed → write nothing. Never fabricate decisions.

BUG_FIXING intent: use this format instead:

markdown
## [YYYY-MM-DD] <bug title>

**Root cause**: what actually caused the bug — the WHY, not just the what
**Symptom**: what the developer observed
**Fix**: what was changed
**Why this fix**: rationale — inferred if not stated explicitly
**Alternative fixes considered**: other approaches discussed (if any)
**AI contribution**:
  - Identified: [Frame D — did Claude spot the root cause?]
  - Suggested: [Frame D — fix approach or diagnostic step]
  - Developer-driven: [what the developer diagnosed/decided independently]
**Intent class**: BUG_FIXING
**Signal score**: HIGH
**Outcome**: fixed | workaround | deferred

Create session-history/YYYY-MM-DD-HHMM.md:

markdown
# Session [YYYY-MM-DD HH:MM]

**Intent**: [class] (runner-up: [class if any])
**Signal**: HIGH
**Frames active**: A ([score]) / B ([score]) / C ([score]) / D ([score])

## What shipped
[grounded in git log]

## What was figured out
[Frame B + C — the reasoning, tradeoffs, debugging — what developers forget]

## Decisions made this session
[refs to DECISIONS.md entries]

## Where it got hard
[Frame B findings — uncertainty, reverts, EXPLORING/STUCK signals]

## AI contribution summary
[Frame D synthesis — one honest paragraph, calibrated]

## Next steps inferred
[what's obviously incomplete]

Append to WORKLOG.md:

YYYY-MM-DD HH:MM | [intent] | HIGH | D:[score] | cache:[hit%]% | tok:[total] | <verb phrase> — <why it mattered>

Fields:

  • D:[score] — Frame D AI contribution score (0.0–1.0)
  • cache:[hit%]% — cache hit rate from token analysis (or cache:n/a if no data)
  • tok:[total] — total tokens this session (input + cache_read + cache_create + output, in K e.g. 45K)
  • verb phrase — what shipped, grounded in git log

Collect token usage (bash — run this and capture output):

bash
python3 -c "
import json, sys
from pathlib import Path

projects = Path.home() / '.claude/projects'
files = sorted(projects.rglob('*.jsonl'), key=lambda f: f.stat().st_mtime, reverse=True)
if not files:
    print('no_data'); sys.exit()

with open(files[0]) as fp:
    lines = [json.loads(l) for l in fp if l.strip()]

ti = to = cr = cc = 0
turns = []
for i, line in enumerate(lines):
    if line.get('type') == 'assistant':
        u = line.get('message', {}).get('usage', {})
        if not u: continue
        inp = u.get('input_tokens', 0)
        ti += inp; to += u.get('output_tokens', 0)
        cr += u.get('cache_read_input_tokens', 0)
        cc += u.get('cache_creation_input_tokens', 0)
        prompt = ''
        for j in range(i-1, -1, -1):
            if lines[j].get('type') == 'user':
                c = lines[j].get('message', {}).get('content', '')
                prompt = (c if isinstance(c, str) else next((x.get('text','') for x in c if isinstance(x,dict) and x.get('type')=='text'), ''))[:80]
                break
        turns.append((inp, prompt))

total = ti + cr + cc
hit = cr / total * 100 if total else 0
print(f'input={ti} output={to} cache_read={cr} cache_create={cc} hit={hit:.0f} turns={len(turns)}')
turns.sort(reverse=True)
for idx, (tok, p) in enumerate(turns[:3]):
    print(f'top{idx+1}={tok}|{p}')
"

Parse the output and include token stats in the session narrative. Then:

Generate session-history/YYYY-MM-DD-HHMM-proof.html — write a self-contained HTML file. Structure and class names are fixed — do not rename or reorder sections.

Fixed CSS tokens (use exactly):

  • Background: #0d1117, Card: #161b22, Border: #30363d
  • Font: font-family: 'Courier New', monospace
  • Frame score colors: high → #3fb950, low → #f85149, pruned → #8b949e
  • AI line colors: ai-identified → #a371f7, ai-suggested → #d29922, ai-developer → #3fb950

Fixed HTML structure (class names must match exactly):

<div class="header">
  <div class="header-top">
    <div class="project-name">
    <span class="badge">                    <!-- intent class -->
  <div class="meta-row">                    <!-- date, branch, signal level text -->
  <div class="signal-container">
    <div class="signal-label">
    <div class="signal-track">
      <div class="signal-fill">             <!-- width % driven by signal score -->

<div class="section">                       <!-- frames -->
  <div class="section-title"> ... <span class="count">Layer 02 · ADHD tree-of-thought</span>
  <div class="frames-grid">
    <div class="frame-card">               <!-- pruned: class="frame-card pruned" -->
      <div class="frame-label">            <!-- Frame A / B / C / D -->
      <div class="frame-name">
      <div class="frame-score high|low">   <!-- score value -->

<div class="section">                       <!-- decisions — skip section if none -->
  <div class="section-title"> ... <span class="count">N recorded</span>
  <div class="decision-card">              <!-- one per DECISIONS.md entry -->
    <div class="decision-header">
      <div class="decision-title">
      <div class="decision-date">
    <div class="decision-fields">
      <div class="field-row">
        <div class="field-label">          <!-- Context / Decision / Alternatives / Reasoning -->
        <div class="field-value">
      <div class="field-row">              <!-- AI contribution row -->
        <div class="field-label">AI contribution</div>
        <div class="field-value">
          <div class="ai-block">
            <div class="ai-line ai-identified|ai-suggested|ai-developer">
              <span class="tag">IDENTIFIED|SUGGESTED|DEV-DRIVEN</span>
      <div class="field-row">              <!-- Outcome row -->
        <div class="field-label">Outcome</div>
        <div class="field-value">
          <span class="outcome-badge outcome-implemented|outcome-pending|outcome-reversed">

<div class="section">                       <!-- session narrative -->
  <div class="section-title">Session narrative</div>
  <div class="narrative-grid">
    <div class="narrative-card">           <!-- What shipped -->
    <div class="narrative-card">           <!-- What was figured out -->
    <div class="narrative-card">           <!-- Where it got hard -->
    <div class="narrative-card">           <!-- Next steps inferred -->

<div class="section">                       <!-- AI contribution summary -->
  <div class="section-title">AI contribution summary</div>
  <div class="narrative-card">             <!-- Frame D synthesis paragraph -->

<div class="section">                       <!-- token usage -->
  <div class="section-title">Token usage</div>
  <div class="narrative-card">             <!-- cache hit rate bar + top turns + optimization note -->

<div class="section">                       <!-- worklog tail -->
  <div class="section-title"> ... <span class="count">last N entries</span>
  <div class="worklog-entry">              <!-- one per recent WORKLOG line -->

<div class="footer">                        <!-- last commit hash · "Generated by collab-proof · timestamp" -->

Write the HTML using bash:

bash
cat > session-history/YYYY-MM-DD-HHMM-proof.html << 'HTMLEOF'
<!DOCTYPE html>
... (full HTML with inline CSS, no external resources)
HTMLEOF

After writing, show: open session-history/YYYY-MM-DD-HHMM-proof.html


If MEDIUM signal

Append one line to WORKLOG.md only:

YYYY-MM-DD HH:MM | [intent] | MEDIUM | D:[score] | cache:[hit%]% | tok:[total] | <verb phrase>

If LOW signal

Tell user: "Signal: LOW — Routine session, nothing recorded."


Honesty rules

  • Never invent decisions not in the conversation or implied by the diff
  • "inferred:" prefix when reasoning is reconstructed
  • Frame D must be calibrated — neither overclaim nor dismiss
  • If all frames score < 0.4 → write nothing

PreCompact snapshot (context compaction defence)

When context compaction is about to happen (triggered by the PreCompact hook), run a lightweight mid-session checkpoint before context is lost:

  1. Compute current Layer 01 signal level from available context
  2. Score all four frames against what's visible now
  3. Write a snapshot to session-history/.tmp-TIMESTAMP.json:
json
{
  "timestamp": "YYYY-MM-DD HH:MM:SS",
  "trigger": "pre-compact",
  "signal": "HIGH / MEDIUM / LOW",
  "frames": { "technical": 0.0, "uncertainty": 0.0, "fork": 0.0, "ai_contribution": 0.0 },
  "intent": "FEATURE_BUILDING",
  "key_moments": [
    "one-line description of the most important decision or finding so far"
  ]
}

When /collab-proof runs at session end:

  • Read all session-history/.tmp-*.json files
  • Merge frame scores (take max per frame across all snapshots)
  • Combine key_moments arrays — these preserve tradeoff discussions that were compacted away
  • Delete .tmp-*.json files after merging

© alirezarezvani, MIT. 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 4 other files (references) in engineering/collab-proof/skills/collab-proof of alirezarezvani/claude-skills.

  • SKILL.md
  • references/ai-collaboration-evidence.md
  • references/developer-portfolio-proof.md
  • references/session-documentation-patterns.md
  • references/tamper-evident-proof.md

Open the folder on GitHubat commit 19392f7

Compare with similar skills

Collab Proof 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.

Collab Proof compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Collab Proof this skillalirezarezvani/claude-skills28k—~3.6kAutomated safety check: PassMIT
Weekly Engineering Retrogarrytan/gstack136k—~2.4kAutomated safety check: PassMIT
Dough Story Wrap Upterryyin/lizard2.5k—~4.3kAutomated safety check: PassCustom licence
Gitea Workflowjwynia/agent-skills165—~3.8kAutomated safety check: PassMIT
Retrokoolamusic/claudefiles130—~2.8kAutomated safety check: PassMIT
ObituaryFactory-AI/cursed-plugins106—~1.2kAutomated safety check: NotesApache-2.0

Similar skills

  • Builds a weekly engineering retrospective from git history: commit counts, per-person contributions, work patterns and code quality numbers over a chosen window.

    136k GitHub stars~2.4k tokensUpdated today
    Product & Project ManagementAuto-check passed
  • Dough Story Wrap Up

    terryyin/lizard

    Closes one completed feature story, bounded retrospective correction, or context-only planless execution using available execution context.

    2.5k GitHub stars~4.3k tokensUpdated today
    Product & Project ManagementAuto-check passed
  • Gitea Workflow

    jwynia/agent-skills

    Orchestrate agile development workflows for Gitea repositories using the tea CLI.

    165 GitHub stars~3.8k tokensUpdated 7 mo ago
    Product & Project ManagementAuto-check passed
  • Retro

    koolamusic/claudefiles

    A skill your agent uses when a user completes a phase, sprint, milestone, or meaningful unit of work and needs a retrospective.

    130 GitHub stars~2.8k tokensUpdated yesterday
    Product & Project ManagementAuto-check passed
  • Obituary

    Factory-AI/cursed-plugins

    Retrospective on deprecated and end-of-life code. An agent skill from Factory-AI/cursed-plugins.

    106 GitHub stars~1.2k tokensUpdated 6 mo ago
    Product & Project ManagementAuto-check: notes
  • Retrospective

    Apocrathia/home-assistant-config

    Structured post-work retrospective for Home Assistant Homelab: review outcomes, mine git history for context drift, classify lessons, and route improvements — HA-local vs contribute back to…

    179 GitHub stars~1.9k tokensUpdated 15 days ago
    Product & Project ManagementAuto-check passed

More from alirezarezvani/claude-skills

All 342 skills in this repo
  • Agile Product Owner

    alirezarezvani/claude-skills

    Writes INVEST-checked user stories with acceptance criteria, splits epics, plans sprints from velocity and ranks the backlog with a weighted score.

    28k GitHub starsUsed in 3 repos~3.2k tokens
    Auto-check passed
  • Product Strategist

    alirezarezvani/claude-skills

    OKR cascade toolkit for product leaders: generates aligned company-to-team OKRs from five strategy types and scores how well they line up.

    28k GitHub starsUsed in 2 repos~1.8k tokens
    Auto-check passed
  • App Store Optimization

    alirezarezvani/claude-skills

    App Store Optimization (ASO) toolkit for researching keywords, analyzing competitor rankings, generating metadata suggestions, and improving app visibility on Apple App Store and Google Play Store.

    28k GitHub starsUsed in 1 repo~4.2k tokens
    Auto-check passed
  • AWS Solution Architect

    alirezarezvani/claude-skills

    Design AWS architectures for startups using serverless patterns and IaC templates.

    28k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed
  • Campaign Analytics

    alirezarezvani/claude-skills

    Calculates attribution, funnel and ROI figures for marketing campaigns with three Python scripts that need only the standard library.

    28k GitHub starsUsed in 1 repo~2.1k tokens
    Auto-check passed
  • Code to PRD

    alirezarezvani/claude-skills

    Reverse-engineers a frontend, backend or fullstack codebase into a product requirements document with per-page docs, an enum dictionary and an API inventory.

    28k GitHub starsUsed in 1 repo~4.9k tokens
    Auto-check passed

Works with

Questions about Collab Proof

What does Collab Proof do?

A skill your agent uses when you want to understand what Claude contributed vs what you drove in a session. Collab Proof is an agent skill from alirezarezvani/claude-skills. Use when you want to understand what Claude contributed vs what you drove in a session.

When should I use Collab Proof?

Collab Proof fits situations like: you want to understand what Claude contributed vs what you drove in a session; : /collab-proof; session retrospective; ai contribution analysis.

How do I install Collab Proof in Claude Code?

Run `npx skills add alirezarezvani/claude-skills --skill collab-proof -a claude-code`. Or copy the skill folder (engineering/collab-proof/skills/collab-proof in alirezarezvani/claude-skills) into .claude/skills/collab-proof in your project. Claude Code loads it when a task matches its description.

How do I install Collab Proof in Codex?

Run `npx skills add alirezarezvani/claude-skills --skill collab-proof -a codex`. Or copy the skill folder (engineering/collab-proof/skills/collab-proof in alirezarezvani/claude-skills) into .agents/skills/collab-proof in your project. Codex loads it when a task matches its description.

Can I use Collab Proof 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 alirezarezvani/claude-skills --skill collab-proof -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/collab-proof, .gemini/skills/collab-proof, .github/skills/collab-proof and .opencode/skills/collab-proof in your project.

What does Collab Proof need to run?

Going by SKILL.md and its folder, Collab Proof needs the command-line tools its instructions call (git and python3). Our summary lists: Python 3.

Does Collab Proof access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Collab Proof 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 Collab Proof use?

Collab Proof is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Collab Proof use?

About 3.6k tokens (SKILL.md is roughly 14k 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 3.4k tokens, read only when the agent opens those files.

What are the alternatives to Collab Proof?

Skills that share tags, products or a category with Collab Proof: Weekly Engineering Retro (garrytan/gstack, 136k stars), Dough Story Wrap Up (terryyin/lizard, 2.5k stars), Gitea Workflow (jwynia/agent-skills, 165 stars) and Retro (koolamusic/claudefiles, 130 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Collab Proof?

alirezarezvani (a GitHub user) maintains it in alirezarezvani/claude-skills, which has 27,788 GitHub stars. The repository holds 342 skills in this directory. The repository was last updated on August 30, 2026.

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