Verify Skill logo

Verify Skill

OrganizationPopular
NeuroAIHub
verify-skill

Interactive skill verification — assess accuracy of parameters, citations, and methodology through structured expert review

Overview

PublisherNeuroAIHub
RepositoryBrainPilot
Skill nameverify-skill
Stars
1.1K
Forks
74
Bundled files
Instructions only
LicenseAGPL-3.0
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by NeuroAIHub on GitHub. Read the source before you install it.

Installation

Install the Verify Skill AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/NeuroAIHub/BrainPilot/tree/main/packages/skills/skills/01_Meta-Skills/verify-skill
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/NeuroAIHub/BrainPilot.git /tmp/BrainPilot
mkdir -p .claude/skills
cp -r /tmp/BrainPilot/packages/skills/skills/01_Meta-Skills/verify-skill .claude/skills/verify-skill
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Verify Skill in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Verify Skill on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Verify Skill is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Verify Skill

Purpose

This meta-skill guides domain experts through a structured verification of any skill in this repository. It produces a detailed verification report that records the expert's assessment of parameters, citations, and methodology — then submits the report to GitHub Discussions for community knowledge building.

Verification is the highest-impact contribution a domain expert can make. Every skill starts as ai-generated and needs human verification to progress to community-reviewed or expert-verified.

When to Use This Skill

Activate when the user:

  • Says "verify a skill", "验证这个 skill", "review this skill's accuracy"
  • Wants to check whether a skill's parameters and citations are correct
  • Has domain expertise and wants to contribute a verification
  • Is reviewing a skill before using it in their research

Research Planning Protocol

Before starting the verification process, you MUST:

  1. Identify the target skill — Which skill will be verified? Read its SKILL.md.
  2. Assess the reviewer's qualifications — What is their domain expertise and experience level?
  3. Define verification scope — Will this be a full verification or focused on specific sections?
  4. Note inherent limitations — Verification without lab replication cannot confirm all claims; flag what can and cannot be verified from literature alone.
  5. Present the verification plan to the user and WAIT for confirmation before proceeding.

For detailed methodology guidance, see skills/research-literacy/SKILL.md.

⚠️ Verification Notice

This skill was generated by AI from academic literature. All parameters, thresholds, and citations require independent verification before use in research. If you find errors, please open an issue.


Prerequisites

Before running this skill, verify:

  1. gh CLI is installed and authenticated

    Run: gh auth status

    If not authenticated, tell the user:

    To submit verification reports, you need the GitHub CLI. Install it from https://cli.github.com/ and run gh auth login. Alternatively, I can save the report as a local markdown file.

  2. The target skill exists — The skill directory must exist under skills/ in the repository.


Interactive Flow (6 Phases)

Progress Tracking (Required)

At the start of the verification, you MUST create a task list (using TodoWrite or equivalent) with these items:

  • Phase 1: Cognitive Alignment
  • Phase 2: Experience Collection
  • Phase 3: Test Scenario Construction
  • Phase 4: Item-by-Item Assessment
  • Phase 5: Apply Corrections to Skill
  • Phase 6: Generate Report and Submit to GitHub Discussions ← DO NOT SKIP

Mark each item as you complete it. Do NOT consider the verification complete until ALL items are checked, especially Phase 6 (GitHub submission).

Phase 1 — Cognitive Alignment

Goal: Ensure the reviewer understands what the skill does before assessing it.

  1. Read the target skill's SKILL.md in full.

  2. Present a summary to the reviewer:

    • What this skill does (purpose and domain)
    • Typical use scenarios (when it triggers)
    • Key parameters and claims it makes (list the specific numbers and citations)
    • What verification means in this context
  3. Ask the reviewer: "Does this summary match your understanding of the skill? Anything to clarify before we proceed?"

  4. Wait for confirmation before moving to Phase 2.

Next → Phase 2: Experience Collection (4 remaining phases until GitHub submission)

Phase 2 — Experience Collection

Goal: Understand the reviewer's domain knowledge to calibrate the verification.

Present these questions:

Q1: How familiar are you with this domain? (1-5)

  • 1 = Heard of it
  • 2 = Read about it
  • 3 = Studied it formally
  • 4 = Use it in my research
  • 5 = I am a specialist in this area

Q2: Have you used these methods in your research?

  • Yes, I use them regularly (describe briefly)
  • Yes, I have used them before (describe context)
  • No, but I know the literature well
  • No, I am learning about this area

Q3: For the key parameters listed in Phase 1, what values do you typically use?

  • Present each key parameter from the skill and ask the reviewer what value they use or expect
  • This is a per-parameter question — iterate through the most important parameters
  • Accept "I don't know" as a valid answer

Q4: What pitfalls have you encountered that this skill should mention?

  • Free text — any practical warnings from experience

Next → Phase 3: Test Scenario Construction (3 remaining phases until GitHub submission)

Phase 3 — Test Scenario Construction

Goal: Test the skill against a realistic scenario to evaluate its practical advice.

  1. Ask the reviewer to describe a scenario:

    "Describe a real or realistic dataset and research question where you would use the methods covered by this skill. Include: modality, sample size, conditions, and what you are trying to find."

  2. Run the target skill against this scenario (simulate how the skill would respond to the described research question).

  3. Present the skill's recommendations for this scenario.

  4. Ask the reviewer to evaluate:

    • Did the skill give appropriate recommendations for this scenario?
    • Were there any incorrect suggestions?
    • What important advice was missing?

Next → Phase 4: Item-by-Item Assessment (2 remaining phases until GitHub submission)

Phase 4 — Item-by-Item Assessment

Goal: Systematic parameter-by-parameter verification with structured scoring.

For each key claim in the skill (parameters, thresholds, citations, methodological recommendations), present a table row and ask the reviewer to assess:

Assessment format:

#ParameterSkill SaysCitationYour VerdictNotes
1[param name][value from skill][cited source]✅ / ⚠️ / ❌ / ❓[reviewer's explanation]
2...............

Verdict options:

  • ✅ Confirmed — The value and citation are correct
  • ⚠️ Context-dependent — Correct in some contexts but not universally; needs qualification
  • ❌ Incorrect — The value or citation is wrong (reviewer provides the correct information)
  • ❓ Cannot verify — The reviewer does not have enough expertise or resources to confirm

Process each parameter interactively — present 3-5 parameters at a time, get the reviewer's verdicts, then continue with the next batch.

After all parameters are assessed, collect overall ratings (1-5 stars each):

  1. Parameter accuracy — Are the numerical values and thresholds correct?
  2. Completeness — Does the skill cover all important aspects of this methodology?
  3. Practical usefulness — Would this skill actually help a researcher do better work?
  4. Pitfall awareness — Does the skill warn about common mistakes and edge cases?

⚠️ CRITICAL: Do NOT stop here. Next → Phase 5: Apply Corrections, then Phase 6: Submit to GitHub Discussions. The verification is NOT complete without submission.

Phase 5 — Apply Corrections

Goal: Update the skill based on verification findings.

If Phase 4 produced any ❌ (Incorrect) or ⚠️ (Context-dependent) verdicts:

  1. List all corrections needed — Summarize what parameters, citations, or methodology need updating based on the reviewer's verdicts.

  2. Apply corrections to the skill's SKILL.md:

    • Fix incorrect parameter values (replace with reviewer-provided values and citations)
    • Add missing caveats or context qualifications for ⚠️ items
    • Update citations where the reviewer identified errors
    • Add pitfalls and warnings from the reviewer's experience (Phase 2 Q4)
  3. Update the skill's review_status in the YAML frontmatter:

    • If the reviewer's familiarity was 4-5 → set to "expert-verified"
    • If the reviewer's familiarity was 2-3 → set to "community-reviewed"
    • If the reviewer's familiarity was 1 → keep as "ai-generated"
  4. Commit the changes with a descriptive message, e.g.: fix: update [skill-name] parameters per expert verification

  5. Present the diff to the reviewer for confirmation.

If Phase 4 produced NO corrections needed (all ✅), skip to Phase 6 but still update review_status if appropriate.

⚠️ CRITICAL: You are NOT done. You MUST proceed to Phase 6 to submit the verification report to GitHub Discussions.

Phase 6 — Report Generation and Submission

Goal: Generate a structured verification report and submit it to GitHub Discussions.

  1. Generate the verification report using the format below.

  2. Present the complete report to the reviewer. Present options:

    • Approve all — Submit as shown
    • Delete sections — Remove specific sections
    • Anonymize — Replace identifying information (name, institution) with generic descriptions
    • Save locally only — Save without submitting to GitHub
    • Abort — Cancel without saving
  3. Wait for explicit confirmation before submitting.

  4. Submit to GitHub Discussions in the "Verification" category.

Submission command:

bash
gh api graphql -f query='
mutation {
  createDiscussion(input: {
    repositoryId: "REPO_ID",
    categoryId: "VERIFICATION_CATEGORY_ID",
    title: "Verification Report: SKILL_NAME",
    body: "REPORT_BODY_HERE"
  }) {
    discussion {
      url
    }
  }
}'

To get the required IDs:

bash
gh api graphql -f query='
{
  repository(owner: "HaoxuanLiTHUAI", name: "awesome_cognitive_and_neuroscience_skills") {
    id
    discussionCategories(first: 10) {
      nodes {
        id
        name
      }
    }
  }
}'

After successful submission, display the Discussion URL to the reviewer.

If submission fails: Save the report to ~/.cache/awesome-neuro-skills/pending-verifications/YYYY-MM-DD-skill-name.md and provide manual submission instructions.


Verification Report Format

markdown
## Verification Report: [skill-name]

### Reviewer Profile
- **Domain**: [e.g., "cognitive neuroscience"]
- **Experience**: [e.g., "5 years EEG research"]
- **Familiarity with this topic**: [1-5 from Q1]
- **Context**: [e.g., "currently running oddball paradigm study"]

### Verification Scenario
> [Description of the test scenario used in Phase 3]

### Skill Evaluation Against Scenario
> [Summary of how well the skill performed on the test scenario]

### Parameter Review
| # | Parameter | Skill Says | Citation | Verdict | Notes |
|---|-----------|-----------|----------|---------|-------|
| 1 | [param] | [value] | [citation] | ✅/⚠️/❌/❓ | [explanation] |

### Expert Insights
> [Reviewer's professional knowledge that supplements or corrects the skill — from Q3, Q4, and Phase 3 feedback]

### Overall Scores
| Dimension | Score |
|-----------|-------|
| Parameter accuracy | [1-5 stars] |
| Completeness | [1-5 stars] |
| Practical usefulness | [1-5 stars] |
| Pitfall awareness | [1-5 stars] |

### Suggested Improvements
- [Concrete suggestions for updates to the skill]

---
*Submitted via the `verify-skill` meta-skill.*

Verification Depth Guidance

What CAN be verified from literature

  • Whether a cited paper exists and the citation is correct
  • Whether the cited paper actually recommends the stated parameter value
  • Whether the methodology matches current field consensus
  • Whether important caveats or alternatives are mentioned

What CANNOT be verified without lab work

  • Whether specific parameter values are optimal for all datasets
  • Whether the pipeline actually produces valid results on real data
  • Whether edge cases and failure modes are exhaustively covered

Flag this distinction clearly in the report.


Completion Checklist

Before considering this verification COMPLETE, you MUST confirm ALL of the following:

  • Skill SKILL.md has been updated with corrections (if any ❌/⚠️ verdicts in Phase 4)
  • review_status has been updated in the skill's YAML frontmatter
  • Changes have been committed to git
  • Verification report has been submitted to GitHub Discussions (or saved locally if gh is unavailable)
  • Discussion URL (or local file path) has been shown to the reviewer

If any item above is unchecked, GO BACK and complete it now. Do NOT end the conversation.

Frequently asked questions

What does the Verify Skill AI skill do?

Interactive skill verification — assess accuracy of parameters, citations, and methodology through structured expert review

Why use Verify Skill on TypingMind?

Because you install it once and use it with any model. Verify Skill is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Verify Skill in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/NeuroAIHub/BrainPilot/tree/main/packages/skills/skills/01_Meta-Skills/verify-skill. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Verify Skill?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Verify Skill?

As many as you like. As long as a model supports skills, you can use Verify Skill with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Verify Skill AI skill free?

Yes. It is published on GitHub by NeuroAIHub under the AGPL-3.0 license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇