Pith. sign in

REVIEW 1 major objections 4 minor 70 references

Flowco: Rethinking Data Analysis in the Age of LLMs

T0 review · 1 major / 4 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Flowco claims that a visual dataflow graph, with LLM help at every stage, lets people with little programming experience author, debug, and refine data analyses.

desk verdict A well-built LLM-plus-dataflow system whose main soft spot is Section 8: it checks executability, not statistical validity, so the user study supports fluent authoring but not yet valid analysis. read the letter →

arxiv 2504.14038 v1 pith:LWOV7IBT submitted 2025-04-18 cs.HC cs.AIcs.PLstat.CO

Stephen N. Freund , Brooke Simon , Emery D. Berger , Eunice Jun This is my paper · ORCID
classification cs.HCcs.AIcs.PLstat.CO
keywords FlowcodataflowprogrammingLLM-basedcodegenerationmixed-initiativesystemsdataanalysisauthoringcomputationalnotebooksvisualuserstudy
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper introduces Flowco, a mixed-initiative system that replaces the free-form chat-and-notebook style of LLM-assisted analysis with a visual dataflow graph. Users draw nodes for each analysis step and edges for data flow, and an LLM synthesizes requirements, code, and validation checks for each node. The paper argues that this structure gives analysts fine-grained control and explicit dependencies that notebooks lack, while constraining the LLM to small, checkable subtasks. A user study with twelve data-science students suggests that, especially for those with little programming experience, this approach supports quickly authoring, debugging, and refining analyses. The point is that the right programming model, not just better prompts, is what makes LLM-generated analysis code usable.

What carries the argument

The key mechanism is the dataflow graph as an organizing and guardrailing structure. Each node is a stateless analysis step with a summary label, a prose requirements list, and generated Python code, while edges make all dependencies explicit. Because the LLM is asked to synthesize one node at a time within this structure, its output is scoped, and because every node's output can be checked against an extended type plus user- or LLM-suggested assertions and unit tests, errors are caught where they occur rather than buried in a notebook's execution order.

What would settle it

Run the airline-safety task from the user study with hidden ground-truth answers and see whether participants using Flowco, without user-written statistical checks, produce statistically invalid regressions at rates comparable to direct LLM chat; if they do, the claimed trustworthiness benefit is not delivered.

Watch

Extended reading notes

Core claim

The central discovery is that dataflow graphs are a foundation for reliable LLM-centric programming: modularity, explicit dependencies, and multiple abstraction layers let each LLM generation step be small, observable, and individually validated. Flowco embodies this by synthesizing each node's requirements and code in topological order, checking outputs against extended types, offering assertion checks and unit tests, and propagating edits downstream. The paper reports that all twelve participants successfully produced analyses after a 12-minute tutorial, that participants found the graph model helped them organize multi-step analyses, and that most preferred Flowco to using a general LLM directly. The claim is not that Flowco makes statistics correct, but that it makes the process of building an executable, inspectable analysis dramatically more approachable.

Load-bearing premise

The whole approach presumes that generating and checking each node separately is enough to keep LLM-produced analyses correct, even though the paper acknowledges that executable code can still be statistically invalid.

Editorial extensions

If this is right

  • Analysts who cannot write Python can author multi-step analyses by drawing graphs and chatting, since code synthesis is per-node and hidden.
  • Stale-variable and hidden-state bugs characteristic of notebooks are structurally eliminated because node evaluation order follows the graph.
  • Generated analyses become inspectable and testable at each step, so users can add assertions such as 'at least 5,000 bootstrap resamples' and catch silent LLM choices.
  • Small edits propagate deterministically: changing one node's requirements invalidates only downstream nodes and resynthesizes the minimal code.
  • Workflows can be exported to notebooks, so Flowco can serve as a front end to existing notebook-based pipelines.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If this model generalizes, the same node-scoped synthesis plus validation pattern could be applied to other LLM programming domains, not just data analysis, wherever step boundaries can be drawn explicitly.
  • A testable extension would measure whether Flowco's guardrails catch statistically invalid analyses when checks are not user-authored; the paper leaves statistical correctness to future work.
  • The reported 'messy graph' concern suggests that without hierarchical subgraph support, the approach may cap out at analyses of moderate complexity.
  • A controlled head-to-head comparison with direct LLM chat on the same analysis tasks, using hidden ground-truth results, would clarify whether the reported novice benefit comes from the dataflow structure or from the integrated LLM itself.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

1 major / 4 minor

Summary. Flowco is a mixed-initiative system that combines a visual dataflow programming model with LLM-based assistance for authoring data analyses. Users construct graphs whose nodes represent analysis steps; an LLM synthesizes requirements, Python code, assertion checks, and unit tests, while the system provides error detection and repair, change propagation, and an AMA chat agent. The paper demonstrates Flowco on several example analyses (including a multiverse analysis and a logistic regression with cross-validation) and reports a first-use study with twelve data science students. The central claim, as stated in the abstract, is that Flowco supports analysts—particularly those with less programming experience—in quickly authoring, debugging, and refining data analyses.

Significance. If the central claim holds, Flowco makes a useful contribution to the growing body of work integrating LLMs into data science practice. The dataflow-graph programming model is a well-motivated design choice for modular, observable, and testable LLM-assisted analysis, and the implemented system is open-sourced. The paper is honest about its limitations, explicitly acknowledging in Section 8 that statistical correctness is not yet guarded. The example analyses show that the system can express non-trivial workflows, and the user study, though small, provides qualitative evidence of usability and perceived benefits. However, the evidence is preliminary: the study is a first-use, uncontrolled evaluation with researcher assistance, and it does not assess the statistical validity of the analyses participants produced. The contribution is therefore best viewed as a promising system design with provisional empirical support, rather than a fully validated solution to trustworthy LLM-assisted data analysis.

major comments (1)
  1. [Section 7 (Table 1) and Section 8 (RQ1)] The study's sample is twelve self-selected students, eleven of whom are in a Data Science or Statistics field, and the claim that Flowco is "particularly" beneficial for those with less programming experience rests on very few participants (e.g., P6, P12). The paper does not report per-participant task success or breakdown of outcomes by programming experience level, so the reader cannot assess how much of the positive result is driven by the more experienced participants. I recommend either providing a per-participant analysis of task completion and difficulties by experience level, or softening the claim to state that the study suggests potential benefits for novices rather than establishing them.
minor comments (4)
  1. [Section 3, first paragraph] There is a typo: "The Flowco user interface... is is divided into three panels" should read "is divided into three panels."
  2. [Figure 6] The generated docstring in Figure 6 contains duplicated words: "The the result output" and "The the result DataFrame" should each have one "The."
  3. [Section 7.2.5] The participant list in the sentence "Five described a desire to use Flowco over their current tools... (P2, P5, P3, P8, P12)" is given in an inconsistent order; listing participants numerically (P2, P3, P5, P8, P12) would be clearer.
  4. [Section 2.2] The phrase "Zamfirescu-Pereira et al. 's PAIL IDE" has an awkward apostrophe placement; consider "the PAIL IDE of Zamfirescu-Pereira et al."

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: Flowco's claims are empirical and self-contained; the Section 8 statistical-validity gap is a limitation, not a circular step.

full rationale

Flowco is a systems paper, not a formal derivation. Its central claim—that the dataflow-plus-LLM model helps analysts author, debug, and refine analyses—is supported by a user study and worked examples; none of these is derived from a fitted parameter, an equation, or a self-citation chain. The related-work citations to the authors' own Tea, Tisane, and PAIL systems are background or motivation (Sections 2.2 and 8), and the Tea result about expert tutorials selecting inapplicable statistical tests is an externally falsifiable empirical finding that does not carry the weight of Flowco's effectiveness claim. The validation architecture in Sections 5.2–5.5 checks executability, type consistency, assertions, and unit tests; Section 8 explicitly concedes that statistical validity is not yet checked, writing that 'Flowco's architecture prioritizes the reliable generation of executable code' and that 'a critical line of future work is extending Flowco's guardrails to check statistical correctness.' That admission narrows the scope of the user-study claim and is a genuine validity threat, but it is not circularity: the study measures a weaker, self-reported authoring-success claim, and the paper does not present the statistical-correctness claim as already established. The closest self-referential mechanism is that Flowco validates node outputs against an LLM-synthesized extended output type, so the type check is a self-consistency check rather than an external oracle; however, the paper does not claim this check establishes statistical or scientific validity, and the central user-study claim does not reduce to that check. No definition, equation, or fitted parameter is renamed as a prediction, and no load-bearing premise depends on an unverified self-citation.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

No free parameters or invented entities; the paper's contributions are a system design and qualitative evaluation. The load-bearing assumptions are that dataflow graphs are a natural authoring medium, that per-node LLM synthesis yields reliable code, and that the 12-participant first-use study supports the stated claims.

assumptions (4)
  • domain assumption Dataflow graphs are a natural medium for exploring, designing, and communicating data analysis workflows.
    The paper motivates its model from observations about scientists' external artifacts (Section 2.4), but does not prove this is superior to other representations for the target users.
  • domain assumption Restricting each LLM synthesis step to a single node and abstraction layer yields more reliable code than larger generation tasks.
    This is the core design premise of Section 5.1 and is not independently validated against monolithic generation.
  • domain assumption Type checks, assertions, and unit tests are sufficient guardrails to give high confidence in LLM-generated code.
    Section 5 presents these mechanisms but does not measure their effectiveness; Section 8 notes statistical validity is not checked.
  • domain assumption A first-use study with 12 data science students can support general claims about supporting analysts.
    Section 7 uses a small convenience sample with no control condition; the authors themselves call this a limitation in Section 8.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Flowco: Rethinking Data Analysis in the Age of LLMs." pith.science (2026). https://pith.science/paper/LWOV7IBT

@misc{pith2026250414038,
  author       = {Pith},
  title        = {Pith review of: Flowco: Rethinking Data Analysis in the Age of LLMs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/LWOV7IBT}},
  note         = {Machine review of arXiv:2504.14038}
}
read the original abstract

Conducting data analysis typically involves authoring code to transform, visualize, analyze, and interpret data. Large language models (LLMs) are now capable of generating such code for simple, routine analyses. LLMs promise to democratize data science by enabling those with limited programming expertise to conduct data analyses, including in scientific research, business, and policymaking. However, analysts in many real-world settings must often exercise fine-grained control over specific analysis steps, verify intermediate results explicitly, and iteratively refine their analytical approaches. Such tasks present barriers to building robust and reproducible analyses using LLMs alone or even in conjunction with existing authoring tools (e.g., computational notebooks). This paper introduces Flowco, a new mixed-initiative system to address these challenges. Flowco leverages a visual dataflow programming model and integrates LLMs into every phase of the authoring process. A user study suggests that Flowco supports analysts, particularly those with less programming experience, in quickly authoring, debugging, and refining data analyses.

Figures

Figures reproduced from arXiv: 2504.14038 by the authors.

Figure 1
Figure 1. Flowco is a mixed-initiative system that leverages a visual dataflow programming model and LLMs to not just synthesize code but also assist in all stages of development. In this example, the analyst creates a workflow to read Old Faithful geyser data, clusters eruptions by duration, and fits a linear model to each cluster. Flowco translates this graph into executable code via an LLM and exposes a variety of other in… view at source ↗
Figure 2
Figure 2. A Jupyter notebook exhibiting a potentially stale [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. The Flowco editor interface is divided into three panels: (Left) the project panel encompasses global actions and the “Ask Me Anything!” (AMA) chat box; (Center) the canvas is the visual editor for Flowco dataflow graphs; and (Right) the details panel presents details of the selected node during editing. A The user creates a new node to load the dataset in beaks.csv. B The user presses the Run button to synthesize c… view at source ↗
Figures from the paper (7 more)
Figure 4
Figure 4. Figure 4: G The user adds two plotting nodes to the graph, as well as H a node to select only the Fortis finches from the dataset. After running the graph, I the user selects Select-Fortis to examine it in the details panel. J The user exposes the synthesized code by selecting t…
Figure 5
Figure 5. Figure 5: Flowco enables the user to validate run-time assertion checks on node outputs via the Checks view. After K adding nodes to estimate the mean beak length for the Fortis finches L the user switches to the Checks view and M clicks the pencil icon that appears while hoveri…
Figure 5
Figure 5. Figure 5: Checks and Unit Tests. To gain confidence in the computation performed by Flowco and the results, Alex then adds assertions to check the node outputs in the graph. Specifically, L Alex switches from the Edit view to the Checks view at the top of the Project panel and t…
Figure 6
Figure 6. Figure 6: When Flowco asks the LLM to generate code for Select-Fortis during the compile step outlined in section 5.1, it provides a template containing the function signature and a pydoc string describing the parameters, preconditions, and requirements. synthesized extended out…
Figure 7
Figure 7. Figure 7: The user directly modifies the components of a node [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]
Figure 8
Figure 8. Figure 8: A multiverse analysis presented in 6.2 that explores how a female applicant’s likelihood of mortgage approval varies [PITH_FULL_IMAGE:figures/full_fig_p011_8.png]
Figure 9
Figure 9. Figure 9: A logistic regression presented in section 6.3 that predicts whether a mortgage application will be accepted. The [PITH_FULL_IMAGE:figures/full_fig_p012_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

70 extracted references · 53 canonical work pages

  1. [1]

    Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng

    Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manju- nath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek Gordon Murray, Benoit Steiner, Paul A. Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. 2016. TensorFlow: A S...

    2016

  2. [2]

    Altair. 2025. Altair RapidMiner. https://altair.com/altair-rapidminer. Accessed: 2025-03-16

    work page 2025

  3. [3]

    Alteryx. 2025. Alteryx Designer Cloud. https://www.alteryx.com/products/ designer-cloud. Accessed: 2025-03-16

    work page 2025

  4. [4]

    Anaconda. 2023. Anaconda Assistant Launches to Bring Instant Data Analysis, Code Generation, and Insights to Users. https: //www.anaconda.com/blog/anaconda-assistant-launches-to-bring-instant- data-analysis-code-generation-and-insights-to-users Accessed: 2024-10-19

    work page 2023

  5. [5]

    Ian Arawjo, Chelse Swoopes, Priyan Vaithilingam, Martin Wattenberg, and Elena L Glassman. 2024. Chainforge: A visual toolkit for prompt engineering and llm hypothesis testing. In Proceedings of the 2024 CHI Conference on Human Factors in Computing Systems . 1–18

    2024

  6. [6]

    Devanbu, and Michael Pradel

    Islem Bouzenia, Premkumar T. Devanbu, and Michael Pradel. 2024. RepairAgent: An Autonomous, LLM-Based Agent for Program Repair. CoRR abs/2403.17134 (2024). https://doi.org/10.48550/ARXIV.2403.17134 arXiv:2403.17134

    arXiv doi:10.48550/arxiv.2403.17134 2024

  7. [7]

    Henley, Anita Sarma, and Titus Barik

    Souti Chattopadhyay, Ishita Prasad, Austin Z. Henley, Anita Sarma, and Titus Barik. 2020. What’s Wrong with Computational Notebooks? Pain Points, Needs, and Design Opportunities. In CHI. ACM, 1–12

    work page 2020

  8. [8]

    Bhavya Chopra, Ananya Singha, Anna Fariha, Sumit Gulwani, Chris Parnin, Ashish Tiwari, and Austin Z Henley. 2023. Conversational challenges in ai- powered data science: Obstacles, needs, and design opportunities. arXiv preprint arXiv:2310.16164 (2023)

    arXiv 2023

Show all 70 references
  1. [9]

    Databricks. 2023. Introducing Databricks Assistant, a Context-Aware AI Assistant. https://www.databricks.com/blog/introducing-databricks-assistant Accessed: 2024-10-19

    2023

  2. [10]

    Helen Dong, Shurui Zhou, Jin LC Guo, and Christian Kästner. 2021. Splitting, renaming, removing: a study of common cleaning activities in Jupyter note- books. In 2021 36th IEEE/ACM International Conference on Automated Software Engineering Workshops (ASEW). IEEE, 114–119

    2021

  3. [11]

    FiveThirtyEight. 2025. Airline Safety. https://github.com/fivethirtyeight/ data/blob/4c1ff5e3aef1816ae04af63218015066e186c147/airline-safety/airline- safety.csv. Accessed: 2025-03-16

    2025

  4. [12]

    Grant and B

    Peter R. Grant and B. Rosemary Grant. 2013. Data from: 40 Years of evolution: Darwin’s finches on Daphne Major Island. https://datadryad.org/stash/dataset/ doi:10.5061/dryad.g6g3h. Accessed: 2025-03-16

    2013 doi

  5. [13]

    Grant and B

    Peter R. Grant and B. Rosemary Grant. 2014. 40 Years of Evolution: Darwin’s Finches on Daphne Major Island . Princeton University Press

    2014

  6. [14]

    There is no reason anybody should be using 1D anymore

    Jesse Harden, Elizabeth Christman, Nurit Kirshenbaum, Mahdi Belcaid, Jason Leigh, and Chris North. 2023. “There is no reason anybody should be using 1D anymore”: Design and Evaluation of 2D Jupyter Notebooks. Graphics Interface 2023 (2023)

    2023

  7. [15]

    Andrew Head, Fred Hohman, Titus Barik, Steven Mark Drucker, and Robert DeLine. 2019. Managing Messes in Computational Notebooks. In Proceed- ings of the 2019 CHI Conference on Human Factors in Computing Systems, CHI 2019, Glasgow, Scotland, UK, May 04-09, 2019 , Stephen A. Bre...

    2019

  8. [16]

    Andrew Head, Fred Hohman, Titus Barik, Steven M Drucker, and Robert DeLine

  9. [17]

    Eric Horvitz. 1999. Principles of mixed-initiative user interfaces. In Proceedings of the SIGCHI conference on Human Factors in Computing Systems . 159–166

    1999

  10. [18]

    Michael Isard, Mihai Budiu, Yuan Yu, Andrew Birrell, and Dennis Fetterly. 2007. Dryad: distributed data-parallel programs from sequential building blocks. In Proceedings of the 2007 EuroSys Conference, Lisbon, Portugal, March 21-23, 2007 , Paulo Ferreira, Thomas R. Gross, and ...

    2007

  11. [19]

    Peiling Jiang, Jude Rayan, Steven P Dow, and Haijun Xia. 2023. Graphologue: Exploring large language model responses with interactive diagrams. In Proceed- ings of the 36th annual ACM symposium on user interface software and technology . 1–20

    2023

  12. [20]

    Johnston, J

    Wesley M. Johnston, J. R. Paul Hanna, and Richard J. Millar. 2004. Advances in dataflow programming languages. ACM Comput. Surv. 36, 1 (2004), 1–34. https://doi.org/10.1145/1013208.1013209

    2004

  13. [21]

    Eunice Jun, Maureen Daum, Jared Roesch, Sarah E Chasins, Emery D Berger, Rene Just, and Katharina Reinecke. 2019. Tea: A High-level Language and Runtime System for Automating Statistical Analysis. In Proceedings of the 32nd Annual Symposium on User Interface Software and Techn...

    2019

  14. [22]

    Eunice Jun, Audrey Seo, Jeffrey Heer, and René Just. 2022. Tisane: Authoring Statistical Models via Formal Reasoning from Conceptual and Data Relationships. In Proceedings of the 2022 CHI Conference on Human Factors in Computing Systems. 1–16

    2022

  15. [23]

    Majeed Kazemitabaar, Jack Williams, Ian Drosos, Tovi Grossman, Austin Zachary Henley, Carina Negreanu, and Advait Sarkar. 2024. Improving Steering and Verification in AI-Assisted Data Analysis with Interactive Task Decomposition. In Proceedings of the 37th Annual ACM Symposium...

    2024

  16. [24]

    Mary Beth Kery, Marissa Radensky, Mahima Arya, Bonnie E John, and Brad A Myers. 2018. The story in the notebook: Exploratory data science using a literate programming tool. In Proceedings of the 2018 CHI conference on human factors in computing systems. 1–11

    2018

  17. [25]

    Knime. 2025. KNIME Analytics Platform. https://www.knime.com/knime- analytics-platform. Accessed: 2025-03-16

    2025

  18. [26]

    Jeffrey Kodosky. 2020. LabVIEW. Proc. ACM Program. Lang. 4, HOPL (2020), 78:1–78:54

    2020

  19. [27]

    David Koop and Jay Patel. 2017. Dataflow notebooks: encoding and tracking dependencies of cells. In 9th USENIX Workshop on the Theory and Practice of Provenance (TaPP 2017)

    2017

  20. [28]

    Claire Le Goues, Michael Pradel, and Abhik Roychoudhury. 2019. Automated program repair. Commun. ACM 62, 12 (2019), 56–65. https://doi.org/10.1145/ 3318162

    2019

  21. [29]

    Yang Liu, Alex Kale, Tim Althoff, and Jeffrey Heer. 2021. Boba: Authoring and Visualizing Multiverse Analyses. IEEE Trans. Vis. Comput. Graph. 27, 2 (2021), 1753–1763. https://doi.org/10.1109/TVCG.2020.3028985

    2021

  22. [30]

    Derek Gordon Murray, Frank McSherry, Rebecca Isaacs, Michael Isard, Paul Barham, and Martín Abadi. 2013. Naiad: a timely dataflow system. In ACM SIGOPS 24th Symposium on Operating Systems Principles, SOSP ’13, Farmington, PA, USA, November 3-6, 2013 , Michael Kaminsky and Mike...

    2013

  23. [31]

    Old Faithful Dataset. 2025. https://www.kaggle.com/datasets/janithwanni/old- faithful/data. Accessed: 2025-03-16

    2025

  24. [32]

    OpenAI. 2024. Improvements to Data Analysis in ChatGPT. https://openai.com/ index/improvements-to-data-analysis-in-chatgpt/ Accessed: 2024-10-19

    2024

  25. [33]

    OpenAI. 2025. OpenAI Function Calling. https://platform.openai.com/docs/ guides/function-calling. Accessed: 2025-03-16

    2025

  26. [34]

    OpenAI. 2025. OpenAI GPT-4o. https://platform.openai.com/docs/models/gpt-4o. Accessed: 2025-03-16

    2025

  27. [35]

    McBurney, H

    Evan Patterson, Robert N. McBurney, H. Schmidt, Ioana Baldini, Aleksandra Mojsilovic, and Kush R. Varshney. 2017. Dataflow representation of data analyses: Toward a platform for collaborative data science. IBM J. Res. Dev. 61, 6 (2017), 9:1–9:13. https://doi.org/10.1147/JRD.20...

    2017

  28. [36]

    Project Jupyter. 2024. Jupyter AI Documentation. https://jupyter-ai.readthedocs. io/en/latest/ Accessed: 2024-10-19

    2024

  29. [37]

    Project Jupyter. 2024. Project Jupyter. https://jupyter.org/ Accessed: 2024-10-19

    2024

  30. [38]

    Luigi Quaranta, Fabio Calefato, and Filippo Lanubile. 2022. Eliciting best practices for collaboration with computational notebooks. Proceedings of the ACM on Human-Computer Interaction 6, CSCW1 (2022), 1–41

    2022

  31. [39]

    To Appear

    Eric Rawn and Sarah Chasins. To Appear. Pagebreaks: Multi-Cell Scopes in Computational Notebooks. In Proceedings of the 2025 CHI Conference on Human Factors in Computing Systems

    2025

  32. [40]

    Adam Rule, Ian Drosos, Aurélien Tabard, and James D Hollan. 2018. Aiding collaborative reuse of computational notebooks with annotated cell folding. Proceedings of the ACM on Human-Computer Interaction 2, CSCW (2018), 1–12

    2018

  33. [41]

    Adam Rule, Aurélien Tabard, and James D Hollan. 2018. Exploration and expla- nation in computational notebooks. In Proceedings of the 2018 CHI Conference on Human Factors in Computing Systems . 1–12

    2018

  34. [42]

    Chasins, Andrew Head, and Aditya G

    Shreya Shankar, Stephen Macke, Sarah E. Chasins, Andrew Head, and Aditya G. Parameswaran. 2022. Bolt-on, Compact, and Rapid Program Slicing for Note- books [Scalable Data Science]. Proc. VLDB Endow. 15, 13 (2022), 4038–4047. https://doi.org/10.14778/3565838.3565855

    2022

  35. [43]

    Streamlit. 2025. Streamlit. https://streamlit.io/. Accessed: 2025-03-16

    2025

  36. [44]

    Sangho Suh, Bryan Min, Srishti Palani, and Haijun Xia. 2023. Sensecape: En- abling multilevel exploration and sensemaking with large language models. In Proceedings of the 36th annual ACM symposium on user interface software and technology. 1–18

    2023

  37. [45]

    Lev Tankelevitch, Viktor Kewenig, Auste Simkute, Ava Elizabeth Scott, Advait Sarkar, Abigail Sellen, and Sean Rintel. 2024. The Metacognitive Demands and 16 Flowco: Rethinking Data Analysis in the Age of LLMs Opportunities of Generative AI. In CHI. ACM, 680:1–680:24

    2024

  38. [46]

    Zhongwei Wan, Xin Wang, Che Liu, Samiul Alam, Yu Zheng, Jiachen Liu, Zhong- nan Qu, Shen Yan, Yi Zhu, Quanlu Zhang, Mosharaf Chowdhury, and Mi Zhang

  39. [47]

    Jiayu Wang, Yifei Ming, Zhenmei Shi, Vibhav Vineet, Xin Wang, Sharon Li, and Neel Joshi. 2024. Is A Picture Worth A Thousand Words? Delving Into Spatial Reasoning for Vision Language Models. In Advances in Neural Information Pro- cessing Systems 38: Annual Conference on Neural...

    2024

  40. [48]

    Zuozhi Wang, Yicong Huang, Shengquan Ni, Avinash Kumar, Sadeem Alsudais, Xiaozhen Liu, Xinyuan Lin, Yunyan Ding, and Chen Li. 2024. Texera: A System for Collaborative and Interactive Data Analytics Using Workflows. Proc. VLDB Endow. 17, 11 (2024), 3580–3588. https://doi.org/10...

    2024

  41. [49]

    John Wenskovitch, Jian Zhao, Scott Carter, Matthew Cooper, and Chris North

  42. [50]

    Tongshuang Wu, Michael Terry, and Carrie Jun Cai. 2022. Ai chains: Transparent and controllable human-ai interaction by chaining large language model prompts. In Proceedings of the 2022 CHI conference on human factors in computing systems . 1–22

    2022

  43. [51]

    Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press

    John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. 2024. SWE-agent: Agent-Computer Inter- faces Enable Automated Software Engineering. InAdvances in Neural Information Processing Systems 38: Annual Conference on Neura...

    2024

  44. [52]

    In 2019 IEEE visualization in data science (VDS)

    Albireo: An interactive tool for visually summarizing computational notebook structure. In 2019 IEEE visualization in data science (VDS) . IEEE, 1–10

    2019

  45. [53]

    Describe this dataset

    JD Zamfirescu-Pereira, Eunice Jun, Michael Terry, Qian Yang, and Björn Hart- mann. 2025. Beyond Code Generation: LLM-supported Exploration of the Pro- gram Design Space. arXiv preprint arXiv:2503.06911 (2025). 17 A Flowco’s AMA Chat Response to “Describe this dataset” in Secti...

    2025 arXiv

  46. [55]

    Ryan Yen, Jiawen Stefanie Zhu, Sangho Suh, Haijun Xia, and Jian Zhao. 2024. CoLadder: Manipulating Code Generation via Multi-Level Blocks. In Proceedings of the 37th Annual ACM Symposium on User Interface Software and Technology . 1–20

    2024

  47. [57]

    Specifically, we want to explore the columns, data types, and any patterns or distributions in the data

    Restating the Question The question asks for a description of the dataset, which involves understanding its structure, content, and any notable characteristics. Specifically, we want to explore the columns, data types, and any patterns or distributions in the data

  48. [58]

    Approach To describe the dataset, I will:

  49. [59]

    Examine the structure of the dataset, including column names and data types

  50. [60]

    Summarize the data to understand its size and basic statistics

  51. [61]

    Check for missing values or anomalies

  52. [62]

    Explore the distribution of key variables, such as Beak length, mm and Beak depth, mm

  53. [63]

    Steps of Analysis I will perform the following steps:

  54. [64]

    Inspect the structure of the dataset: This includes column names, data types, and a preview of the data

  55. [65]

    Summarize the dataset: Generate descriptive statistics for numerical columns

  56. [66]

    Check for missing values: Identify if any columns have missing data

  57. [67]

    Let me start by inspecting the dataset

    Visualize distributions: Plot histograms or boxplots for numerical columns to understand their distributions. Let me start by inspecting the dataset. Okay, I ran some code: # Inspect the structure of the dataset beaks.info() The dataset contains 406 rows and 3 columns. Here’s ...

  58. [68]

    This suggests the presence of two distinct groups or species with different beak lengths

    Beak Length (mm): • The distribution appears bimodal, with two peaks around 11 mm and 14 mm. This suggests the presence of two distinct groups or species with different beak lengths. • The range spans from approximately 8.7 mm to 15.9 mm

  59. [69]

    • The range spans from approximately 7.5 mm to 11 mm

    Beak Depth (mm): • The distribution is unimodal and roughly symmetric, centered around 9 mm. • The range spans from approximately 7.5 mm to 11 mm. These patterns suggest that the dataset may represent multiple species with distinct beak character- istics, particularly in terms...

  60. [70]

    Key observations include: • The species column categorizes the data, likely corresponding to the two distinct groups observed in the beak length distribution

    Conclusion The dataset contains information about bird species and their beak measurements. Key observations include: • The species column categorizes the data, likely corresponding to the two distinct groups observed in the beak length distribution. 19 • Beak length shows gre...

  61. [2019]

    In Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems

    Managing messes in computational notebooks. In Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems . 1–12

    2019

  62. [2024]

    Efficient Large Language Models: A Survey. Trans. Mach. Learn. Res. 2024 (2024). https://openreview.net/forum?id=bsCCJHbO8A

    2024

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.