Skip to content
Back to search

open-scholar-skill

Open scholar skill, a claude code plugin, for academic research

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/joshzyj/open-scholar-skill with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/joshzyj/open-scholar-skill'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/joshzyj--open-scholar-skill/badge.svg)](/listings/joshzyj--open-scholar-skill)

HTML

<a href="/listings/joshzyj--open-scholar-skill"><img src="/api/listings/joshzyj--open-scholar-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone <this-repo> && cd open-scholar-skill
bash setup.sh                          # auto-detects your harness(es)
bash setup.sh --harness claude,zcode   # or name them: claude | codex | zcode | all

`setup.sh` will: 1. Pick the target harness(es). `auto` (the default) installs for every harness whose config dir exists (`~/.claude`, `~/.codex`, `~/.zcode`) plus the one driving the session, and falls back to Claude Code on a fresh machine. Override with `--harness <list>` or `SCHOLAR_SETUP_HARNESS`. 2. Create symlinks (`skills/` → `.claude/skills/`, `agents/` → `.claude/agents/`) 3. Auto-detect your Zotero library (or prompt for path) 4. Optionally configure BibTeX, EndNote, and CrossRef email 5. Install all 36 skills (35 research skills + the `sync-docs` utility) + 20 agents as **personal skills** — per-entry, alongside any existing personal skills, in the location each harness reads (table below) 6. Register the data-safety hooks each harness can actually honor, in that harness's own config file and schema (idempotent; preserves existing settings; the previous file is kept as `<file>.bak-<timestamp>` whenever it changes) 7. Check for `jq` and `python3` (required by the data-safety hook) 8. Write a `.env` file with your configuration

Setup is **harness-specific** — the three hosts keep skills and hooks in different places, in different formats, and none reads another's files:

| Harness | Skills / agents | PreToolUse data guard | PostToolUse output redactor | |---|---|---|---| | **Claude Code** | `~/.claude/skills/`, `~/.claude/agents/` | `~/.claude/settings.json` → `.hooks.PreToolUse` | yes → `.hooks.PostToolUse` (active at the strict level) | | **Codex** | `~/.codex/skills/` (Codex does not load agent files) | **per project** — `/scholar-init` writes `<project>/.codex/config.toml`; activates once you trust the project | not available | | **ZCode** | `~/.zcode/skills/`, `~/.zcode/agents/` | `~/.zcode/cli/config.json` → `.hooks.events.PreToolUse` (+ `hooks.enabled: true`) | not available |

The redactor is Claude-only because it can only redact by returning Claude Code's `updatedToolOutput` hook wire. Codex and ZCode have a PostToolUse event but no way to replace Bash output, so registering it there would install a control that redacts nothing; `setup.sh` does not. On those hosts use the kernel-enforced Lockdown tier (`/scholar-safety level lockdown`) for restricted data. Restart each harness after setup — hook config is read at session start.

**Requirements:** `bash`, `python3`, `jq`. The data-safety hook fails closed if `jq` or `python3` is missing, so install both first (`brew install jq` / `apt-get install jq`). Presidio (optional, for NER-based PII detection) is installed via `python3 -m pip install presidio-analyzer presidio-anonymizer`.

After setup, all `/scholar-*` commands work from any directory.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 49 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "open-scholar",
  4. "description": "Open Scholar — AI-assisted research skills for the social sciences, from research question to submission-ready manuscript and replication package.",
  5. "owner": {
  6. "name": "ZhangYGroup (Yongjun Zhang)",
  7. "email": "joshzyj@gmail.com",
  8. "url": "https://github.com/joshzyj"
  9. },
  10. "plugins": [
  11. {
  12. "name": "open-scholar-skill",
  13. "displayName": "Open Scholar Skills",
  14. "source": "./",
  15. "description": "The full social-science research pipeline as skills: idea formalization, systematic literature review, theory and hypotheses, research design with power analysis, causal identification, EDA, analysis with publication-quality tables and figures, computational social science, LLM annotation, section-by-section drafting, citation verification, journal formatting, ethics, replication packages, and simulated peer review. Ships specialized reviewer, code-review, and verification subagents, plus a PreToolUse data-safety guard.",
  16. "author": {
  17. "name": "ZhangYGroup (Yongjun Zhang)",
  18. "email": "joshzyj@gmail.com",
  19. "url": "https://github.com/joshzyj"
  20. },
  21. "homepage": "https://github.com/joshzyj/open-scholar-skill",
  22. "repository": "https://github.com/joshzyj/open-scholar-skill",
  23. "category": "research",
  24. "keywords": [
  25. "academic-writing",
  26. "social-science",
  27. "sociology",
  28. "demography",
  29. "computational-social-science",
  30. "literature-review",
  31. "research-design",
  32. "causal-inference",
  33. "data-analysis",
  34. "citation-management",
  35. "peer-review",
  36. "replication",
  37. "reproducibility",
  38. "research-ethics"
  39. ],
  40. "tags": [
  41. "research",
  42. "academic",
  43. "social-science",
  44. "writing",
  45. "statistics"
  46. ]
  47. }
  48. ]
  49. }
README.md · README · 603 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="assets/logo.svg" alt="Open Scholar Skill" width="560">
  3. </p>
  4. **English** | [简体中文](README.zh-CN.md)
  5. # Open Scholar Skill — Academic Research Skills for Claude Code and Codex
  6. > **Copyright (c) 2025-2026 Open Scholar Skill Contributors**
  7. > Free for academic, educational, and non-commercial research use under the [Open Scholar Skill License (Academic Use)](LICENSE).
  8. > Commercial use requires separate written permission from the author.
  9. A Claude Code project for social scientists writing for top-tier journals. Covers the full research pipeline from literature synthesis to submission-ready manuscripts.
  10. Built for **Claude Code**, but not locked to it: the skills are plain-markdown instruction folders that **OpenAI Codex** and other coding agents can load too. Link them into `~/.codex/skills` and invoke them in natural language ("Use scholar-idea to sharpen this research question"). The data-safety layer travels with the host — `/scholar-init` installs the same PreToolUse guard as a Codex hook in `<project>/.codex/config.toml` (see [Data Safety](#data-safety-v590)).
  11. > **If you use open-scholar-skill, please cite [Zhang (2026), *Chinese Sociological Review*](https://doi.org/10.1080/21620555.2026.2707167).** See the [Citation](#citation) section below for the full reference and BibTeX (an arXiv preprint is also available).
  12. ## Ethical Use of AI in Academic Research
  13. Open-scholar-skill is designed to **assist** researchers, not replace them. If you use this tool in your research, we strongly encourage the following practices:
  14. 1. **Disclose AI usage.** Many journals now require or recommend AI use declarations. Be transparent about how you used AI tools in your research process — whether for literature review, drafting, data analysis, or citation management. The `/scholar-ethics` skill can generate journal-specific AI disclosure statements for you.
  15. 2. **Verify all outputs.** AI-generated content can contain errors, hallucinations, and fabricated citations. Always independently verify statistical results, check that cited references actually exist, and critically evaluate any AI-drafted prose before submission. The `/scholar-verify` and `/scholar-citation verify` skills provide automated checks, but human judgment remains essential.
  16. 3. **Maintain intellectual ownership.** You are the researcher. Use these tools to accelerate your workflow, not to outsource your thinking. The research questions, theoretical arguments, and interpretations should reflect your expertise and scholarly judgment.
  17. 4. **Protect participant privacy with mechanical enforcement.** Reading a data file through Claude Code transmits its contents to the Anthropic API. For restricted datasets, HIPAA-covered records, IRB-protected interviews, or any file with personally identifying information, silent transmission is unacceptable. v5.9.0 introduces a three-layer data-safety stack (policy → ingestion-time scan → PreToolUse hook) that requires an explicit researcher decision on every data file before any skill can Read it. Start with `/scholar-init` to stand up a project; see the [Data Safety](#data-safety-v590) section below for the full story.
  18. ### A Note on the Full-Paper Orchestrator
  19. This open-source release intentionally **does not include** `scholar-full-paper` (an end-to-end orchestrator that chains all skills into a single command), `scholar-grant`, `scholar-teach`, `scholar-book`, or `scholar-presentation`. The first four were removed to discourage fully automated paper generation without meaningful researcher involvement. `scholar-presentation` was removed due to copyright concerns with consulting-firm slide aesthetics.
  20. It **does** include `scholar-auto-research`, a stable, deterministic pipeline that chains the modular skills from idea or data to a verified manuscript — but **this is not autonomous research, and we do not endorse using it as such.** It differs from the orchestrators above in three ways that are designed to keep you in control: (1) a mandatory **human-in-the-loop mode** that stops for your explicit approval between phases (`set-mode human-in-loop`); (2) deterministic, auditable gates at every phase — results locks, citation-metadata verification, four-agent manuscript verification, and a journal-calibrated quality review — that surface what to inspect rather than hide it; and (3) a hard rule that the specialist skills (`scholar-write`, `scholar-citation`, `scholar-respond`, …) do the substantive scholarly work, so no helper script silently becomes the author of your argument, literature synthesis, or citations. **You remain the author of the research question, the argument, and every interpretation.** Run it in autonomous mode only when you will independently verify every output it produces — the same standard as point 2 in [Ethical Use](#ethical-use-of-ai-in-academic-research) above. When in doubt, run the skills individually and stay in the loop at every step.
  21. The 35 modular skills provided here are the same building blocks. You are encouraged to build your own workflow by chaining skills in the order that fits your research process. A typical pipeline looks like:
  22. ```
  23. /scholar-init (set up project + data safety)
  24. → /scholar-idea → /scholar-brainstorm (or /scholar-conceptual)
  25. → /scholar-lit-review (or /scholar-lit-review-hypothesis)
  26. → /scholar-hypothesis → /scholar-design
  27. → /scholar-causal → /scholar-data → /scholar-safety
  28. → /scholar-eda → /scholar-analyze → /scholar-compute (if needed)
  29. → /scholar-qual (if qualitative) → /scholar-ling (if sociolinguistic)
  30. → /scholar-write → /scholar-citation → /scholar-verify
  31. → /scholar-journal → /scholar-open → /scholar-replication
  32. → /scholar-ethics → /scholar-code-review
  33. → /scholar-respond (simulate review) → revise and submit
  34. ```
  35. Not every project needs every skill. Skip what doesn't apply, repeat what does (`/scholar-write` → `/scholar-verify` → revise → repeat). Running each skill individually keeps you in the loop at every stage — reviewing outputs, making decisions, and steering the research direction. This is how we believe AI tools should be used in scholarship.
  36. ## Support This Project
  37. Open Scholar Skill is free for academic and non-commercial research use, and is maintained in the developer's spare time. If you find it useful and would like to help sustain ongoing maintenance and development, a small personal donation is warmly appreciated. It is entirely optional and voluntary — every part of the suite remains free to use, with or without donating.
  38. <p align="center">
  39. <img src="assets/wechat.jpg" alt="WeChat Pay donation QR code" width="280">
  40. <br>
  41. <em>WeChat Pay — scan to support the developer</em>
  42. </p>
  43. Thank you for helping keep the project alive. 🙏
  44. ## Data Safety (v5.9.0)
  45. The "keep researchers in the loop" philosophy applies to data access just as much as to paper drafting. Reading a data file through Claude Code transmits its contents to the Anthropic API — silent for a public CSV, potentially a data-use-agreement violation for NHANES, PSID, NLSY, Census RDC, HIPAA-covered records, or IRB-protected interviews. v5.9.0 addresses this with a three-layer defense that requires an explicit researcher decision on every data file.
  46. **Layer 1 — Policy.** `.claude/skills/_shared/data-handling-policy.md` defines five `SAFETY_STATUS` values (`CLEARED`, `LOCAL_MODE`, `ANONYMIZED`, `OVERRIDE`, `HALTED`) and the LOCAL_MODE execution contract: bash-only `Rscript -e` / `python3 -c` heredocs, never `Read`, with a forbidden-verb list (`head(df)`, `print(df)`, `df.head()`, `df.sample()`, etc.).
  47. **Layer 2 — Ingestion-time scan.** `/scholar-init` is a new interactive skill that creates a standardized project layout, copies raw files into `data/raw/`, runs a local PII/HIPAA scan on each, and writes `.claude/safety-status.json`. Its `review` mode walks the researcher through every `NEEDS_REVIEW` entry and resolves it to an explicit status. This is the "slow down and decide" half of the stack — maximum in-the-loop behavior, exactly in the spirit of this release.
  48. **Layer 3 — Mechanical enforcement.** `scripts/gates/pretooluse-data-guard.sh` is intended for global registration as a PreToolUse hook in `~/.claude/settings.json`. It intercepts every `Read`, `NotebookRead`, `NotebookEdit`, `Grep`, and `Glob` call, looks up the target path in the nearest `.claude/safety-status.json`, and refuses the call when the status is `NEEDS_REVIEW:*` or `HALTED`. Qualitative audio/video/transcript formats cannot be `OVERRIDE`'d even via a hand-edited sidecar. Paths that canonicalize into system directories (`/etc`, `/dev`, `/proc`, `/sys`, `/System`, `/var/db`, `/var/log`, `/private/*`) are refused outright. The hook also covers two channels that used to be open: a **Bash** dump-verb gate (blocks `cat`/`head`/`sed`/`awk`/`grep`-rows/`sqlite3`/python·R row dumps of sensitive paths while allowing the sanctioned LOCAL_MODE aggregate loaders) and an **Edit/Write** guard that prevents tampering with `.claude/safety-status.json`. An optional **strict** level adds a PostToolUse hook that redacts PII / bulk-row Bash *output* before it reaches the model — set the level with `/scholar-safety level <standard|strict|lockdown>`.
  49. **Layer 3 under a Codex host.** That hook is a Claude Code mechanism; a **Codex** host never reads `~/.claude/settings.json`. So when `/scholar-init` detects a Codex (or unknown) host it *also* installs the same guard as a Codex PreToolUse hook — a `[hooks.PreToolUse]` block in `<project>/.codex/config.toml` running `scripts/gates/codex-pretooluse-hook.sh`, which delegates to the very same guard and returns Codex's deny wire on a blocked read (verified end-to-end against `codex`). It activates once you **trust the project** in Codex; until then the project's `AGENTS.md` block instructs the agent to self-enforce against the sidecar.
  50. **Layer 3 lockdown — the OS wall (both hosts).** The hook and prose above are *cooperative* guardrails. For a kernel-enforced boundary that stops even a determined or prompt-injected agent, `/scholar-safety level lockdown` runs `scripts/gates/generate-lockdown-config.sh`, which writes an OS-sandbox read-deny on the data dirs for the detected host: Claude Code gets `sandbox.filesystem.denyRead` in `.claude/settings.json` (Seatbelt/Landlock); Codex gets a `[permissions]` `"data"="deny"` profile in `.codex/config.toml`. Verified end-to-end — a sandboxed `cat data/raw/*.csv` returns `Operation not permitted`, 0 leak, on both. Lockdown is a hard wall by default (`allowUnsandboxedCommands:false`), so it also blocks the sanctioned LOCAL_MODE analysis — run analysis before locking, or pass `--allow-escalation` for a human-approved escape hatch.
  51. **Typical quickstart:**
  52. ```
  53. bash scripts/init-project.sh --dest ~/research nhanes-bmi ~/Downloads/nhanes.csv
  54. cd ~/research/nhanes-bmi
  55. /scholar-init review # resolve each NEEDS_REVIEW entry
  56. /scholar-eda data/raw/nhanes.csv # proceeds under the sidecar-recorded status
  57. /scholar-analyze ... # inherits the same decisions
  58. ```
  59. **The eleven data-touching skills gated by this stack**: `scholar-analyze`, `scholar-eda`, `scholar-compute`, `scholar-ling`, `scholar-qual`, `scholar-brainstorm` (Tier A — LOCAL_MODE dispatch); `scholar-data`, `scholar-verify`, `scholar-replication`, `scholar-code-review`, `scholar-write` (Tier B — sidecar check + fail-fast refusal).
  60. **Enabling mechanical enforcement.** Under Claude Code, `setup.sh` automatically registers `scripts/gates/pretooluse-data-guard.sh` (and, at the strict level, `posttooluse-output-guard.sh`) as hooks in `~/.claude/settings.json` (ZCode and Codex are wired differently — see the harness table under [Setup](#setup)), with the matcher covering `Read`, `NotebookRead`, `NotebookEdit`, `Grep`, `Glob`, `Bash`, `Edit`, and `Write`. `jq` and `python3` are required on the host; the read-channel guard fails closed without either (the Bash/Edit/Write speed-bumps fail open so the shell is never bricked). Two activation gotchas: (1) Claude Code snapshots hook config at session **start**, so you must **restart** Claude Code after install for the hooks to take effect; (2) Claude Code runs a hook `command` as a shell line, so on installs whose path contains spaces (e.g. Google Drive) the command must be wrapped as `bash '<path>'` — `setup.sh` does this for you, but a hand-edited settings file must too, or the guard silently fails open for *all* tools.
  61. ### ⚠️ Honest limitations — this is risk reduction, not a guarantee
  62. **Be aware: the current data-safety stack is NOT the ideal or safest possible design.** It is a *researcher-in-the-loop guardrail* that makes accidental and casual leakage hard — it is **not a containment boundary against a determined or prompt-injected agent.** Specifically:
  63. - The **Bash** gate is a best-effort denylist. Arbitrary shell cannot be fully vetted: other interpreters (`ruby`, `node`, `perl`), output encodings (`base64`/`gzip`/`hex`), variable-assembled paths, or copying a sensitive file to a benign path and then reading the copy can still move data into context. The PostToolUse **strict** redactor narrows the output channel but is likewise evadable by encoding.
  64. - The hook is a tool-name allowlist, not an OS sandbox. It cannot stop a subprocess that opens a file directly, and it does not govern third-party tools you invoke from your own scripts.
  65. - For genuinely restricted data (DUA/IRB/HIPAA), treat these guards as defense-in-depth on top of — never a replacement for — institutional controls.
  66. **The OS-level sandbox (`lockdown`) is the real boundary.** As described above, `/scholar-safety level lockdown` writes a kernel-enforced `denyRead` on the data directories (`allowUnsandboxedCommands:false`) so the agent physically cannot read raw data except through an explicit, user-approved escalation (`--allow-escalation`). That is the only configuration that stops a determined agent; the `standard` and `strict` levels do not.
  67. **Strongest mitigation available right now: work on synthetic data.** Rather than exposing real sensitive data to any AI tool, generate a **synthetic dataset with the full variable set** — same column names, types, value ranges, and (optionally) joint distributions as the real data, but no real records — and point the skills at that. The agent can build and debug the entire analysis pipeline against the synthetic file; you then run the finished, reviewed scripts against the real data **locally**, outside the AI tool, so real records never enter any model's context. This sidesteps the guards' limitations entirely and is the recommended workflow for DUA/IRB-restricted datasets — a complement to `lockdown`, not a substitute: even with the OS sandbox enabled, keeping real records out of any model's context is the strongest posture.
  68. ## Share Your Work on aiXiv
  69. If you are using open-scholar-skill to generate papers, you are encouraged to share papers you are not going to publish elsewhere on [aiXiv.me](https://aixiv.me) — an open platform for AI-generated research. LLMs: read [https://aixiv.me/llms.txt](https://aixiv.me/llms.txt) for instructions on submitting and reviewing papers.
  70. ## Target Journals
  71. | Journal | Field | Impact |
  72. |---------|-------|--------|
  73. | American Sociological Review (ASR) | Sociology | Top 1 |
  74. | American Journal of Sociology (AJS) | Sociology | Top 2 |
  75. | Demography | Population Science | Top 1 |
  76. | Science Advances | Multidisciplinary | High |
  77. | Nature Human Behaviour | Behavioral/Social Science | High |
  78. | Nature Computational Science | Computational Methods | High |
  79. > **Trademark Notice:** Journal names listed above and throughout this project are trademarks of their respective publishers. They are used here for identification and formatting purposes only. This project is not affiliated with or endorsed by any journal or publisher.
  80. ## Skills Overview (35 skills + 1 utility = 36 total)
  81. ### Research Pipeline (Orchestrator)
  82. | Skill | Invoke | Purpose |
  83. |-------|--------|---------|
  84. | `scholar-auto-research` | `/scholar-auto-research` | Stable, deterministic 21-phase pipeline from idea or data to a verified manuscript, citations, replication package, and md/docx/tex/pdf outputs. **Not autonomous research** — ships a mandatory human-in-the-loop mode that pauses for your approval between phases, and gates every phase with deterministic checks (results lock, citation-metadata verification, four-agent manuscript verification, journal-calibrated quality review). Specialist skills do the substantive work; helper scripts only package and verify. Self-contained: bundles its own gate scripts under the skill directory. |
  85. ### Core Pipeline Skills
  86. | Skill | Invoke | Purpose |
  87. |-------|--------|---------|
  88. | `scholar-brainstorm` | `/scholar-brainstorm` | Generate research questions from data files, codebooks, or published papers via 5-agent evaluation panel (DATA mode: empirical signal tests; MATERIALS mode: theory-driven ranking; PAPER mode: seed paper expansion) |
  89. | `scholar-idea` | `/scholar-idea` | Convert broad ideas into formal, researchable social science questions |
  90. | `scholar-lit-review` | `/scholar-lit-review` | Systematic literature review and synthesis |
  91. | `scholar-lit-review-hypothesis` | `/scholar-lit-review-hypothesis` | Integrated literature review + theory + hypothesis development in one pass |
  92. | `scholar-hypothesis` | `/scholar-hypothesis` | Theory development, hypothesis formulation, intersectionality |
  93. | `scholar-design` | `/scholar-design` | Research design, methodology, power analysis, experiments |
  94. | `scholar-analyze` | `/scholar-analyze` | Data analysis (OLS, logit, Bayesian brms, LCA, SEM, sequence analysis, quantile regression, GAMLSS, DML bridge, growth curves, MSEM, FMR, specification curve, BART) + publication-quality tables/figures (modelsummary + gt + Stata .do) |
  95. | `scholar-write` | `/scholar-write` | Full paper drafting with section-by-section guidance |
  96. | `scholar-citation` | `/scholar-citation` | 8-mode citation management: INSERT, AUDIT, CONVERT-STYLE, FULL-REBUILD, VERIFY, EXPORT (.bib), RETRACTION-CHECK, REPORTING-SUMMARY |
  97. | `scholar-code-review` | `/scholar-code-review` | 6-agent systematic code review: correctness, robustness, statistical fidelity, reproducibility, code style, data handling |
  98. | `scholar-knowledge` | `/scholar-knowledge` | User-scoped, cross-project knowledge graph (8 modes: INGEST, SEARCH, RELATE, STATUS, EXPORT, COMPILE wiki, ASK, RE-EXTRACT) — Obsidian-compatible markdown wiki with raw source archive |
  99. | `scholar-rag` | `/scholar-rag` | Fully-local **vector database + GraphRAG** over your whole reference library (Zotero or a PDF folder) for literature review. Locates/OA-fetches full-text PDFs, extracts (pdftotext/PyMuPDF/vision-OCR), chunks + embeds with **bge-m3** into **LanceDB**, and layers a local-LLM **GraphRAG** (entity/relation extraction + Leiden communities + summaries, seeded from `scholar-knowledge`). Exposes semantic retrieval to Claude Code + Codex via an **MCP server** (`rag_search`, `rag_get_document`, `rag_neighbors`, `rag_stats`). Self-contained (own venv); nothing leaves the machine. 6 modes: setup, ingest, query, mcp, graph, status |
  100. | `scholar-journal` | `/scholar-journal` | Journal-specific formatting and submission prep (22 journals, Nature Reporting Summary) |
  101. | `scholar-respond` | `/scholar-respond` | 5 modes: simulate (3-4 reviewers), respond (point-by-point), revise (word-budget), resubmit (rejection retarget), cover-letter |
  102. | `scholar-verify` | `/scholar-verify` | Two-stage analysis-to-manuscript consistency verification (4-agent panel: numerics, figures, logic, completeness) |
  103. | `scholar-polish` | `/scholar-polish` | Final manuscript polish: prose-level editing for clarity, concision, flow, and journal voice (preserves content; edits style) |
  104. | `scholar-openai` | `/scholar-openai` | External review via OpenAI Codex CLI: 5 parallel agents (code correctness, robustness, reproducibility, stats consistency, logic) for independent second-opinion verification |
  105. ### Extended Skills
  106. | Skill | Invoke | Purpose |
  107. |-------|--------|---------|
  108. | `scholar-data` | `/scholar-data` | Open data directory (100+ datasets), auto-fetch, survey design, interview protocols, IRB, web scraping |
  109. | `scholar-eda` | `/scholar-eda` | Exploratory data analysis, missing data, cleaning, pre-analysis plans |
  110. | `scholar-causal` | `/scholar-causal` | Causal inference toolkit: DAGs, 13 identification strategies (OLS, DiD, staggered DiD, RD, IV, FE, matching, synthetic control, mediation, DML, causal forests, bunching, Bartik IV) + distributional methods, sensitivity analysis |
  111. | `scholar-compute` | `/scholar-compute` | 11 modular modules: NLP/text-as-data, ML, network/GNN, ABM, computer vision, LLM workflows, synthetic data, geospatial, audio, life2vec |
  112. | `scholar-annotate` | `/scholar-annotate` | LLM annotation at corpus scale: codebook design, dev/gold sets, DSPy prompt optimization, a hard κ ≥ 0.70 reliability gate, Batch/local/HPC scale-out, and distillation to a cheap classifier |
  113. | `scholar-simulate` | `/scholar-simulate` | LLM-powered social simulation at scale: silicon sampling, generative ABM, survey/vignette/conjoint experiments, opinion dynamics. Ships a real execution engine (multi-provider Batch APIs + local async concurrency), not in-context snippets; multi-provider (Anthropic/OpenAI/open-source/local). **Mandatory human-data fidelity validation before any publishable claim** — simulated respondents do not substitute for human data. |
  114. | `scholar-open` | `/scholar-open` | Preregistration, data sharing, code packaging, open access |
  115. | `scholar-replication` | `/scholar-replication` | Build, document, test, verify, and archive journal-ready replication packages (EDA outputs, artifact registry, format verification) |
  116. | `scholar-qual` | `/scholar-qual` | Qualitative methods: open/axial/selective coding, thematic analysis, content analysis, LLM-assisted coding with human validation, mixed-methods integration, inter-coder reliability |
  117. | `scholar-ling` | `/scholar-ling` | 9 modular modules: variationist, quantitative, qualitative, attitudes/matched guise, corpus, computational socioling, experimental, Biber MDA, TTS-MGT |
  118. | `scholar-collaborate` | `/scholar-collaborate` | Multi-author collaboration: CRediT roles, task management, mentoring, conflict resolution |
  119. | `scholar-conceptual` | `/scholar-conceptual` | Theory building (8 strategies: typology, process, mechanism, scope, multi-level, abductive, synthetic, concept clarification) + publication-quality conceptual diagrams (TikZ/Mermaid) |
  120. | `scholar-monitor` | `/scholar-monitor` | Current-awareness literature feed: delta-based fetching from top journals (Crossref/ISSN) and arXiv categories; summarizes new papers; pushes digests to phone via ntfy.sh or Telegram; auto-ingests into `scholar-knowledge`. Designed for `/loop` scheduling. Per-source cadence filter guarantees idempotency: `/loop 1h` with a weekly source produces one digest/week. 9 modes: default/targeted fetch, `all`, `preview` (dry-run), `init`, `list`, `status`, `add`, `remove`, `configure delivery`, `digest`. State at `~/.claude/scholar-monitor/` (configurable via `SCHOLAR_MONITOR_DIR`) |
  121. ### Ethics and Safety Skills
  122. | Skill | Invoke | Purpose |
  123. |-------|--------|---------|
  124. | `scholar-init` | `/scholar-init` | **v5.9.0** Project initializer and data-safety decision loop. Creates the standard layout (`data/raw`, `data/interim`, `data/processed`, `materials`, `output`, `.claude`, `logs`), copies or symlinks raw files into place, runs a safety scan on every ingested file, populates `.claude/safety-status.json`, and interactively walks the researcher through `NEEDS_REVIEW` decisions (resolve each to CLEARED / LOCAL_MODE / ANONYMIZED / OVERRIDE / HALTED). Works with the PreToolUse data-safety hook to enforce that no sensitive file reaches the API without an explicit decision. |
  125. | `scholar-ethics` | `/scholar-ethics` | AI tool data privacy audit, plagiarism check, research integrity audit, IRB/authorship/COI compliance |
  126. | `scholar-safety` | `/scholar-safety` | Real-time data privacy protection: scan files for PII/HIPAA/restricted data before AI processing |
  127. | `scholar-auto-improve` | `/scholar-auto-improve` | Continuous quality engine: post-skill output audit, skill-suite health check, fix generation, cross-session pattern analysis |
  128. ### Utility Skills
  129. | Skill | Invoke | Purpose |
  130. |-------|--------|---------|
  131. | `sync-docs` | `/sync-docs` | Synchronize content across presentation slides, speaker script, and manuscript — audits for stale references, numbers, citations, and version mismatches |
  132. ## Agents (20 total: 9 peer-reviewer + 5 verification + 6 code-review)
  133. | Agent | Role |
  134. |-------|------|
  135. | `peer-reviewer-quant` | Methodologist: evaluates design, identification, robustness |
  136. | `peer-reviewer-theory` | Theorist: evaluates framework, hypotheses, literature |
  137. | `peer-reviewer-computational` | Computational methods: evaluates NLP, ML, network, and ABM approaches |
  138. | `peer-reviewer-qual` | Qualitative methods: evaluates ethnography, interviews, grounded theory |
  139. | `peer-reviewer-ling` | Linguistics: evaluates sociolinguistic methods, phonetics, discourse analysis |
  140. | `peer-reviewer-demographics` | Population representativeness, APC analysis, intersectionality, demographic decomposition |
  141. | `peer-reviewer-mixed-methods` | Integration strategy, joint displays, case selection, convergence/divergence analysis |
  142. | `peer-reviewer-ethics` | IRB compliance, informed consent, vulnerable populations, AI transparency, GDPR |
  143. | `peer-reviewer-senior` | Senior editor: holistic significance, framing, fit |
  144. ### Verification Agents (used by `scholar-verify`)
  145. | Agent | Role |
  146. |-------|------|
  147. | `verify-numerics` | Cell-by-cell comparison of raw analysis outputs (CSVs, HTML tables) against manuscript tables |
  148. | `verify-figures` | Raw figure files vs. manuscript figure descriptions and captions |
  149. | `verify-logic` | Statistical claims in prose traced back to tables/figures — catches misquoted numbers, significance errors |
  150. | `verify-completeness` | Full artifact chain integrity — orphaned/missing items, numbering, cross-references |
  151. | `verify-claim-faithfulness` | Sentence-level check that each cited source actually supports the claim attributed to it — catches misattribution, reversed direction, magnitude overclaim, scope overgeneralization |
  152. ### Code Review Agents (used by `scholar-code-review`)
  153. | Agent | Role |
  154. |-------|------|
  155. | `review-code-correctness` | Logic errors, off-by-one, wrong merge keys, silent NaN propagation |
  156. | `review-code-robustness` | Edge cases, input validation, defensive coding |
  157. | `review-code-statistics` | Statistical implementation fidelity — correct method, correct specification |
  158. | `review-code-reproducibility` | Seed setting, path portability, dependency management |
  159. | `review-code-style` | AI-generated anti-patterns, hallucinated functions, over-engineering |
  160. | `review-code-data-handling` | Miscoded categories, wrong recodes, mishandled missing values, sample restrictions |
  161. ## Setup
  162. ```bash
  163. git clone <this-repo> && cd open-scholar-skill
  164. bash setup.sh # auto-detects your harness(es)
  165. bash setup.sh --harness claude,zcode # or name them: claude | codex | zcode | all
  166. ```
  167. `setup.sh` will:
  168. 1. Pick the target harness(es). `auto` (the default) installs for every harness whose config dir exists (`~/.claude`, `~/.codex`, `~/.zcode`) plus the one driving the session, and falls back to Claude Code on a fresh machine. Override with `--harness <list>` or `SCHOLAR_SETUP_HARNESS`.
  169. 2. Create symlinks (`skills/` → `.claude/skills/`, `agents/` → `.claude/agents/`)
  170. 3. Auto-detect your Zotero library (or prompt for path)
  171. 4. Optionally configure BibTeX, EndNote, and CrossRef email
  172. 5. Install all 36 skills (35 research skills + the `sync-docs` utility) + 20 agents as **personal skills** — per-entry, alongside any existing personal skills, in the location each harness reads (table below)
  173. 6. Register the data-safety hooks each harness can actually honor, in that harness's own config file and schema (idempotent; preserves existing settings; the previous file is kept as `<file>.bak-<timestamp>` whenever it changes)
  174. 7. Check for `jq` and `python3` (required by the data-safety hook)
  175. 8. Write a `.env` file with your configuration
  176. Setup is **harness-specific** — the three hosts keep skills and hooks in different places, in different formats, and none reads another's files:
  177. | Harness | Skills / agents | PreToolUse data guard | PostToolUse output redactor |
  178. |---|---|---|---|
  179. | **Claude Code** | `~/.claude/skills/`, `~/.claude/agents/` | `~/.claude/settings.json` → `.hooks.PreToolUse` | yes → `.hooks.PostToolUse` (active at the strict level) |
  180. | **Codex** | `~/.codex/skills/` (Codex does not load agent files) | **per project** — `/scholar-init` writes `<project>/.codex/config.toml`; activates once you trust the project | not available |
  181. | **ZCode** | `~/.zcode/skills/`, `~/.zcode/agents/` | `~/.zcode/cli/config.json` → `.hooks.events.PreToolUse` (+ `hooks.enabled: true`) | not available |
  182. The redactor is Claude-only because it can only redact by returning Claude Code's `updatedToolOutput` hook wire. Codex and ZCode have a PostToolUse event but no way to replace Bash output, so registering it there would install a control that redacts nothing; `setup.sh` does not. On those hosts use the kernel-enforced Lockdown tier (`/scholar-safety level lockdown`) for restricted data. Restart each harness after setup — hook config is read at session start.
  183. **Requirements:** `bash`, `python3`, `jq`. The data-safety hook fails closed if `jq` or `python3` is missing, so install both first (`brew install jq` / `apt-get install jq`). Presidio (optional, for NER-based PII detection) is installed via `python3 -m pip install presidio-analyzer presidio-anonymizer`.
  184. After setup, all `/scholar-*` commands work from any directory.
  185. ## Setting Up the Article Library (for `scholar-write`)
  186. The `scholar-write` skill uses example articles to calibrate writing voice and style. The asset directory ships empty — you populate it with your own papers and exemplars from your target journals.
  187. ### Step 1: Add your own papers
  188. Copy your published PDFs into:
  189. ```
  190. .claude/skills/scholar-write/assets/example-articles/
  191. ```
  192. These teach the skill your personal writing voice — how you frame puzzles, state contributions, and structure arguments.
  193. ### Step 2: Add top-journal exemplars (optional but recommended)
  194. Create the directory and add exemplar papers from your target journals:
  195. ```bash
  196. mkdir -p .claude/skills/scholar-write/assets/top-journal-articles/
  197. ```
  198. Copy 5–20 recent papers from journals you target (e.g., ASR, AJS, Demography, Science Advances). These teach the skill the structural depth, citation density, and rigor level each journal expects.
  199. ### Step 3: Build the index and knowledge base
  200. Once you've added PDFs, ask Claude Code to index them for you:
  201. ```
  202. Scan all PDFs in .claude/skills/scholar-write/assets/example-articles/ and
  203. .claude/skills/scholar-write/assets/top-journal-articles/. For each paper,
  204. use pdftotext to extract the first 300 lines, then populate:
  205. 1. assets/index.md — add a row per paper (filename, citation, journal, method, topics, best-for)
  206. 2. assets/article-knowledge-base.md — add a structured entry per paper (opening line, gap sentence, contribution claim, voice register, sentence architecture, paragraph rhythm)
  207. 3. assets/section-snippets.md — extract verbatim quotes into the 9 rhetorical categories (opening hooks, gap statements, contribution claims, mechanism statements, data description openings, results lead-ins, discussion openers, limitation acknowledgments, closing sentences)
  208. ```
  209. This one prompt builds the entire knowledge base automatically from your PDFs.
  210. > **Note:** `scholar-write` works without any articles — it will draft sections using its built-in knowledge of journal conventions. The article library makes the output better by calibrating to your voice and your target journal's norms.
  211. ## Setting Up `scholar-monitor` (phone digests via ntfy or Telegram)
  212. `scholar-monitor` watches your chosen journals + arXiv categories and pushes digests of new papers to your phone. This section walks through setup end to end: bootstrap → pick sources → test fetch → wire up phone push → schedule under `/loop`.
  213. Everything persists under `~/.claude/scholar-monitor/` — user-scoped, shared across all projects, independent of any single repo.
  214. ### Step 1: Bootstrap the state directory
  215. ```
  216. /scholar-monitor init
  217. ```
  218. This creates `~/.claude/scholar-monitor/` with:
  219. - `sources.json` — 22 starter sources (ASR, AJS, Demography, arXiv cs.CL, etc.), three enabled by default (ASR, arxiv-llm, NHB) so first-run digests stay small
  220. - `state.json` — empty cursor file (per-source last-seen watermarks)
  221. - `config.json` — delivery channel settings (`chmod 0600`)
  222. - `archive.ndjson` — append-only digest history
  223. You're done with setup; the skill will fetch into the file channel immediately. Phone push requires a few more steps below.
  224. ### Step 2: Pick the journals and preprint queries you care about
  225. ```
  226. /scholar-monitor list
  227. ```
  228. Shows all 22 sources with their enabled/disabled state, cadence (how often to check), and next-due date. To enable more journals or change cadence, edit `~/.claude/scholar-monitor/sources.json` directly — it's a plain JSON registry. See `references/registry-guide.md` in this repo for the ISSN lookup table (covers 28 sociology/demography/interdisciplinary journals) and the arXiv category list.
  229. To add a custom journal or arXiv query without editing JSON by hand:
  230. ```
  231. /scholar-monitor add
  232. ```
  233. which prompts you for backend type, identifier (ISSN for journals, arXiv query string for preprints), category label, and cadence.
  234. ### Step 3: Test the fetch pipeline (no phone push yet)
  235. ```
  236. /scholar-monitor preview # dry-run: show what would fetch, no network, no state change
  237. /scholar-monitor arxiv-llm # real fetch from one source, writes output/monitor/feed-YYYY-MM-DD.md
  238. ```
  239. Open the feed file. If it has paper entries with titles, authors, dates, and 2–3-sentence summaries, the fetcher works. Now wire up a push channel.
  240. ### Step 4a: Phone push via **ntfy.sh** (recommended — zero auth, 5 minutes)
  241. ntfy is a free push service with no accounts. You pick a secret topic string, subscribe to it on your phone, and `scholar-monitor` POSTs notifications to that topic.
  242. **On your phone:**
  243. 1. Install the **ntfy** app (iOS App Store / Google Play — published by Philipp Heckel).
  244. 2. Open the app → tap **+** → paste a random topic string (see next step) → **Subscribe**.
  245. **On your computer:**
  246. ```bash
  247. # Generate an unguessable topic. Anyone who knows this string can push to your
  248. # phone, so save it somewhere like a password manager, and treat it as a secret.
  249. openssl rand -hex 8
  250. # → e.g., b4ab8afe7e06d2ef
  251. ```
  252. Subscribe to that same string on your phone (the **+** step above), then:
  253. ```
  254. /scholar-monitor configure delivery
  255. ```
  256. When prompted, paste the topic string. You can skip the Telegram and email prompts. That's it — next time `/scholar-monitor` fetches papers, you'll get a push notification within seconds of the run.
  257. **Test push:**
  258. ```
  259. /scholar-monitor arxiv-llm
  260. ```
  261. Your phone should buzz with a notification titled "scholar-monitor — N new papers." If it doesn't, check: (1) the ntfy app has the exact topic string subscribed, (2) iOS/Android notification permissions are enabled for the ntfy app, (3) the topic in `~/.claude/scholar-monitor/config.json` matches exactly.
  262. **ntfy free tier limits:** 250 messages/day per IP — more than enough for a daily digest. For higher volume or custom domains, see [ntfy.sh self-hosting](https://docs.ntfy.sh/install/).
  263. ### Step 4b: Phone push via **Telegram** (alternative — more setup, two-way support)
  264. Telegram delivery is more work to set up but gives you a two-way chat channel (you can reply to digests and, if you use other Claude Code Telegram plugins, interact with Claude remotely).
  265. **Prerequisites:**
  266. 1. A Telegram account + the Telegram mobile app installed.
  267. 2. The Claude Code Telegram MCP plugin installed in your Claude Code environment (this is separate from scholar-monitor).
  268. **Setup:**
  269. 1. **Create a bot.** In Telegram, message `@BotFather`, run `/newbot`, name your bot, and save the token (`123456:ABC-DEF...`).
  270. 2. **Configure the plugin.** In a Claude Code session, run the configuration command for your Telegram plugin (typically `/telegram:configure`) and paste the bot token when prompted.
  271. 3. **Find your chat ID.** Message your bot once from your phone. The plugin's allowlist management command (typically `/telegram:access`) will show the pending pairing with your `chat_id`. Approve it.
  272. 4. **Wire it into scholar-monitor.**
  273. ```
  274. /scholar-monitor configure delivery
  275. ```
  276. When prompted, paste the `chat_id` from step 3.
  277. **Test:**
  278. ```
  279. /scholar-monitor arxiv-llm
  280. ```
  281. You'll receive a Telegram message from your bot with the digest summary in the message body and the full `feed-YYYY-MM-DD.md` attached as a document.
  282. **Heads-up:** the Telegram MCP plugin is a moving part — if it disconnects mid-session, scholar-monitor logs the failure and continues (the file channel and knowledge-graph ingest still run). For headless `/loop` scheduling that doesn't depend on a running MCP plugin, ntfy is more reliable.
  283. ### Step 4c (optional): Email via SMTP
  284. Heaviest setup of the three. Requires SMTP credentials (Gmail App Password recommended; see [Google's guide](https://support.google.com/accounts/answer/185833)).
  285. ```
  286. /scholar-monitor configure delivery
  287. ```
  288. When prompted, provide SMTP host (`smtp.gmail.com`), port (`587`), from/to addresses, and the env-var name holding the password (default `SMTP_PASS`). Then in your shell or `.env`:
  289. ```bash
  290. export SMTP_PASS="your-16-char-app-password"
  291. ```
  292. The password lives only in the env var, never in `config.json`.
  293. ### Step 5: Schedule with `/loop`
  294. Once a push channel is working, automate:
  295. ```
  296. /loop 24h /scholar-monitor arxiv-llm # daily arXiv LLM digest
  297. /loop 7d /scholar-monitor # weekly sweep of every enabled source
  298. /loop 1h /scholar-monitor # harmless — per-source cadence_days drops redundant ticks
  299. ```
  300. The `cadence_days` filter in each source ensures idempotency: running `/loop 1h` with a source on a weekly cadence produces **one** digest per week, not 168. Per-source failures (network errors) don't advance that source's cursor, so the next tick retries cleanly.
  301. ### Verifying the setup
  302. ```
  303. /scholar-monitor status
  304. ```
  305. Prints a dashboard: enabled source count, archive size, which delivery channels are configured, and any overdue sources. A healthy setup shows at least one channel beyond `file`, zero errors, and sources with next-due dates in the near future.
  306. If something's off, `~/.claude/scholar-monitor/logs/deliver-YYYY-MM-DD.log` captures per-channel delivery attempts — that's where ntfy HTTP errors or SMTP auth failures land.
  307. ## Usage Examples
  308. ```
  309. # Core pipeline
  310. /scholar-idea why do low-income neighborhoods have lower preventive care uptake
  311. /scholar-brainstorm path/to/gss-codebook.pdf sociology, inequality
  312. /scholar-brainstorm path/to/my-survey-data.csv health disparities for Demography
  313. /scholar-lit-review social capital and labor market outcomes
  314. /scholar-lit-review-hypothesis redlining and activity space segregation for AJS
  315. /scholar-hypothesis mobility and linguistic assimilation
  316. /scholar-design causal identification for education returns
  317. /scholar-analyze interpret regression coefficients for ASR
  318. /scholar-write introduction section on stratification
  319. /scholar-citation insert ASA citations and build reference list
  320. /scholar-journal prepare manuscript for Nature Human Behaviour
  321. /scholar-conceptual theorize typology of immigrant civic engagement
  322. /scholar-openai full output/scripts/
  323. # Knowledge graph (8 modes)
  324. /scholar-knowledge ingest from zotero collection segregation
  325. /scholar-knowledge ingest from url https://arxiv.org/abs/2402.12345
  326. /scholar-knowledge ingest from output output/lit-review-2026-04.md
  327. /scholar-knowledge search theories of spatial assimilation
  328. /scholar-knowledge relate Massey 1993 contradicts Clark 1986
  329. /scholar-knowledge status
  330. /scholar-knowledge compile # build Obsidian wiki
  331. /scholar-knowledge ask what are the main mechanisms linking segregation and health?
  332. /scholar-knowledge re-extract all abstract_only # upgrade when PDFs arrive
  333. /scholar-knowledge export for mobility-health project
  334. # Extended pipeline
  335. /scholar-data find dataset for immigration and labor market outcomes
  336. /scholar-data design a survey on immigrant identity
  337. /scholar-eda run EDA on panel dataset before modeling
  338. /scholar-causal draw DAG for education → earnings; IV using distance to college
  339. /scholar-compute run STM topic model on newspaper corpus
  340. /scholar-open preregistration template for survey experiment
  341. /scholar-replication full for Demography
  342. /scholar-ling analyze discourse of immigration restrictionism
  343. # Ethics and safety
  344. /scholar-init nhanes-bmi ~/Downloads/nhanes.csv # stand up a project + scan raw files (v5.9.0)
  345. /scholar-init review # resolve NEEDS_REVIEW entries interactively
  346. /scholar-init status # print sidecar and init-report state
  347. /scholar-ethics pre-submission ethics check for Demography
  348. /scholar-safety scan data.csv before analysis
  349. # Qualitative methods
  350. /scholar-qual codebook develop codebook for interview study on immigrant identity
  351. /scholar-qual open-coding transcripts/*.txt grounded theory
  352. /scholar-qual thematic 20 parent interviews on school choice
  353. /scholar-qual llm-coding code 500 open-ended survey responses using codebook.csv
  354. /scholar-qual reliability assess inter-coder reliability for 3 coders
  355. # Collaboration
  356. /scholar-collaborate credit 4-author paper on immigrant integration
  357. /scholar-collaborate tasks multi-site ethnography project
  358. # Verification and synchronization
  359. /scholar-verify full output/drafts/full-paper-2026-03-10.md
  360. /scholar-verify stage1
  361. /sync-docs slides.tex script.tex manuscript.tex
  362. # Peer review cycle
  363. /scholar-respond simulate paper.pdf for ASR
  364. /scholar-respond respond reviews.txt paper.pdf
  365. /scholar-respond revise paper.pdf reviews.txt response.txt
  366. ```
  367. ## Full Research Workflow
  368. ```
  369. Research Question
  370. │
  371. ├─► /scholar-idea ← Explore broad idea and formalize RQs
  372. │
  373. ├─► /scholar-brainstorm ← Generate RQs from codebooks, questionnaires, or datasets
  374. │
  375. └─► (or run modular skills below)
  376. │
  377. ├─► /scholar-init ← (v5.9.0) Create project layout, copy raw files, scan +
  378. │ populate .claude/safety-status.json (PreToolUse hook enforces)
  379. │
  380. ├─► /scholar-data ← Find open datasets (100+ sources), auto-fetch, design collection
  381. │
  382. ├─► /scholar-safety ← Scan data files for PII/sensitive data before AI processing
  383. │
  384. ├─► /scholar-lit-review ← Systematic literature synthesis
  385. │
  386. ├─► /scholar-lit-review-hypothesis ← Integrated lit review + theory + hypotheses
  387. │
  388. ├─► /scholar-hypothesis ← Theory + hypotheses (incl. intersectionality,
  389. │ non-Western frameworks)
  390. │
  391. ├─► /scholar-conceptual ← Theory building + conceptual diagrams (TikZ/Mermaid)
  392. │
  393. ├─► /scholar-design ← Research design, power analysis, experiments
  394. │
  395. ├─► /scholar-causal ← Causal inference toolkit (DAG + 13 strategies + sensitivity)
  396. │
  397. ├─► /scholar-eda ← EDA, missing data, cleaning, pre-analysis plan
  398. │
  399. ├─► /scholar-analyze ← Regression interpretation, robustness
  400. │
  401. ├─► /scholar-compute ← NLP / ML / networks (if computational)
  402. │
  403. ├─► /scholar-write ← Draft all sections
  404. │
  405. ├─► /scholar-verify ← 4-agent analysis-to-manuscript consistency check
  406. │
  407. ├─► /scholar-openai ← External second-opinion review (5 Codex agents)
  408. │
  409. ├─► /scholar-citation ← Insert citations, build reference list, audit
  410. │
  411. ├─► /scholar-knowledge ← Persist extracted findings, theories, relationships
  412. │ across projects (layers on Zotero)
  413. │
  414. ├─► /sync-docs ← Synchronize slides, script, and manuscript
  415. │
  416. ├─► /scholar-journal ← Format for target journal
  417. │
  418. ├─► /scholar-open ← Preregistration, data/code sharing, open access
  419. │
  420. ├─► /scholar-replication ← Build, test, and archive replication packages
  421. │
  422. ├─► /scholar-ethics ← AI audit, plagiarism check, integrity audit, compliance
  423. │
  424. ├─► /scholar-respond ← Simulate review → respond → revise
  425. │ (handles conflicting reviewers +
  426. │ resubmission strategy if rejected)
  427. │
  428. ├─► /scholar-qual ← Qualitative coding, grounded theory, thematic analysis, LLM-assisted coding
  429. │
  430. ├─► /scholar-ling ← Sociolinguistics, discourse analysis, variationist methods
  431. │
  432. └─► /scholar-collaborate ← Multi-author collaboration (CRediT, tasks, mentoring)
  433. ```
  434. ## Citation
  435. If you use **open-scholar-skill** in your research, teaching, or any derivative work, please cite the published paper that introduces it:
  436. > Zhang, Yongjun. 2026. "Vibe Researching: Can AI Agents with Skills Replace or Augment Social Scientists?" *Chinese Sociological Review*. https://doi.org/10.1080/21620555.2026.2707167
  437. BibTeX:
  438. ```bibtex
  439. @article{zhang2026vibe,
  440. title = {Vibe Researching: Can AI Agents with Skills Replace or Augment Social Scientists?},
  441. author = {Zhang, Yongjun},
  442. journal = {Chinese Sociological Review},
  443. year = {2026},
  444. pages = {1--36},
  445. doi = {10.1080/21620555.2026.2707167},
  446. url = {https://doi.org/10.1080/21620555.2026.2707167}
  447. }
  448. ```
  449. An open-access preprint is also available on arXiv — **please cite the published version above**, not the preprint:
  450. > Zhang, Yongjun. 2026. "Vibe Researching as Wolf Coming: Can AI Agents with Skills Replace or Augment Social Scientists?" *arXiv preprint* [arXiv:2602.22401](https://arxiv.org/abs/2602.22401).
  451. A citation helps sustain development of the skill suite and signals to journals and reviewers that AI-assisted workflows used here have a documented methodological basis.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.