Overview
Two different questions sit behind this service. First, is the analysis correct: do merges keep the right rows, are variables coded as intended, do the standard errors match the design? Second, is it reproducible: can someone else, on another computer, run your files and get the same numbers? A project can fail either test while looking fine to its author.
Our code review reads your scripts the way a careful coauthor or replicator would, runs them in a clean environment and compares the output with the numbers in your manuscript. We report problems by severity, from errors that change results to style issues that only affect readability, and suggest fixes.
For replication packages we follow widely used guidance, particularly the AEA Data Editor's recommendations and template README used across economics, and adapt it to your field and journal. The result is a package with a clear structure, documented data sources and a master script that runs everything without manual steps.
Who it’s for and the problems it solves
This is for you if you are…
- Economists and social scientists submitting to journals with a data editor or replication policy
- Researchers whose funder or institution requires code and data deposit
- Doctoral researchers who want their thesis analyses checked before submission or defense
- Research groups inheriting code from a departed student or postdoc
- Authors responding to a request from a journal's data editor
Common problems we help with
- The numbers in your paper no longer match what your code produces
- Your scripts depend on absolute file paths, manual steps or files that are not in the folder
- You are unsure which package versions you used, and results changed after an update
- A data editor asked for a README, data citations and computational requirements you have not documented
- Some data are confidential or licensed and cannot be shared, and you do not know how to handle this
- Random results (bootstraps, simulations, machine learning splits) differ each time you run the code
What’s included — and what isn’t
Included
- Code review of R, Stata, Python, SPSS syntax, SAS or MATLAB scripts, with a written report ranked by severity
- Clean-environment rerun and comparison of every reported table and figure against the manuscript
- Checks on data handling: merges, filters, recodes, missing-value treatment and sample construction
- Checks on analysis code: model specification against the paper, standard errors, weights and random seeds
- Project restructuring into data, code and output folders with a master script (for example main.do, run_all.R or main.py)
- Environment capture: renv.lock, requirements or lockfiles, Stata version statements and package lists, software and hardware requirements
- README preparation following a recognized template: data availability statements, data citations, computational requirements, run instructions, and a table mapping outputs to programs
- Guidance on confidential or restricted data: access instructions, synthetic data or simulated examples, and separate deposits
- Preparation for deposit in repositories such as openICPSR, Zenodo, OSF or Dataverse
Not included
- Changing analyses to produce different results without your agreement and documentation
- Certifying reproducibility on behalf of a journal — only the journal's data editor does that
- Sharing data you are not licensed to redistribute
- Writing the paper or thesis text
What you receive
- Code review report
- Findings ranked as critical (changes results), important (fragile or unclear) and minor (style), each with location, explanation and suggested fix.
- Reproduction check
- A table comparing each value in your manuscript tables and figures with the rerun output, with discrepancies explained.
- Restructured project
- A clean folder layout with a single master script, relative paths and outputs written by code.
- Environment files
- Pinned package versions and a list of software, versions and approximate runtime and hardware.
- README and data statements
- A README following a recognized template, with data availability and provenance, citations and instructions for replicators.
How it works
Receive the project
You share the code, data (or access instructions), manuscript and any journal or data editor requirements.
Clean rerun
We run the code in a fresh environment and record every failure, warning and difference from the manuscript.
Line-by-line review
We read the code for logic errors, undocumented choices and fragile patterns, and draft the review report.
Discuss and fix
We go through findings with you. You decide which changes to make; we can implement agreed fixes.
Package and final run
We restructure, write the README and environment files, and run the complete package once more from scratch.
Review and packaging practices
- Clean-environment testing
- Running from a fresh R library, Python virtual environment or Stata installation with only the declared packages, to catch hidden dependencies.
- Environment pinning
- renv for R, requirements files, conda environments or uv lockfiles for Python, and version statements plus ado-file bundling for Stata.
- Randomness control
- Explicit seeds for every stochastic step, and noting where parallel computation needs additional seed handling.
- Project structure
- Separate data/raw, data/derived, code and output folders, numbered scripts, and a master script as the only entry point.
- Documentation standards
- The AEA Data Editor guidance and Social Science Data Editors' template README, adapted for other fields and journal requirements.
- Version control
- Git history, tagged releases for submitted versions, and archiving to a repository that issues a DOI.
What a code review actually looks for
Code review is not about style preferences. We look first for errors that change results: merges that duplicate or drop observations, filters applied in the wrong order, variables recoded in one script and used raw in another, standard errors that ignore clustering, or a sample in the code that differs from the sample described in the paper. Each is checked against your manuscript's description.
Next we look for fragility: hard-coded paths, copy-pasted blocks that have drifted apart, results typed into tables by hand, and code that depends on objects created interactively. These may not be wrong today but will cause errors after the next revision.
- Critical: changes a reported number or conclusion
- Important: likely to break or to be misunderstood by a replicator
- Minor: readability, naming and comments
Anatomy of a replication package
A replication package should let someone reproduce every table and figure by running code, with no manual intervention beyond setting a root directory. The AEA Data Editor's guidance, widely used beyond economics, recommends keeping data and code in separate folders so that code can be downloaded without very large data, citing every dataset not created by the authors, and stating software versions, required packages and expected runtimes.
The README is the heart of the package. It explains where each dataset comes from and whether and how it can be obtained, lists the computational requirements, gives step-by-step run instructions and maps each table and figure to the program that produces it. We prepare this with you, because only you know the full provenance of the data.
Seeds, versions and other small things that matter
Bootstrapped confidence intervals, multiple imputation, cross-validation and simulation all use random numbers. Without a fixed seed, results change slightly every run, and replicators cannot tell a small random difference from an error. We set seeds once at the top of each relevant script and note any procedures where parallel processing requires extra care.
Software versions matter as much. Package updates can change defaults, and sometimes results. Recording versions with renv, a lockfile or a Stata version statement, and stating the operating system and runtime in the README, lets a replicator reconstruct your setup rather than guess at it.
What the work can look like
Illustrative example — fictional data
Sample review excerpt: reproduction check
An economics author prepared a package for a journal requiring replication materials, with 6 tables and 4 figures from Stata and R code. The findings are invented to show the report format.
Rerun summary
Clean run in Stata 19/SE and R 4.6 completed in about 2 hours 10 minutes after two fixes. 9 of 10 exhibits matched the manuscript exactly; Table 4 differed in the third decimal place.
Critical finding
Table 4 used bootstrapped standard errors without a seed. Adding set seed 20260927 in 04_robustness.do made results stable; the manuscript values fell within the range of 50 reruns, so conclusions were unaffected. The manuscript table was updated to the seeded values.
Important findings
Two scripts used absolute paths to the author's laptop, and the R code relied on a package loaded interactively but not listed. Both were fixed, and the README's computational requirements now list all Stata and R packages with versions.
Illustrative example with invented findings. Real reports depend on your code, data and the journal's requirements.
What you’ll need to provide
- All code files and the data, or instructions for obtaining restricted data
- The manuscript or thesis chapter with the tables and figures to reproduce
- Journal replication policy or the data editor's request, if any
- Information on data licenses and any confidentiality constraints
- The software versions you used, if known
You don’t need everything ready to ask for a quote — tell us what you have and we’ll say what’s missing.
What affects price and turnaround
Price depends on
- Size of the codebase and number of scripts and languages
- Number of tables and figures to verify
- Run time of the full analysis
- Complexity of data provenance and any restricted-data arrangements
- Whether you want a review report only, or review plus restructuring and packaging
Turnaround depends on
- Completeness of the files you send and access to restricted data
- Computation time for a full clean run
- Time needed on your side to decide on and approve fixes
- Deadlines set by the journal's data editor
Every project is quoted individually. How we price our work.
Questions people ask before starting
Which languages can you review?
R, Stata, Python, SPSS syntax, SAS and MATLAB, and projects that mix several of them. Tell us what is in the project and we will confirm we can run it.
Can you review code if I cannot share the data?
Yes. We can review code without data, which catches many logic and structure issues, and test it on a synthetic dataset with the same structure. You then run the final version on the real data and share the log files.
Does your review mean the journal will accept my package?
No. Only the journal's data editor decides. We prepare the package according to published guidance and the journal's stated policy, which reduces the chance of revision requests.
What happens if you find an error that changes my results?
We tell you promptly, explain it and show the corrected result. The decision on how to proceed is yours. For published work, we can help you understand options such as contacting the journal.
Can you review a thesis before submission?
Yes. A pre-submission review of analysis code is a good way to find errors before your examiners do, and it helps you explain your analysis confidently at the defense.
Do you keep my code and data?
Only for the duration of the project unless you ask us to keep them for later revisions. Please tell us about any data-use agreements that restrict who may access the data.