Skip to content
Back to search

MixtapeTools

Tools for coding, teaching, and presentations with AI assistance

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/scunning1975--mixtapetools/badge.svg)](/listings/scunning1975--mixtapetools)

HTML

<a href="/listings/scunning1975--mixtapetools"><img src="/api/listings/scunning1975--mixtapetools/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.

1. Read the Workflow

Start with [`workflow.md`](workflow.md) to understand the philosophy.

2. Set Up a Project

Copy `claude/CLAUDE.md` to your project root. Fill in your project specifics.

3. Do Your Analysis

Work with Claude as a thinking partner, not a code generator. Ask it to explain its understanding. Verify outputs visually. Document as you go.

4. Invoke Referee 2

When you have results worth checking:

1. Open a **new terminal** (fresh context is essential) 2. Paste the contents of `personas/referee2.md` 3. Say: "Please audit and replicate the project at [path]. Primary language is [R/Stata/Python]." 4. Respond to the referee report (fix or justify each concern) 5. Iterate until verdict is Accept

---

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.

README.md · README · 466 lines

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

  1. # MixtapeTools
  2. > Tools for empirical economics research with Claude Code — audit protocols, presentation systems, PDF workflows, and a research GTD harness.
  3. ---
  4. ## About This Repo
  5. This is a collection of tools, templates, and philosophies I've developed while using Claude Code for:
  6. - **Coding** (data analysis scripts, replication code, automation)
  7. - **Teaching** (course materials, lecture decks, pedagogical tools)
  8. - **Presentations** (Beamer decks, slides for talks and seminars)
  9. - **Research management** (hypothesis tracking, evidence courtroom, live dashboards)
  10. As I develop new approaches, I'll add them here. Anyone is free to use them.
  11. **Take everything with a grain of salt.** These are workflows that work for me. Your mileage may vary.
  12. ---
  13. ## A Note on Collaboration Style
  14. The tools here reflect a specific way of working with Claude Code: **Claude as a thinking partner**, not Claude as an autonomous agent. I steer iteratively; Claude executes when the next move is clear and surfaces ambiguity when it isn't. This approach has distinctly less automation than many people prefer, and that is deliberate — I think more clearly when I am thinking *through* Claude rather than *at* Claude. The dialogue is the work, not just the delivery mechanism for the work.
  15. If your taste runs toward highly automated pipelines, or toward AI that never takes initiative without permission, a lot of what's here may feel too loose on one axis and too presumptuous on the other. Both styles are legitimate; they're not what these tools are optimized for.
  16. **YMMV. Take what's useful; leave the rest.**
  17. ---
  18. ## Who I Am
  19. **Scott Cunningham** — Professor of Economics at Baylor University
  20. - **Website:** [www.scunning.com](https://www.scunning.com)
  21. - **Substack:** [causalinf.substack.com](https://causalinf.substack.com) — I write regularly about causal inference, Claude Code, and random things
  22. - **Free book:** [Causal Inference: The Mixtape](https://mixtape.scunning.com) — available online
  23. ---
  24. ## Start Here: My Workflow
  25. **Location:** [`workflow.md`](workflow.md) | **Deck:** [`presentations/examples/workflow_deck/`](presentations/examples/workflow_deck/)
  26. Before diving into specific tools, read my workflow document. It explains **how I think about using Claude Code for empirical research** — not just the tools, but the philosophy behind them.
  27. **Key concepts:**
  28. | Concept | What It Means |
  29. |---------|---------------|
  30. | **Thinking partner, not code monkey** | Claude is a collaborator who reasons about problems, not just a code generator |
  31. | **External memory via markdown** | Claude has amnesia between sessions; markdown files provide institutional memory |
  32. | **Cross-software replication** | R = Stata = Python to 6 decimal places, or something is wrong |
  33. | **Adversarial review (Referee 2)** | Fresh Claude instance audits your work; you can't grade your own homework |
  34. | **Verification through visualization** | Trust pictures over numbers; errors become visible |
  35. | **Documentation as first-class output** | If it's not documented, it didn't happen |
  36. Everything else in this repo implements these principles.
  37. ---
  38. ## The Tools
  39. ### 1. Referee 2 (Systematic Audit & Replication Protocol)
  40. **Location:** [`skills/referee2/`](skills/referee2/) | `personas/referee2.md` (full protocol)
  41. Referee 2 is a **health inspector for empirical research** — a systematic five-audit protocol with cross-language replication, formal referee reports, and a revise & resubmit process. It runs after a project is complete, in a **fresh terminal**, by a Claude instance that has never seen the work. The separation is what makes it independent: the Claude that built the pipeline cannot objectively audit it.
  42. **The Five Audits:**
  43. | Audit | What It Does |
  44. |-------|--------------|
  45. | **Code Audit** | Coding errors, missing value handling, merge diagnostics, variable construction |
  46. | **Cross-Language Replication** | Replication scripts in 2 other languages (R/Stata/Python), results compared to 6 decimal places |
  47. | **Directory Audit** | Folder structure, relative paths, naming conventions — replication-package ready? |
  48. | **Output Automation Audit** | Are tables and figures programmatically generated or manually created? |
  49. | **Econometrics Audit** | Identification strategy, standard errors, fixed effects, parallel trends, first stage |
  50. **Critical Rule:** Referee 2 NEVER modifies author code. It only creates its own replication scripts. Only the author modifies the author's code.
  51. *Referee 2 is one of two complementary audit tools. See below.*
  52. ---
  53. ### 2. Blindspot (Make the Stone Stony Again)
  54. **Location:** [`skills/blindspot/`](skills/blindspot/) | `.claude/skills/blindspot/SKILL.md` (actual skill)
  55. Blindspot is a **peripheral vision audit for empirical output** — a structured protocol for finding what the author cannot see. Problems hiding in plain sight (**vices**) and opportunities being overlooked (**virtues**).
  56. **The Shklovsky principle:** Viktor Shklovsky, the Soviet literary theorist, argued that art exists to restore perception. A man who walks barefoot up a mountain eventually cannot feel his feet. Art exists to make the stone stony again. Research has the same problem: by the time you've spent months on a paper, the main finding has collapsed your attention, and everything else — the spike at t=1, the missing subgroup, the heterogeneity richer than the average — has become invisible.
  57. Blindspot makes the stone stony again.
  58. **The Blindspot Grid — four quadrants, two vices and two virtues:**
  59. | | What's there but unseen | What's absent but unnoticed |
  60. |---|---|---|
  61. | **Problems** | **Vice 1: The Unexplained Feature** — a spike, a sign flip, a sample-size drop nobody asked about | **Vice 2: The Convenient Absence** — a robustness check never run, a subgroup never examined, a dog that didn't bark |
  62. | **Opportunities** | **Virtue 1: The Unasked Question** — heterogeneity richer than the average, a mechanism visible in the data but absent from the hypothesis | **Virtue 2: The Unexploited Strength** — an identification argument stronger than the paper claims, a falsification test that would crush the main objection |
  63. **Ruling:** CLEAR / CONDITIONAL / HOLD
  64. **Usage:** `/blindspot path/to/figure-or-table "what I think the main finding is"`
  65. Read the full documentation: [`skills/blindspot/README.md`](skills/blindspot/README.md)
  66. ---
  67. ### Referee 2 and Blindspot: Complements, Not Substitutes
  68. These two tools address different failure modes at different stages of the research process. **Both should be run. Neither replaces the other.**
  69. | | Referee 2 | Blindspot |
  70. |---|---|---|
  71. | **Core question** | *Is this implemented correctly?* | *Can you see what's in front of you?* |
  72. | **Failure mode it catches** | Coding errors, bad merges, wrong SEs, non-replicating results | Overlooked problems (vices) and overlooked opportunities (virtues) |
  73. | **When it runs** | After the project is complete | When output first appears, before writing begins |
  74. | **Session** | Fresh terminal — independence is structural | Same session — you need the person closest to the work |
  75. | **Persona** | Health inspector with a checklist | Shklovsky — restoring perception |
  76. | **Would have caught a merge error?** | Yes | Maybe |
  77. | **Would have caught the t=1 spike?** | No | Yes |
  78. **Why separate sessions for Referee 2 but not Blindspot?**
  79. Referee 2 needs a fresh session because it's auditing *implementation* — the Claude that built the code will rationalize its own choices. True independence requires structural separation.
  80. Blindspot doesn't need separation because it's auditing *perception* — your own understanding of output you produced. You're the right person to do that, with a structured forcing function to look past what you expect to see.
  81. **The workflow:**
  82. 1. Produce output → `/blindspot` → interpret and write
  83. 2. Complete project → open fresh terminal → `/referee2`
  84. ---
  85. ### 3. Bibcheck (Many-Agent Bibliography Audit)
  86. **Location:** [`skills/bibcheck/`](skills/bibcheck/) | `.claude/skills/bibcheck/SKILL.md` (actual skill)
  87. A third verification skill, narrower than Referee 2 and bounded to a single artifact: the `.bib` file. `/bibcheck` audits a bibliography by spawning **many narrow-focus agents** — one per citation, or one per field across all citations — to verify each entry against canonical sources (DOI, journal landing page, author working paper).
  88. **Why narrow agents:** A single agent asked to audit 80 citations in one pass tends to drift. Early entries get careful treatment; later entries get pattern-matched. Splitting the work — one agent per entry, full attention budget on a small task, parallel siblings for the next — moves the bottleneck from agent attention to orchestration. Orchestration is what cheap parallel agents are for.
  89. **Two modes:**
  90. | Mode | Best for | How it works |
  91. |------|----------|--------------|
  92. | **Per-citation** (default) | Catching mixed-up entries (title of paper A with authors of paper B) | One Agent subagent per `@article{}` entry; each fully audits its one entry; reviewer agent consolidates |
  93. | **Per-field** (`--by-field`) | Catching systematic transcription errors (a journal name consistently wrong, swapped volume/issue, leaked working-paper years) | One specialist per field (title, year, journal, authors, volume/issue, pages, DOI); each launched as an isolated `claude --dangerously-skip-permissions -p` subprocess so they cannot peek at each other |
  94. **Outputs:** a timestamped `bibcheck_<ts>/` folder containing `bibcheck_report.md` (per-entry findings, Clean / Corrected / Unverifiable summary) and `corrected.bib` (drop-in replacement). The skill never auto-overwrites the source — you review and merge.
  95. **Critical Rule:** `/bibcheck` is bounded. It checks whether `.bib` entries are accurate descriptions of papers that exist. It does NOT check whether each citation supports the claim it's attached to in the manuscript — that is a `/referee2` literature audit.
  96. **Usage:** `/bibcheck path/to/refs.bib` (per-citation) or `/bibcheck --by-field path/to/refs.bib` (per-field). Optional `--max-parallel N` (default 8).
  97. Read the full documentation: [`skills/bibcheck/README.md`](skills/bibcheck/README.md)
  98. ---
  99. ### 4. The Rhetoric of Decks
  100. **Location:** `presentations/`
  101. My philosophy of slide design, plus a tested prompt for generating Beamer presentations. The key insight: aim for MB/MC equivalence across slides (smoothness), not maximum density.
  102. **Core principles:**
  103. - Beauty earns attention; attention enables communication
  104. - Titles are assertions, not labels
  105. - One idea per slide
  106. - Bullets are defeat — find the structure hiding in your list
  107. ---
  108. ### 5. Split-PDF Skill (Download, Split, and Deep-Read Papers)
  109. **Location:** [`skills/split-pdf/`](skills/split-pdf/) (human-readable guide) | `.claude/skills/split-pdf/SKILL.md` (actual skill)
  110. A Claude Code **skill** — an invocable `/split-pdf` command that automates the full pipeline for reading academic papers:
  111. 1. **Acquire** the PDF (web search + download, or use a local file in place)
  112. 2. **Check** for an existing `_text.md` extract or existing splits — offer to reuse
  113. 3. **Split** into 4-page chunks via PyPDF2, stored in a `_build/` directory
  114. 4. **Read** 3 chunks at a time (~12 pages), pausing between batches
  115. 5. **Extract** structured reading notes across 8 dimensions into `notes.md`
  116. 6. **Persist** the final extraction as `<basename>_text.md` alongside the source PDF
  117. **Why not just read the full PDF?** Long PDFs either crash the session ("prompt too long" — unrecoverable) or produce shallow, hallucinated output. Splitting forces Claude to attend carefully to every section and externalizes understanding into markdown notes incrementally.
  118. **Key features:** In-place PDF handling (no centralized `articles/` folder), persistent `_text.md` extracts (skip re-reading on future invocations), split reuse, and an agent isolation protocol that prevents context bloat when other skills call `/split-pdf`.
  119. **Usage:** Type `/split-pdf path/to/paper.pdf` or `/split-pdf "search query for paper"`
  120. Read the full documentation: [`skills/split-pdf/README.md`](skills/split-pdf/README.md)
  121. ---
  122. ### 5b. Beautiful Deck (End-to-End Deck Creation)
  123. **Location:** [`skills/beautiful_deck/`](skills/beautiful_deck/) | `.claude/skills/beautiful_deck/SKILL.md` (actual skill)
  124. A Claude Code **skill** — invoke with `/beautiful_deck` — that runs the full deck-generation pipeline. This is the operational version of the prompt that used to live at `presentations/deck_generation_prompt.md`.
  125. **What the skill enforces:**
  126. - **Audience triage before any slide is written** — commits to a rhetorical balance (ethos / pathos / logos) that fits the audience (academic seminar, teaching lecture, conference talk, working deck, external non-academic)
  127. - **Original theme, never boilerplate** — a custom `.sty` tuned to the audience. May build on `metropolis`, `moloch`, `focus`, etc. as a foundation, but a reader should not be able to tell what theme package is underneath
  128. - **Pedagogical movement: Narrative → Application → Picture → Codeblock → Technical** — intuition first, technical last. The anti-pattern is the lecture that opens with definitions and ends with an example "for intuition"
  129. - **Format flexibility** — Beamer by default. Accepts Quarto, Typst, reveal.js, Marp on explicit user request
  130. - **Code-first figure generation** — standalone scripts run before `\includegraphics{}` is written
  131. - **Zero-warning compile loop** — Overfull / Underfull / font / reference warnings all must return zero at every checkpoint, not just the final compile
  132. - **`/tikz` cleanup** — invoked automatically to catch label collisions and coordinate drift
  133. - **Rhetoric audit (sub-agent)** — checks titles-as-assertions, one-idea-per-slide, MB/MC balance, narrative arc, Devil's Advocate presence
  134. - **Graphics audit (sub-agent)** — checks numerical accuracy, label positioning, axis coherence, color consistency, font sizing
  135. **Usage:** `/beautiful_deck [optional content path or description]`
  136. ---
  137. ### 6. Compile Deck (Beamer Presentations with the Rhetoric of Decks)
  138. **Location:** `.claude/commands/compiledeck.md`
  139. A Claude Code **command** — invoke with `/compiledeck` — that embeds the full Rhetoric of Decks philosophy so you don't have to explain it each time.
  140. **The skill asks two questions:**
  141. 1. **Who is the audience?**
  142. - **External** (seminar, conference, teaching) — sparse, performative, one idea per slide
  143. - **Working** (coauthors, yourself) — can be more detailed, documents reasoning
  144. 2. **What's the tone?**
  145. - **Professional/Academic** — your consistent "house style" for outward-facing work
  146. - **Colorful/Expressive** — unique, creative design each time
  147. **What's embedded:**
  148. - The Three Laws (Beauty is Function, Cognitive Load is Enemy, Slide Serves Spoken Word)
  149. - Titles as assertions, not labels
  150. - MB/MC equivalence across slides
  151. - The compile loop (compile → fix errors → fix warnings → visual check → repeat)
  152. - TikZ coordinate checking and figure label verification
  153. **Usage:** Type `/compiledeck` when creating or editing a Beamer deck.
  154. ---
  155. ### 7. TikZ Collision Audit
  156. **Location:** [`skills/tikz/`](skills/tikz/) | `.claude/skills/tikz/SKILL.md` (actual skill)
  157. A Claude Code **skill** — invoke with `/tikz path/to/file.tex` — that systematically audits and fixes every visual collision in every TikZ figure in a LaTeX file. Labels sitting on arrows, text inside boxes, arrows crossing each other — found and fixed using measurement, not intuition.
  158. **The problem it solves:** TikZ compiles silently even when labels overlap arrows or text bleeds into box edges. The compiler catches nothing. This skill catches everything.
  159. **How it works:** Six ordered passes, each targeting a specific class of collision:
  160. | Pass | What it checks |
  161. |------|---------------|
  162. | Pass 0 | Cross-slide consistency — same diagram on multiple slides must be identical except for deliberate changes |
  163. | Pass 1 | Bézier curves first — computes max curve depth using `(chord/2) × tan(bend/2)`, checks every label against the danger zone |
  164. | Pass 2 | Gap calculations — estimates label width in cm, compares against usable space between nodes |
  165. | Pass 3 | Arrow label keywords — every label must have `above`, `below`, `left`, or `right` |
  166. | Pass 4 | Boundary rule — labels within 0.4cm of any circle, rectangle, or filled shape are a collision |
  167. | Pass 5 | Margin check — minimum clearances between all object pairs |
  168. **Most common pattern it catches:** Step labels on flow diagrams that are wider than the arrow between boxes — they look right in code but overlap box text when rendered.
  169. **Full formulas and reference tables:** `compiledeck/tikz_rules.md`
  170. **Usage:** `/tikz path/to/deck.tex`
  171. ---
  172. ### 8. Additional Commands
  173. **Location:** `.claude/commands/`
  174. | Command | Description |
  175. |---------|-------------|
  176. | `/compiletex [file.tex]` | Compile any LaTeX file and report errors/warnings. Aims for zero warnings. |
  177. | `/newproject [name]` | Scaffold a new research project with standard folder structure and CLAUDE.md. Also available as a [skill](skills/newproject/). |
  178. | `/newbook [slug]` | Scaffold a book-shaped project: `memoir`-based LaTeX skeleton, Palatino body, Gov 2001 palette, voiced-sidebar callouts, one chapter per file, bibliography stub, CLAUDE.md with voice cast. Parallel to `/newproject`. [See documentation](skills/newbook/). |
  179. ---
  180. ### 9. CLAUDE.md Template
  181. **Location:** `claude/CLAUDE.md`
  182. A template for giving Claude persistent memory within a project. Copy it to your project root and fill in the specifics. Claude Code will automatically read it every session.
  183. ---
  184. ### 10. GTD Research Harness *(work in progress)*
  185. **Location:** [`gtd/`](gtd/)
  186. A warrant-first GTD system for conducting empirical research with an AI thinking partner. Makes research dialogue **recoverable**, claims **falsifiable**, and the current state of knowledge **always visible**.
  187. The system has three components:
  188. - **The protocol** — how to file hypotheses, insights, and decisions so they accumulate into a coherent knowledge base rather than a pile of chat history
  189. - **The dashboard** — a live Python server (`gtd/templates/dashboard_server.py`) that reads the filesystem on every request and renders: a re-entry page, narrative with drift detection, a five-stage evidence courtroom, pipeline freshness tracking, hypothesis DAG, and referee report viewer
  190. - **The interrogation** — a structured prompt (`gtd/INTERROGATION.md`) for periodic reviews that stress-test whether the narrative is actually earned
  191. **Core idea:** Every claim must have a warrant. Every warrant must have a falsification test. Every falsification test must be filed as an insight. The courtroom tab enforces this by requiring evidence at all five stages before a claim can appear in the narrative or manuscript.
  192. **Status:** Under active development through use on a live R&R project. Stable enough to copy and adapt; not stable enough to treat as finished.
  193. Read: [`gtd/README.md`](gtd/README.md) | Dashboard template: [`gtd/templates/dashboard_server.py`](gtd/templates/dashboard_server.py)
  194. ---
  195. ## Repository Structure
  196. ```
  197. MixtapeTools/
  198. ├── README.md # You are here
  199. ├── workflow.md # How I use Claude Code for research (START HERE)
  200. ├── gtd/ # GTD research harness (work in progress)
  201. │ ├── README.md # Full protocol documentation
  202. │ ├── INTERROGATION.md # Periodic review prompt
  203. │ ├── SKILL.md # Claude Code skill definition
  204. │ ├── workflow.md # GTD-specific workflow
  205. │ ├── docs/ # Design rationale and tab-by-tab guide
  206. │ ├── examples/ # Example hypothesis/insight/decision files
  207. │ └── templates/ # Dashboard server + static dashboard
  208. ├── skills/ # Human-readable guides to Claude Code skills
  209. │ ├── README.md # What skills are, how to use them, how to install
  210. │ ├── blindspot/ # Blindspot: peripheral vision audit for output
  211. │ ├── split-pdf/ # Split-PDF: deep-read academic papers
  212. │ ├── newproject/ # Newproject: scaffold new research projects
  213. │ └── tikz/ # TikZ: collision audit for LaTeX figures
  214. ├── .claude/
  215. │ ├── commands/ # Slash commands (invoke with /command-name)
  216. │ │ ├── compiledeck.md # /compiledeck — Beamer with Rhetoric of Decks
  217. │ │ ├── compiletex.md # /compiletex — Compile LaTeX, report warnings
  218. │ │ └── newproject.md # /newproject — Scaffold new research project
  219. │ └── skills/
  220. │ ├── blindspot/ # Skill: make the stone stony again
  221. │ ├── tikz/ # Skill: audit and fix TikZ visual collisions
  222. │ ├── split-pdf/ # Skill: download, split, and deep-read PDFs
  223. │ └── newproject/ # Skill: scaffold new research projects
  224. ├── claude/ # Templates for working with Claude
  225. │ └── CLAUDE.md # Project context template (copy to your projects)
  226. ├── personas/ # Systematic audit & replication protocols
  227. │ └── referee2.md # The 5-audit protocol for empirical research
  228. └── presentations/ # Everything about slide decks
  229. ├── rhetoric_of_decks.md # Practical principles (condensed)
  230. ├── rhetoric_of_decks_full_essay.md # Full intellectual framework (600+ lines)
  231. ├── deck_generation_prompt.md # The prompt + iterative workflow
  232. └── examples/
  233. ├── workflow_deck/ # Visual presentation of the workflow
  234. ├── rhetoric_of_decks/ # The philosophy deck (45 slides)
  235. └── gov2001_probability/ # A lecture deck
  236. ```
  237. ---
  238. ## The Philosophy
  239. ### Design Before Results
  240. During estimation and analysis, focus entirely on whether the specification is correct. Results are meaningless until the "experiment" is designed on purpose. Don't get excited or worried about point estimates until the design is intentional.
  241. ### Trust But Verify (Heavily on Verify)
  242. AI makes confident mistakes. Cross-software replication (R = Stata = Python) catches bugs that single-language analysis misses. If results aren't identical to 6+ decimal places across implementations, something is wrong.
  243. ### Adversarial Review Requires Separation
  244. If you ask the same Claude that wrote code to review it, you're asking a student to grade their own exam. True adversarial review requires a **new terminal** with fresh context and no prior commitments.
  245. ### Referee 2 Never Modifies Author Code
  246. The audit must be independent. Referee 2 creates its own replication scripts but **never touches the author's code**. Only the author modifies the author's code. This separation ensures the audit is truly external.
  247. ### Formal Process > Informal Vibes
  248. Checklists beat intuition. The Referee 2 protocol works because it specifies exactly what to check, requires concrete deliverables (replication scripts, comparison tables, referee reports), and creates a paper trail.
  249. ### Documentation Is First-Class Output
  250. If it's not documented, it didn't happen. Every audit produces a dated referee report filed in `correspondence/`. Every response is documented. Replication scripts are permanent artifacts. Future you (or your collaborators) can reconstruct exactly what happened.
  251. ---
  252. ## Quick Start
  253. ### 1. Read the Workflow
  254. Start with [`workflow.md`](workflow.md) to understand the philosophy.
  255. ### 2. Set Up a Project
  256. Copy `claude/CLAUDE.md` to your project root. Fill in your project specifics.
  257. ### 3. Do Your Analysis
  258. Work with Claude as a thinking partner, not a code generator. Ask it to explain its understanding. Verify outputs visually. Document as you go.
  259. ### 4. Invoke Referee 2
  260. When you have results worth checking:
  261. 1. Open a **new terminal** (fresh context is essential)
  262. 2. Paste the contents of `personas/referee2.md`
  263. 3. Say: "Please audit and replicate the project at [path]. Primary language is [R/Stata/Python]."
  264. 4. Respond to the referee report (fix or justify each concern)
  265. 5. Iterate until verdict is Accept
  266. ---
  267. ## Project Directory Structure
  268. For the Referee 2 workflow to function properly, your research projects should include:
  269. ```
  270. your_project/
  271. ├── CLAUDE.md # Project context for Claude
  272. ├── correspondence/
  273. │ └── referee2/
  274. │ ├── 2026-02-01_round1_report.md # Detailed written report
  275. │ ├── 2026-02-01_round1_deck.pdf # Visual presentation of findings
  276. │ ├── 2026-02-02_round1_response.md # Author response
  277. │ └── ...
  278. ├── code/
  279. │ ├── R/ # Author's code (ONLY author modifies)
  280. │ ├── stata/
  281. │ ├── python/
  282. │ └── replication/ # Referee 2's replication scripts
  283. ├── data/
  284. │ ├── raw/
  285. │ └── clean/
  286. └── output/
  287. ├── tables/
  288. └── figures/
  289. ```
  290. ---
  291. ## Contributing
  292. Have improvements or additions? PRs welcome. I'm particularly interested in:
  293. - Additional audit protocols (security reviewer, pedagogy reviewer, etc.)
  294. - Examples showing the Referee 2 workflow catching real bugs
  295. - Tools for other aspects of coding and teaching
  296. ---
  297. ## Acknowledgments
  298. Inspired by [Boris Cherny's ChernyCode](https://github.com/meleantonio/ChernyCode) template for AI coding best practices.
  299. ---
  300. ## License
  301. Use freely. Attribution appreciated but not required.
  302. ---
  303. *Last updated: May 2026*

Ratings and comments

Sign in to rate this skill.

Sign in

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