research-expert — Claude Code skill: research methods and stats
research-expert — a skill that hands the agent working Python for study design and statistics, plus guidance on writing the paper afterwards.
Apache-2.0 256 installs ★ 45 updated 2026-10-12
npx skills add personamanagmentlayer/pcl --skill research-expert -a claude-codeWhat research-expert does
The skill bundles Python helpers for planning a study and making sense of the results: sample size for two-sample and proportion tests, simple, block and stratified randomisation, descriptive summaries, a t-test with Cohen's d, one-way ANOVA with eta-squared, OLS regression and a correction for multiple comparisons. It also walks through study types, RCTs to meta-analysis, and the parts of a manuscript.
Its allowed tools are Read, Write and Edit, so it edits files and leaves execution to you. The snippets import numpy, scipy, pandas and statsmodels; install those in your environment or the analysis stops at the first import.
Literature reviews, proposals, citation handling and publishing ethics come as text guidance rather than code.
What it helps with
- size a two-arm study before recruitment
- assign subjects to groups with block randomisation
- get Cohen's d next to a t-test p-value
- correct p-values for multiple comparisons
- draft a manuscript in IMRAD order
Example prompts for the agent
- Work out the sample size for a two-sample t-test with power 0.8
- Block-randomise the participants across the study groups
- Run a one-way ANOVA on the groups and report eta-squared
How to install research-expert
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill research-expert -a claude-code2Manually: put the files in place
~/.claude/skills/research-expert/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/research-expert/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill research-expert -a codex2Manually: put the files in place
.agents/skills/research-expert/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill research-expert -a cursor2Manually: put the files in place
.cursor/skills/research-expert/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install personamanagmentlayer/pcl stdlib/scientific/research-expert2Manually: put the files in place
.github/skills/research-expert/SKILL.md1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill research-expert -a gemini-cli2Platform CLI
gemini skills install https://github.com/personamanagmentlayer/pcl --path stdlib/scientific/research-expertManually: put the files in place
.devin/skills/research-expert/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill research-expert -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about research-expert
How do I install research-expert in Claude Code?
Run npx skills add personamanagmentlayer/pcl --skill research-expert -a claude-code, then the skill sits at ~/.claude/skills/research-expert/SKILL.md.
What does research-expert do?
It gives the agent a method for planning a study and analysing the data: sample size, randomisation, descriptive stats, hypothesis tests and regression, with writing advice alongside.
What does it need to work?
Python with numpy, scipy, pandas and statsmodels available. The skill only reads and writes files, so you run the code yourself.
Source text
SKILL.md · Apache-2.0
---
name: research-expert
version: 1.1.0
description: >-
Expert-level research methodology, academic writing, statistical analysis, and scientific
investigation. Use when the user mentions methodology, statistics, academic writing, or
experimental design, or when the task involves Research Design, Statistical Analysis, or
Data Analysis.
category: scientific
tags: [research, methodology, statistics, academic-writing, experimental-design]
allowed-tools:
- Read
- Write
- Edit
---
# Research Methodology Expert
Expert guidance for research methodology, experimental design, statistical analysis, and academic writing.
## Core Concepts
### Research Design
- Experimental vs observational studies
- Randomized controlled trials (RCTs)
- Cross-sectional, longitudinal, cohort studies
- Case-control studies
- Systematic reviews and meta-analysis
- Sample size determination
### Statistical Analysis
- Descriptive statistics
- Hypothesis testing
- Confidence intervals
- Regression analysis
- ANOVA and t-tests
- Non-parametric tests
- Multiple testing correction
### Academic Writing
- Literature review
- Research proposals
- Manuscript structure (IMR AD)
- Citation management
- Peer review process
- Publishing ethics
## Experimental Design
```python
from dataclasses import dataclass
from typing import List, Optional
import numpy as np
from scipy import stats
@dataclass
class Study:
name: str
design_type: str # 'RCT', 'observational', 'cohort'
sample_size: int
groups: List[str]
primary_outcome: str
secondary_outcomes: List[str]
class SampleSizeCalculator:
"""Calculate required sample size for studies"""
@staticmethod
def two_sample_ttest(effect_size: float, alpha: float = 0.05,
power: float = 0.8) -> int:
"""Calculate sample size for two-sample t-test"""
from statsmodels.stats.power import tt_ind_solve_power
n = tt_ind_solve_power(
effect_size=effect_size,
alpha=alpha,
power=power,
alternative='two-sided'
)
return int(np.ceil(n))
@staticmethod
def proportion_test(p1: float, p2: float, alpha: float = 0.05,
power: float = 0.8) -> int:
"""Calculate sample size for comparing proportions"""
from statsmodels.stats.power import zt_ind_solve_power
effect_size = (p2 - p1) / np.sqrt(p1 * (1 - p1))
n = zt_ind_solve_power(
effect_size=effect_size,
alpha=alpha,
power=power,
alternative='two-sided'
)
return int(np.ceil(n))
class ExperimentalDesign:
"""Design and randomize experimental studies"""
def __init__(self, n_subjects: int, n_groups: int):
self.n_subjects = n_subjects
self.n_groups = n_groups
def simple_randomization(self) -> List[int]:
"""Simple random assignment to groups"""
return np.random.choice(self.n_groups, size=self.n_subjects)
def block_randomization(self, block_size: int) -> List[int]:
"""Block randomization for balanced groups"""
n_blocks = self.n_subjects // block_size
assignments = []
for _ in range(n_blocks):
block = np.repeat(range(self.n_groups),
block_size // self.n_groups)
np.random.shuffle(block)
assignments.extend(block)
# Handle remaining subjects
remainder = self.n_subjects % block_size
if remainder > 0:
extra = np.random.choice(self.n_groups, size=remainder)
assignments.extend(extra)
return assignments
def stratified_randomization(self, strata: List[str]) -> List[int]:
"""Stratified randomization by covariates"""
assignments = np.zeros(self.n_subjects, dtype=int)
for stratum in set(strata):
stratum_indices = [i for i, s in enumerate(strata) if s == stratum]
stratum_n = len(stratum_indices)
stratum_assignments = np.random.choice(
self.n_groups,
size=stratum_n,
replace=True
)
for idx, assignment in zip(stratum_indices, stratum_assignments):
assignments[idx] = assignment
return assignments
```
## Statistical Analysis
```python
import pandas as pd
from scipy import stats
import statsmodels.api as sm
from statsmodels.stats.multitest import multipletests
class StatisticalAnalysis:
"""Perform statistical analyses"""
@staticmethod
def descriptive_stats(data: pd.Series) -> dict:
"""Calculate descriptive statistics"""
return {
"mean": data.mean(),
"median": data.median(),
"std": data.std(),
"min": data.min(),
"max": data.max(),
"q25": data.quantile(0.25),
"q75": data.quantile(0.75),
"skewness": stats.skew(data),
"kurtosis": stats.kurtosis(data)
}
@staticmethod
def independent_ttest(group1: np.ndarray, group2: np.ndarray) -> dict:
"""Perform independent samples t-test"""
statistic, pvalue = stats.ttest_ind(group1, group2)
# Calculate effect size (Cohen's d)
pooled_std = np.sqrt((group1.var() + group2.var()) / 2)
cohens_d = (group1.mean() - group2.mean()) / pooled_std
return {
"t_statistic": statistic,
"p_value": pvalue,
"cohens_d": cohens_d,
"mean_diff": group1.mean() - group2.mean(),
"significant": pvalue < 0.05
}
@staticmethod
def one_way_anova(groups: List[np.ndarray]) -> dict:
"""Perform one-way ANOVA"""
f_statistic, p_value = stats.f_oneway(*groups)
# Calculate effect size (eta-squared)
grand_mean = np.mean(np.concatenate(groups))
ss_between = sum(len(g) * (g.mean() - grand_mean)**2 for g in groups)
ss_total = sum(((g - grand_mean)**2).sum() for g in groups)
eta_squared = ss_between / ss_total
return {
"f_statistic": f_statistic,
"p_value": p_value,
"eta_squared": eta_squared,
"significant": p_value < 0.05
}
@staticmethod
def linear_regression(X: pd.DataFrame, y: pd.Series) -> dict:
"""Perform linear regression"""
X_with_const = sm.add_constant(X)
model = sm.OLS(y, X_with_const).fit()
return {
"coefficients": model.params.to_dict(),
"r_squared": model.rsquared,
"adj_r_squared": model.rsquared_adj,
"f_statistic": model.fvalue,
"p_value": model.f_pvalue,
"summary": model.summary()
}
@staticmethod
def multiple_testing_correction(p_values: List[float],
method: str = 'fdr_bh',
alpha: float = 0.05) -> dict:
"""Apply multiple testing correction"""
reject, pvals_corrected, alphacSidak, alphacBonf = multipletests(
p_values,
alpha=alpha,
method=method
)
return {
"rejected": reject,
"corrected_pvalues": pvals_corrected,
"n_significant": reject.sum(),
"method": method
}
class EffectSize:
"""Calculate effect sizes"""
@staticmethod
def cohens_d(group1: np.ndarray, group2: np.ndarray) -> float:
"""Cohen's d for two groups"""
pooled_std = np.sqrt((group1.var() + group2.var()) / 2)
return (group1.mean() - group2.mean()) / pooled_std
@staticmethod
def hedges_g(group1: np.ndarray, group2: np.ndarray) -> float:
"""Hedges' g (corrected effect size)"""
n1, n2 = len(group1), len(group2)
df = n1 + n2 - 2
correction = 1 - (3 / (4 * df - 1))
d = EffectSize.cohens_d(group1, group2)
return d * correction
@staticmethod
def r_squared_to_cohens_f(r_squared: float) -> float:
"""Convert R² to Cohen's f"""
return np.sqrt(r_squared / (1 - r_squared))
```
## Literature Review
```python
from typing import Dict, List
from dataclasses import dataclass
@dataclass
class Citation:
authors: List[str]
year: int
title: str
journal: str
volume: Optional[int] = None
pages: Optional[str] = None
doi: Optional[str] = None
def format_apa(self) -> str:
"""Format citation in APA style"""
authors_str = self._format_authors_apa()
citation = f"{authors_str} ({self.year}). {self.title}. {self.journal}"
if self.volume:
citation += f", {self.volume}"
if self.pages:
citation += f", {self.pages}"
if self.doi:
citation += f". https://doi.org/{self.doi}"
return citation + "."
def _format_authors_apa(self) -> str:
"""Format authors in APA style"""
if len(self.authors) == 1:
return self.authors[0]
elif len(self.authors) == 2:
return f"{self.authors[0]} & {self.authors[1]}"
else:
return f"{self.authors[0]} et al."
class LiteratureReview:
"""Manage literature review"""
def __init__(self):
self.citations: List[Citation] = []
self.themes: Dict[str, List[Citation]] = {}
def add_citation(self, citation: Citation, themes: List[str]):
"""Add citation and categorize by themes"""
self.citations.append(citation)
for theme in themes:
if theme not in self.themes:
self.themes[theme] = []
self.themes[theme].append(citation)
def get_bibliography(self, style: str = 'apa') -> List[str]:
"""Generate bibliography"""
if style == 'apa':
return [c.format_apa() for c in sorted(
self.citations,
key=lambda x: (x.authors[0], x.year)
)]
def get_summary_by_theme(self, theme: str) -> List[Citation]:
"""Get citations for specific theme"""
return self.themes.get(theme, [])
```
## Best Practices
### Research Design
- Pre-register studies when possible
- Calculate adequate sample sizes
- Use appropriate controls
- Randomize when applicable
- Blind assessors to reduce bias
- Consider confounding variables
- Document protocol deviations
### Data Analysis
- Pre-specify analysis plan
- Check statistical assumptions
- Report effect sizes, not just p-values
- Apply multiple testing corrections
- Use appropriate statistical tests
- Report confidence intervals
- Make data and code available
### Academic Writing
- Follow journal guidelines
- Use clear, precise language
- Report methodology in detail
- Discuss limitations openly
- Acknowledge conflicts of interest
- Properly cite all sources
- Use reference management software
## Anti-Patterns
❌ P-hacking and data dredging
❌ HARKing (Hypothesizing After Results are Known)
❌ Cherry-picking results
❌ Inadequate sample sizes
❌ Ignoring failed experiments
❌ No pre-registration
❌ Selective reporting of outcomes
## Resources
- ClinicalTrials.gov: https://clinicaltrials.gov/
- CONSORT Statement: http://www.consort-statement.org/
- Cochrane Handbook: https://training.cochrane.org/handbook
- APA Style: https://apastyle.apa.org/
- StatsModels: https://www.statsmodels.org/
© personamanagmentlayer · Apache-2.0 · personamanagmentlayer/pcl