LLM-based AI assistants are becoming increasingly capable, but they are always at risk of hallucination, sycophancy, over-confidence, and laziness. So can these flawed and non-deterministic tools ever be useful for conducting rigorous data analysis?
Yes -- but only with the right guidance, right guardrails, and in expert hands to direct all core decisions and verify all key outputs.
Enter DAAF, the Data Analyst Augmentation Framework. DAAF is a free and open-source instructions framework for Claude Code that helps skilled researchers deepen and extend their expertise across any domain of data analysis with AI assistance -- while enhancing the transparency, rigor, and reproducibility that good science demands. DAAF sits between you and Claude Code to automatically and consistently help Claude think more like a responsible and rigorous researcher by:
- Enforcing strict auditability and reproducibility standards for all work, thus allowing you to verify everything Claude does on your behalf
- Preventing potentially dangerous unintended file access and editing, by sandboxing Claude with strict protections and logging traces
- Setting high standards of care, rigor, and thoroughness in all data analysis, by forcing Claude to comment, verify, and review all analytic code before you ever see it
- Embedding best practices for a wide variety of research methodologies like causal inference and geospatial analysis, by providing rich Skills that extend Claude's base capabilities with real research and resources
- Collaborating with you, the human expert, directly on all key decisions, thus keeping you firmly in the driver's seat
Think of it as a force-multiplying exoskeleton for human researchers -- a tool explicitly designed to augment your hard-earned expertise, not replace it. The goal is to make it easy for researchers to use Claude Code effectively and responsibly. Importantly, DAAF is not and will never be perfect -- but it is already immensely useful, and this is the worst a tool like DAAF will ever be from now on with the help and support of the broader research community.
Install and begin using it in as little as 10 minutes from a fresh install with an Anthropic account, an OpenRouter API key, or an OpenAI account.
New to DAAF? Start with the Getting Started video below -- a full tutorial that walks you through the entire installation and gets you oriented to the whole environment, from the Docker setup and Claude Code to DAAF itself. Or read on for more information!
Project Homepage | Getting Started video (30 min) | Installation Guide | User Documentation Reference | DAAF Field Guide Substack | AI for Responsible and Rigorous Research Discord | Contributing to DAAF
If you're already comfortable with the Terminal and Claude Code, you can get started almost immediately using the Quick Start instructions below. Otherwise, I recommend starting with the full Installation Guide for beginner-friendly details, prerequisites, and troubleshooting.
Requirements: Docker Desktop (running) and an account with one of the supported AI providers:
- Anthropic subscription (Max recommended, $100-200/mo) — flat-rate, best value for heavy use.
- Anthropic API key — pay-per-use; no subscription, but a full analysis can run $50+.
- OpenRouter — pay-per-token, no subscription; provides access to Anthropic models plus high-performing open-weight alternatives like GLM 5.2.
- OpenAI API key or ChatGPT subscription — run DAAF on GPT models via DAAF's automatic compatibility layer; a supported route that will benefit from wider community testing (see the Installation Guide's Option F).
Open a terminal in your desired installation directory.
macOS / Linux (Terminal):
# Install DAAF (downloads Docker build files, builds image, clones repo into container)
curl -fsSL https://raw.githubusercontent.com/DAAF-Contribution-Community/daaf/main/scripts/host/install.sh | bash
# Enter the installation folder and open the DAAF Control Panel
cd daaf-docker
bash daaf.shWindows (PowerShell):
# Install DAAF (downloads Docker build files, builds image, clones repo into container)
irm https://raw.githubusercontent.com/DAAF-Contribution-Community/daaf/main/scripts/host/install.ps1 | iex
# Enter the installation folder and open the DAAF Control Panel
cd daaf-docker
.\daaf.ps1On first launch, Claude Code will prompt you to authenticate. DAAF defaults to Opus 4.8 with 1 million token context. Anthropic's lower-cost Sonnet tier is also an excellent choice that matches the Opus line on DAAF's orchestration benchmarks at a fraction of the cost; if you'd like to use it, type /model to switch. You're ready to go; see Understanding DAAF for some suggestions on how to get started with progressively more complex tasks with DAAF!
DAAF explicitly embraces the fact that LLM research assistants will never be perfect and can never be trusted as a matter of course. But with the right guardrails, they can still be immensely valuable for critically-minded researchers. Every design decision serves five core requirements:
- Transparent. Because LLMs will always be susceptible to lying, hallucinating, and cutting corners, DAAF forces Claude Code to operate using file-first principles: all data operations are drafted and run as actual Python or R files, all reasoning is stored as verbose comments, plan documents, and structured code output that you can review and intervene on at any time.
- Scalable. Because most LLMs are trained as generalists susceptible to sycophancy and overconfidence, DAAF provides a comprehensive and extensible set of explicit instructions and standards enforcing highly opinionated best practices (via agent and skill documents), injecting the right information at the right time for any specific task -- so you don't have to hold its hand every time to get good output.
- Rigorous. Because LLMs can perform extensive computation on your behalf, DAAF's workflows force Claude to be meticulous, cautious, self-checking, and extremely thorough. Code is broken into hyper-atomic steps and adversarially reviewed. Plans and reports are informed by deep-dives into actual data documentation and actual exploratory analyses, then also reviewed by equally informed counterparts.
- Reproducible. Because good science needs to be reproducible, every single data file, script, and output is automatically stored throughout the entire process. You do not have to just trust DAAF or Claude Code -- you can and should verify everything yourself.
- Responsible. Because AI-assisted research demands accountability, DAAF ensures that data sources are properly cited, AI assistance is transparently disclosed via the GUIDE-LLM reporting standard, data usage terms are respected, limitations are honestly acknowledged, and the human researcher's judgment remains the final authority on all analytical decisions.
When you open DAAF, just begin by asking it any question or for support with any type of task. DAAF intelligently responds to your needs by automatically selecting and walking you through one of nine possible research workflow modes (and you can feel free to redirect it if it gets it wrong!) while providing easy opportunities to transition across supported workflows as needed:
Data Onboarding: Make Claude an expert in your data
- What you do: Point DAAF to your data (local file, web download, or API) and any associated documentation
- What DAAF does: Runs a multi-stage data profiling process to learn all the ins and outs, with fully reproducible code
- What you get: An in-depth data documentation Skill that DAAF references for all future work with your data -- fully portable, share with colleagues
- Sensitive data? If your data can't leave your environment, DAAF routes it through a privacy-preserving synthetic-data path -- you profile it locally and only a summary crosses the boundary
- Example: I've got a new BLS employment dataset I want to explore and understand a bit more. I've got this link to the dataset and a technical paper from them: can you start profiling it?
Data Lookup: Your personal data documentation oracle
- What you do: Ask DAAF a specific question about any dataset it has access to
- What DAAF does: Loads the data documentation Skill and synthesizes all relevant reference information into a precise, grounded answer in seconds
- What you get: A precise, documentation-informed answer with opportunities to dig deeper
- Example: Can you give me a sense of what the year variables actually indicate in the various IPEDS datasets?
Data Discovery: Connect the dots across data sources and topics
- What you do: Ask DAAF a broad data or research scoping question
- What DAAF does: Launches explorations across all available data documentation relevant to your question
- What you get: An in-depth summary of relevant opportunities, insights, clarifications, and caveats to consider
- Example: What are all the socioeconomic status related variables we have access to across the Urban Institute Education Portal datasets?
Ad Hoc Collaboration: A smarter, more grounded research partner
- What you do: Ask DAAF to help you riff on anything research-related -- code review, debugging, brainstorming, writing scripts
- What DAAF does: Engages as a collaborator with embedded domain and methodological expertise guiding the way
- What you get: A much more knowledgeable and careful Claude assistant for flexible, multi-turn working sessions
- Example: How would I implement a diff-in-diff design in Python? I know how in R but not the Python equivalents. Or: I usually work in Python -- can you help me set up a fixest regression in R?
Full Pipeline: From research question to results, with your guidance every step of the way
- What you do: Ask DAAF for support answering any arbitrarily complex research question with your data
- What DAAF does: Data scoping, analytic planning, data acquisition and cleaning, in-depth code review, analysis, visualization, and report writing -- the works
- What you get: A pre-analysis plan, a fully reproducible end-to-end analysis for close review, and a summary report with key findings, data visualizations, limitations, and citations
- Example: I want to analyze how graduation rates relate to admissions selectivity, while better accounting for factors like Pell share, student demographics, and other related factors
Revision and Extension: Make the first draft better and build beyond
- What you do: Ask for revisions to or new deliverables from any prior analysis
- What DAAF does: Reviews the prior analysis, launches targeted revisions, reruns analyses as needed, updates all downstream work
- What you get: Refined analyses, new dashboards, additional visualizations, stakeholder reports -- whatever you need
- Example: The scatter plots from yesterday look scrunched -- fix the sizing and propagate the changes downstream
Reproducibility Verification: Verify, don't trust. Ensure prior work is fully reproducible.
- What you do: Point DAAF to a completed Full Pipeline analysis (yours or someone else's)
- What DAAF does: Reruns and re-verifies every script against the final report, critiquing and exploring along the way -- a "reproduced" verdict means the results matched within reasonable tolerances when re-run
- What you get: An in-depth reproducibility report with issues, concerns, and summary takeaways
- Example: I want to verify that the graduation rate analysis reproduces correctly from its replication notebook before we share it with our collaborators
Framework Development: Make DAAF work for you
- What you do: Ask DAAF to improve its own functionality: new methodologies, new Python or R libraries, new domain expertise, or new modes entirely
- What DAAF does: Reviews its own architecture, conducts in-depth research, and meticulously updates its functionality
- What you get: A better DAAF with modular skills and agents you can share with colleagues or the community
- Example: I want to explore building in more supports for more sophisticated natural language processing techniques that allow us to classify open-response text
User Support: Get help understanding and using DAAF itself and its underlying tools (Docker, Git, Claude Code)
- What you do: Ask DAAF any question about what it is, how it works, how to troubleshoot setup or tool issues, or what to expect
- What DAAF does: Loads its own documentation and responds directly with clear, educational guidance -- can also look up official Docker, Git, and Claude Code docs online when needed
- What you get: A conversational, patient explanation of anything about DAAF or its technology stack, plus pointers to the right mode when you're ready to do something specific
- Example: I'm new here -- can you walk me through what DAAF actually does? Also, how do I give Docker more memory?
The base framework comes ready to analyze any or all of the 40+ foundational public education datasets available via the Urban Institute Education Data Portal, and is readily extensible to new data domains and methodologies. DAAF also comes out-of-the-box with a deep understanding of many of the most common social science research methods and beyond: from causal inference techniques like difference-in-differences, to geospatial analysis, to unsupervised machine learning methods. Several additional skills are included to help DAAF support broader science communication skills, as well -- embedding many best practices related to data visualization, data dashboarding, science communication, and more.
Included data sources: CCD, CRDC, EdFacts, EADA, FSA, IPEDS, MEPS, NACUBO, NCCS, NHGIS, PSEO, SAIPE, College Scorecard, Campus Safety
Methodological support: Difference-in-differences • Fixed/random effects • Mixed effects models • Instrumental variables • Regression discontinuity • Synthetic control • Event studies • Propensity score matching • Time series analysis • Complex survey analysis • Geospatial analysis & spatial statistics • Network analysis & community detection • Decomposition analysis • Quantile regression • Exploratory data analysis • DAG modeling • Predictive analytics • Cross-validation • Algorithmic fairness assessment • Cluster analysis • Wild bootstrap inference • Sensitivity analysis
Python library expertise: polars • pyfixest • linearmodels • statsmodels • scikit-learn • geopandas • igraph • plotly • plotnine • marimo • svy • fairlearn • SHAP • PySAL • LightGBM • seaborn • rdrobust • marginaleffects
R library expertise: tidyverse (data manipulation) • ggplot2 (static visualization) • fixest (high-dimensional fixed effects) • r-stats (base statistical modeling) • quarto (reproducible notebooks) • plotly-r (interactive visualization) • sf-terra (spatial analysis) • igraph-r (network analysis) • plm (panel data) • tidymodels (machine learning) • survey-r (complex surveys) • gt (table formatting)
R is a core execution lane engineered for parity with Python -- the same pipeline, the same validation, the same reproducibility standards -- with Python as the default and R a one-line preference away. A few method-level differences between the two remain and are documented honestly in the technical FAQ.
Need a Python or R package that isn't listed? You can add your own by editing the Dockerfile and rebuilding -- see Customizing Your Python and R Environment for instructions.
Additional features: Interactive dashboards (Plotly) • Reactive analytic notebooks (marimo for Python, Quarto for R) • Browser-based code editor (code-server) • R/tidyverse-Python code translation • Python-R code translation • Stata-Python code translation • Stata-R code translation • Citation propagation & verification • GUIDE-LLM AI use disclosure • Git version control • Session transcript archiving • DAAF Log Explorer • Docker-based safety sandboxing • Destructive command prevention • Secret/credential scanning • File-first execution enforcement • Science communication
Model benchmarking: DAAFBench measures how faithfully different models follow DAAF's research protocols (protocol adherence, not research quality) -- a practical guide when choosing a model or budget.
- Watch the Getting Started tutorial -- a full 30-minute walkthrough that installs DAAF from scratch and orients you to the whole environment: the Docker setup, Claude Code, DAAF itself, and everyday essentials like the browser file editor, the session log viewer, and keeping your installation up to date
- Watch the v2.0.0 Showcase highlighting all the current functionalities of DAAF
- Explore a sample Full Pipeline project on our interactive online explainer, or browse the actual repo files to see what kinds of reports, visualizations, reproducible scripts, and other artifacts DAAF can produce.
- Explore a sample Reproducibility Verification project to explore the outputs of a Reproducibility Verification process (using the same Full Pipeline project above) -- see the project README for a guided walkthrough.
- Watch the data onboarding demo explaining how the data onboarding process works and talking through a use-case where we replicate the NYTimes' "Red Shift" interactive data visualization
- Watch the v1.0.0 10-minute demo talking through the original modes, philosophy, and intentions behind DAAF, while showing the actual interactions with DAAF to produce a Full Pipeline analysis
DAAF is designed to be fully domain-extensible -- you can readily bring your own data sources into the ecosystem by engaging with the Data Onboarding mode (see this 10-minute tutorial for a demonstration).
Note: If you plan to use DAAF with private, proprietary, or regulated data (FERPA, HIPAA, etc.), the implications depend entirely on your specific Anthropic license and access method. Enterprise agreements, AWS Bedrock, and Google Vertex AI each offer different data governance guarantees. DAAF ships configuration templates for the Bedrock and Vertex routes, though these routes aren't maintainer-validated end-to-end -- treat them as a starting point you'll need to stand up and test in your own environment (see the technical FAQ). It is your responsibility to understand and evaluate these nuances for your use case before using DAAF with any non-public data. Consult your IT team and legal counsel, and review Anthropic's current data policies for your specific agreement type. For more detail, see the Data Privacy FAQ. And if your data genuinely can't leave your environment, DAAF includes a built-in synthetic-data protocol for exactly this situation -- you profile the data locally and DAAF works from a disclosure-controlled summary alone, so the real data never enters the container. Its disclosure controls minimize what leaves your machine but are not a formal privacy guarantee -- you review the profile summary yourself before it ever crosses the boundary. See Can I use DAAF with data that can't leave my secure environment?.
All that being said, the Urban Institute Education Data Portal serves as an excellent out-of-the-box demonstration domain because it offers:
- High-quality, well-documented public data
- Real, immediate policy relevance (K-12 schools, districts, colleges, outcomes)
- Sufficient complexity to stress-test the system (multiple sources, coded values, suppression rules, cross-state comparability issues)
These datasets allow new users to quickly and easily experiment with DAAF using genuine research questions, nuanced datasets, and complex analytic plans. The architecture, agents, methodological skills, validation protocols, engagement modes, and workflow stages are all domain-agnostic.
DAAF is in constant development as AI advances continue, and as more and more users find value in using DAAF for their own research. DAAF needs the support of the research community to grow into a reliable, scalable tool, so contributions of all kinds are welcome!
- Bug reports and session learnings -- even a quick issue with context is extremely valuable. Every completed Full Pipeline project produces a LEARNINGS.md file with actionable improvements that can be fed back into the framework for improvements
- New data sources and methodological tools -- use Data Onboarding mode to profile new datasets, or use the Framework Development mode to develop new statistical methods and domain expertise Skills to share back with the community.
- Workflow improvements and documentation -- suggestions for improving quality, reducing friction, clearer onboarding, and better documentation are all welcome.
- Platform ports -- the vast majority of DAAF's tooling can be ported to other agentic coding harnesses (Gemini CLI, Codex, OpenCode, etc.) with a good bit of elbow-grease, but it requires people who know the real ins-and-outs of these various harnesses' idiosyncrasies.
See Contributing to DAAF for the full contribution guide and Extending DAAF for adding new capabilities for your own use.
- 00. README — [This document] Project overview, quick start, design philosophy, capabilities, and acknowledgments
- 01. Installation & Quick Start — (Recommended Next Step) Get started! Installation prerequisites, step-by-step setup, day-to-day usage, and troubleshooting
- 02. Understanding and Working with DAAF — Learn to work with DAAF for the first time: what to expect, how to use it, and how to test its strengths and limitations
- 03. Best Practices — Tips for working with Claude Code, writing effective prompts, ensuring quality and rigor with DAAF, reviewing outputs, and managing context
- 04. Extending DAAF — How to add new data source skills, analytical tools and methodologies, creating your own additional specialized agents, and customizing your Python and R environment
- 05. Contributing to DAAF — Get involved in developing DAAF! How to file issues, contribute new skills and data sources, improve documentation and protocols, test your changes, and more! (This one lives at the repository root as
CONTRIBUTING.md, not in theuser_reference/folder — which is why the folder's numbering skips from 04 to 06.) - 06. FAQ: Philosophy — (Recommended Next Step) Grapples with the broader implications of this work, AI automation in general, model advancement pace, approaching the "exponential", environmental ethics, what this means for the next generation of researchers, and more
- 07. FAQ: Technical Support — Covers frequently asked questions about Docker, issues with Claude Code, usage limits, authentication errors, and other common errors
If you use DAAF in your research, please cite it and all underlying data sources, methodological guidance, and software tooling (more on that below). Software citation ensures credit for open-source tools and supports reproducibility by recording the exact version used.
Plain text (APA):
Kim, B. H. (2026). DAAF: Data Analyst Augmentation Framework (Version 3.0.0) [Computer software]. https://doi.org/10.5281/zenodo.19343886
BibTeX:
@software{kim2026daaf,
author = {Kim, Brian Heseung},
title = {{DAAF}: Data Analyst Augmentation Framework},
year = {2026},
url = {https://github.com/DAAF-Contribution-Community/daaf},
doi = {10.5281/zenodo.19343886},
version = {3.0.0},
license = {LGPL-3.0-or-later}
}GitHub also provides a "Cite this repository" button (powered by the CITATION.cff file) that generates APA and BibTeX citations automatically. Following FORCE11 Principle 6 (Specificity), please cite the exact version of DAAF you used -- every DAAF report automatically records the git commit hash and version in its AI Use Disclosure section.
Knowing the importance of citing who we build upon, DAAF includes a built-in citation propagation system that tracks data, methodological, and software attribution throughout the analysis pipeline. As DAAF executes your analysis, it accumulates citations for every data source accessed, statistical method applied, and software library used for estimation -- guided by a parsimony principle (cite what directly produced a result, not every library touched along the way). These are verified at the end of the pipeline and rendered into a structured References section in your final report, organized by data sources, methodological references, software and tools, and reporting standards.
That being said, the citations generated are best-effort, not guaranteed -- always review the References section of your report and add or adjust as needed for your publication context. See the Citation Reference for more information and examples for how the system thinks about this.
This project is licensed under the GNU Lesser General Public License v3.0 (LGPL-3.0-or-later). Anyone can use DAAF for any reason, for free, forever -- this work is too important and high-stakes to treat as anything but a shared effort we can all benefit from and contribute to.
Internal use -- personally or within your organization, no matter how extensively you modify the framework -- is completely unrestricted. More restrictions apply only if you distribute a modified version: core framework improvements must also be licensed open-source, but extensions built on top (skills for proprietary datasets, bespoke agents, etc.) can remain private under any license. This ensures DAAF stays open and community-driven while allowing proprietary extensions in any context, including institutional or enterprise environments.
For the full philosophy behind this decision, see FAQ: Philosophy. See LICENSE and COPYING.LESSER for the full license text.
Hello! My name is Brian Heseung Kim (@brhkim). I have been at the frontier of finding rigorous, careful, and auditable ways of using LLMs and their predecessors in social science research since roughly 2018. I focused my entire Ph.D. dissertation on teaching others how to use these tools responsibly (finished in mid-2022, months before ChatGPT was released), and I've continued to work on that frontier through to today. As a former public high school English teacher, much of why DAAF is packaged as an educational endeavor comes from my belief that helping peers and colleagues rapidly develop deep fluency on this frontier is one of the most important things I can do. I now work full-time developing DAAF and other AI frameworks to support the work of public-interest and research organizations as Founder and Chief Data Scientist at Open Augments.
- Urban Institute Education Data Portal -- The proof-of-concept iteration of this project would not be possible without this remarkable public resource that harmonizes data from over a dozen federal education data sources into a single, well-documented API. We are deeply grateful to the Urban Institute for making high-quality education data freely accessible. If you use DAAF or the Education Data Portal in your work, please cite the Urban Institute appropriately -- see the Education Data Portal documentation for citation guidelines.
- GUIDE-LLM -- DAAF integrates this consensus-based reporting checklist (developed by Feuerriegel, Barrie, Crockett, Globig, McLoughlin, Mirea, Spirling, Yang, and over 80 additional experts) to help researchers transparently disclose how AI was used in their work.
- GSD Core (Open GSD Community) -- Several core workflow patterns in DAAF, particularly around agent specialization, shared working memory, and task decomposition, were improved thanks to excellent practices in this community-led project.
- Docker -- Containerization platform providing DAAF's sandboxed execution environment
- code-server (Coder) -- Browser-based VS Code editor, itself built on Microsoft's VS Code and the Open VSX extension registry
- marimo -- Reactive Python notebooks used for DAAF's Python reproducible research artifacts
- Quarto -- Open-source scientific publishing system used for DAAF's R reproducible research notebooks
- Polars -- High-performance DataFrame library and DAAF's default data engine
- uv (Astral) -- Fast Python package manager powering DAAF's build
- Git and pre-commit -- Version control and commit-time safety checks
- DAAF also relies on a broad ecosystem of specific Python and R packages for statistical computing, visualization, and geospatial analysis -- see the Dockerfile for the complete list with pinned versions.
DAAF's Skills encode curated methodological guidance drawn from the work of many researchers. The exact references are embedded in the Skill files themselves (see .claude/skills/), but we gratefully acknowledge the scholars whose textbooks, papers, and open educational resources most directly shaped the framework's embedded expertise:
Causal inference and econometrics: Joshua Angrist & Jorn-Steffen Pischke, Scott Cunningham, Nick Huntington-Klein, Jeffrey Wooldridge, Guido Imbens, Judea Pearl, Paul Rosenbaum & Donald Rubin, Alberto Abadie, Matias Cattaneo, Edward Leamer, Charles Manski, Anton Korinek (causal inference, statistical modeling) • Modern difference-in-differences: Brantly Callaway & Pedro Sant'Anna, Andrew Goodman-Bacon, Liyang Sun & Sarah Abraham, Clement de Chaisemartin & Xavier D'Haultfoeuille, Jonathan Roth, John Gardner, Kirill Borusyak, Ariel Dube (causal inference, pyfixest) • Statistical inference: A. Colin Cameron & Douglas Miller, James MacKinnon, Morten Nielsen & Matthew Webb, Yosef Benjamini & Yoav Hochberg, Joseph Romano & Michael Wolf (statistical modeling, pyfixest, linearmodels) • Sensitivity and robustness: Emily Oster, Carlos Cinelli & Chad Hazlett, Joseph Altonji (causal inference, statistical modeling) • Statistical learning and machine learning: Trevor Hastie, Robert Tibshirani & Jerome Friedman, Gareth James & Daniela Witten, Leo Breiman, Susan Athey & Stefan Wager, Sendhil Mullainathan, Victor Chernozhukov, Cynthia Rudin, Christoph Molnar, Scott Lundberg, Galit Shmueli (supervised ML, exploratory/unsupervised) • Fairness: Jon Kleinberg, Alexandra Chouldechova, Ziad Obermeyer (supervised ML) • Clustering and unsupervised methods: Leonard Kaufman & Peter Rousseeuw, Christian Hennig, Brian Everitt, Chris Fraley & Adrian Raftery, Ian Jolliffe, Laurens van der Maaten, Leland McInnes (exploratory/unsupervised) • Decomposition methods: Ronald Oaxaca & Alan Blinder, Jonah Gelbach, Nicole Fortin, Thomas Lemieux & Sergio Firpo, Frank Cowell (descriptive analysis) • Survey methodology: Thomas Lumley, Steven Heeringa, Brady West & Patricia Berglund, Sharon Lohr, Leslie Kish, Kirk Wolter (survey analysis, svy) • Geospatial analysis: Sergio Rey, Dani Arribas-Bel & Levi John Wolf, Luc Anselin, Waldo Tobler, Timothy Conley, A. Stewart Fotheringham (geospatial analysis, geopandas) • Network analysis: Vincent Traag, Ludo Waltman & Nees Jan van Eck (community detection, igraph) • Panel data and IV: Badi Baltagi, William Greene, Kevin Sheppard, Douglas Staiger & James Stock (linearmodels, pyfixest) • Time series: James Hamilton, Rob Hyndman, Helmut Lutkepohl (statsmodels) • Visualization and science communication: Edward Tufte, Cole Nussbaumer Knaflic, Jonathan Schwabish, Claus Wilke, Alberto Cairo, Barbara Minto, Brent Dykes, Catherine D'Ignazio & Lauren F. Klein (visualization design, science communication) • Software: Alexander Fischer & S. Schar (pyfixest), Skipper Seabold & Josef Perktold (statsmodels), Mamadou S. Diallo (svy), Fabian Pedregosa et al. (scikit-learn), Sergio Rey et al. (PySAL), Laurent Berge, Kyle Butts & Grant McDermott (fixest), Kelsey Jordahl et al. (geopandas), Geoff Boeing (OSMnx), Guolin Ke et al. (LightGBM), Hadley Wickham et al. (tidyverse, ggplot2), Thomas Lumley (survey for R), Max Kuhn & Julia Silge (tidymodels), Edzer Pebesma (sf), Robert Hijmans (terra), Gábor Csárdi & Tamás Nepusz et al. (igraph), Thomas Lin Pedersen (tidygraph, ggraph)
These researchers' contributions -- many freely available as open-access resources -- represent decades of accumulated methodological wisdom that DAAF aims to make more accessible to applied researchers.
DAAF is free and always will be, as the flagship project of Open Augments.