Claude Code Academic Workflow Template
A ready-to-fork Claude Code template for academics using LaTeX/Beamer + R, with multi-agent review, quality gates, adversarial QA, and replication protocols.
Evidence: README describes permission modes (Normal/Auto-accept/Bypass) and pre-approved Bash/Edit patterns, but no explicit least-privilege principle; user confirmation exists (plan approval, explicit /commit), but not all sensitive operations; data flow transparency partially described (e.g., /verify-claims forked verifier), but not complete; sensitive data handling mentioned (e.g., /disclosure-check), but not in depth; dependency security not mentioned; external effects (e.g., GitHub Pages deployment) described, but permission scope not detailed; rollback not mentioned; source attribution (author, license) present, but publisher unverified. Deductions: lack of explicit least-privilege evidence, incomplete data flow and sensitive data handling, dependency security absent, rollback missing.
Evidence: README and CHANGELOG exist, but no self-consistency tests; dependency availability not mentioned; failure messages (e.g., validate-setup.sh reports missing tools) described, but error handling details absent. Deductions: self-consistency lacks test evidence, dependency availability absent, failure messages incomplete.
Evidence: README clearly targets academic users (LaTeX/Beamer + R) and lists multiple scenarios (slides, papers, data analysis); capability boundaries described (e.g., /review-paper --peer scope); trigger precision (e.g., explicit /commit) explained; environment fit (e.g., XeLaTeX, Quarto requirements) stated. Deductions: capability boundaries and trigger precision well described, but environment fit lacks detailed configuration.
Evidence: Information architecture clear (README, CHANGELOG, CONTRIBUTING); install notes detailed (Quick Start, validate-setup.sh); naming stability not explicit; examples and FAQ present (HelloWorld demos); known limitations not explicit; license MIT; versioning changelog exists; maintenance responsibility not explicit. Deductions: naming stability, known limitations, maintenance responsibility not explicit.
Evidence: Output usability (e.g., PDF, HTML outputs) described; marginal value (e.g., multi-agent review, adversarial QA) explained; cost-benefit (e.g., model routing, cost monitoring) mentioned, but no concrete data. Deductions: cost-benefit lacks concrete data.
Evidence: Claim traceability (e.g., /verify-claims) described, but no verification results; cross-source corroboration (e.g., citing Anthropic docs) present, but no independent verification; fact-inference separation (e.g., framing honesty) mentioned, but not systematic. Deductions: lack of verification results and independent corroboration.
- Publisher identity unverified; treat source with caution.
- Dependency security not mentioned; check for vulnerabilities.
- Rollback mechanism absent; consider reversibility of operations.
- Sensitive data handling incomplete; review data flows.
- Cost-benefit lacks data; requires actual testing.
What does this agent do, and when should you use it?
This repository is a comprehensive Claude Code configuration template for academic research workflows, targeting users who work with LaTeX/Beamer, Quarto, and R. It implements a 'contractor mode' where users state a goal, and Claude plans, executes with specialized agents, fixes issues, verifies quality, and presents results. The template includes 18 specialized agents (e.g., proofreader, slide-auditor, pedagogy-reviewer, r-reviewer, domain-reviewer), 52 skills (e.g., /create-lecture, /review-paper, /data-analysis, /qa-quarto), 32 rules, and 7 hooks, enforcing a goal-first, gate-enforced workflow. It features multi-agent review with a shared finding schema, adversarial QA with a critic-fixer loop until convergence, quality scoring (0-100, with commit threshold at 80), context survival via MEMORY.md and session logs, and verification discipline including /verify-claims, /audit-reproducibility, and /humanize. Originating from a production PhD course at Emory University, it includes preconfigured disciplines for economics and political science, and is extensible to other fields via knowledge base templates and custom domain reviewers.
The repository provides a set of Claude Code configurations that orchestrate academic task automation. Users invoke Claude Code in a forked repo, paste a starter prompt, and Claude reads the configuration files (CLAUDE.md, rules, skills, agents) to plan and execute tasks. It runs specialized agents for parallel review: for example, proofreader checks grammar, slide-auditor checks visual layout, r-reviewer checks R code quality, and domain-reviewer checks field-specific correctness. The orchestration runtime (orchestrator-protocol) manages a fan-out-reduce-judge loop, and quality gates (80/90/95) are enforced by the /commit skill and a pre-commit hook. Adversarial QA (/qa-quarto) runs a critic-fixer loop until no new findings. Skills like /review-paper simulate peer review with disposition sampling, /audit-reproducibility cross-checks numeric claims against script outputs, /verify-claims uses chain-of-verification, and /humanize detects AI-voice tells. The template supports both R and Stata pipelines, Monte Carlo simulations (/simulation-study), and R package release gates (/r-package-check). Outputs include compiled PDFs (via /compile-latex), HTML slides (via /deploy), and replication packages.
- An economics professor preparing PhD lecture slides can use /create-lecture, which plans structure, generates content, and runs slide-excellence for multi-agent review.
- A graduate student writing a research paper can use /lit-review to find literature, /review-paper --peer for simulated peer review, and /verify-claims to fact-check citations before submission.
- An applied econometrician conducting data analysis can use /data-analysis to run end-to-end R pipelines with publication-ready output and /audit-reproducibility to verify numeric claims.
- A researcher preparing a replication package can use /replication-package to assemble an AEA-compliant package with environment snapshot and claim provenance.
- An assistant professor submitting to a journal can use seven-pass-review for adversarial review and /humanize to detect AI-style writing before final submission.
- A researcher designing Monte Carlo studies can use /simulation-study to create parameterized DGPs, estimator grids, and Monte Carlo SEs, with review by sim-reviewer.
What are this agent's strengths and limitations?
- Features 18 specialized agents, each focusing on a narrow review dimension (e.g., proofreader, slide-auditor, r-reviewer), outperforming general-purpose review.
- Quality gates are enforced via a real pre-commit hook, ensuring that bypassing the skill doesn't bypass the review.
- Adversarial QA (critic-fixer loop) and simulated peer review with disposition sampling (--variance N) catch errors that single-pass review misses.
- Includes verification discipline layers (/verify-claims, /audit-reproducibility) that block fabricated citations and numerical inconsistencies.
- Platform-specific to Claude Code, requiring a Claude subscription or API access and relying on Anthropic models.
- Steep learning curve: over 50 skills and 30 rules require time to understand; new users may be overwhelmed.
- External dependencies like XeLaTeX, Quarto, R, and Python are required for full functionality, which may be heavy for text-only users.
- Extensive documentation (guide, changelog, ecosystem) necessitates significant reading to use effectively.
How do you install or deploy this agent?
- Fork the repository pedrohcgs/claude-code-my-workflow on GitHub. 2. Clone your fork: git clone https://github.com/YOUR_USERNAME/claude-code-my-workflow.git my-project && cd my-project. 3. Run ./scripts/validate-setup.sh to check required tools (Claude Code, git, Python 3; XeLaTeX, Quarto, R optional). 4. Run ./scripts/install-hooks.sh to install pre-commit hooks for quality gates and git guardrails.
How do you use this agent?
- Start Claude Code in the project directory: claude. 2. Paste the starter prompt from the guide (https://psantanna.com/claude-code-my-workflow/workflow-guide.html), filling in your project name and description. 3. Claude reads the configuration, enters plan mode, and proposes an approach. 4. Approve the plan and invoke a skill like /create-lecture, /data-analysis, or /review-paper. 5. The skill runs the implement-verify-review-fix-reverify-score loop and returns a summary. 6. Use /commit to commit changes, and the pre-commit hook runs quality gates. For fully autonomous runs, use --permission-mode acceptEdits or Bypass mode.
How does this agent compare with similar options?
The template originated from an Emory University course by Pedro Sant'Anna and is part of an ecosystem including clo-author (paper-centric workflows), claudeblattman (for non-technical academics), MixtapeTools (presentation rhetoric), autoresearch (autonomous research), and ClaudeCodeTools (sequential review protocol).