streamlit

Direct LLM-based generation of complete, multi-file UI code faces challenges including complex prompt engineering, verbose and unmaintainable outputs, and poor structural controllability. To address these, we propose a scaffolded code generation framework grounded in an intermediate representation (IR), which decomposes UI development into three structured IR artifacts: application storyboards, data models, and GUI skeletons—enabling iterative, human-LLM co-construction. Our IR-driven approach explicitly models navigation flows and component dependencies to guide multi-file code synthesis, thereby enhancing output interpretability, maintainability, and collaborative efficiency. A user study demonstrates that 75% of participants preferred our system over conventional chat-based baselines; it significantly reduced error rates and improved development speed in prototype-building tasks.

This study systematically evaluates large language models’ (LLMs) ability to invoke unfamiliar, domain-specific Python libraries (e.g., ParShift, pyclugen) for complex scientific computing tasks under zero-shot conditions, focusing on the reliability of generating executable and functionally correct code. We propose a structured zero-shot prompting framework, integrated with multi-round quantitative execution validation, functional correctness assessment, and error-pattern analysis; additionally, conversational data analysis and synthetic-data clustering serve as complementary evaluation dimensions. To our knowledge, this is the first benchmarking effort targeting LLMs’ capability to interface with third-party scientific computing libraries. Our evaluation reveals that documentation gaps and implementation flaws in target libraries significantly impede code generation. Results show only GPT-4.1 achieves consistent success across all tasks—outperforming all other models substantially. This work establishes a novel benchmark, methodology, and empirical foundation for trustworthy LLM-driven code generation in scientific automation.

This work addresses the high manual overhead and conceptual abstraction challenges faced by researchers and developers in Python package development. We propose a human-AI collaborative, end-to-end package auto-generation framework. Our method introduces a novel multi-stage large language model (LLM) orchestration paradigm, integrating structured prompt distillation, prompt augmentation, and a dual-track Human/LLM evaluation mechanism. Leveraging open-source autoregressive models—including CodeLlama and Phi-3—it jointly generates production-ready code, modular architecture, unit tests, and comprehensive documentation. Empirical evaluation demonstrates an 89% human-verified pass rate for generated packages, a 3.2× improvement in documentation completeness, and a 76% reduction in development cycle time. All source code, prompts, and usage examples are publicly released under an open license, enabling reproducible, extensible, and ethically grounded AI-augmented software engineering practice.

Data standardization is critical in the data science lifecycle, yet existing tools (e.g., Pandas) require manual, error-prone coding, while LLM-based automation still demands expert prompt engineering and iterative interaction. To address this, we propose a declarative API-driven LLM-Agent framework that introduces *Dataprep.Clean*—a novel, column-type-aware standardization component enabling end-to-end automation via a single-line operation and one-shot natural language input. Our method integrates domain knowledge modeling with lightweight agent orchestration, eliminating programming prerequisites and enabling semantic cleaning of heterogeneous columns. Evaluated on real-world datasets, the approach achieves high accuracy and robustness across diverse standardization tasks. Deployed as an interactive web tool, it substantially lowers the barrier to entry for data practitioners. This work advances data preprocessing toward declarative, intelligent automation—bridging the gap between domain expertise and scalable, user-friendly tooling.

This work addresses the lack of standardized evaluation for large language models (LLMs) in generating visualization code from tabular data. We introduce PandasPlotBench, the first benchmark dataset specifically targeting Pandas DataFrame visualization—comprising 175 human-annotated tasks spanning Matplotlib, Seaborn, and Plotly. Our methodology employs natural-language instruction-driven code generation, coupled with standardized prompting and execution-based code evaluation. Key contributions include: (1) the first fine-grained, task-level evaluation framework for exploratory data visualization from tables; (2) empirical identification of a significant generalization gap for LLMs on Plotly—despite strong performance on Matplotlib and Seaborn; (3) demonstration of robustness to concise instructions across the latter two libraries; and (4) open-sourcing of both the benchmark dataset and evaluation framework, which has been widely adopted by the research community.

This work addresses the inefficiencies researchers face in interactive computing environments due to cumbersome parameter configuration, inconsistent user interfaces, and the inability to persist settings across sessions—factors that hinder exploratory workflows and reproducibility. To overcome these challenges, the authors propose a declarative UI generation framework that, from a single specification of input parameters and validation rules, automatically renders consistent interfaces across diverse platforms such as Jupyter, Colab, and terminal-based environments. Inspired by ImageJ/FIJI, the system incorporates a persistence mechanism that serializes configurations in YAML format, enabling seamless sharing and reuse of settings across sessions and platforms. This approach significantly lowers the barrier for non-programmers to employ complex algorithms, minimizes redundant input, and enhances both experimental iteration speed and scientific reproducibility.

This paper addresses the state fragmentation between natural-language prompts and formal programs (e.g., Python), which necessitates manual interoperability implementation. To resolve this, we propose a shared program state abstraction mechanism, underpinned by a novel Natural Function Interface (NFI) specification that unifies runtime state across natural-language code and host programs—enabling seamless variable access, object manipulation, and control-flow coordination. Implemented in the Nightjar system, our approach integrates natural-language interface compilation, state bridging, and dynamic execution scheduling to achieve, for the first time, fully transparent state interoperability within a programming environment. Experiments demonstrate a 4–19% improvement in task accuracy, a 39.6% average reduction in generated code length, and runtime overhead ranging from 0.4× to 4.3× that of manual implementations. Our core contribution is establishing a state-consistency paradigm for collaborative execution between natural and formal languages.

This work addresses the significant limitations of spreadsheet-based analysis in reproducibility, auditability, version control, and automation. It proposes a migration pathway from Excel to research-grade analytical workflows by leveraging Python’s pandas library as a bridge. The study introduces an innovative set of Excel-to-pandas mapping rules, categorizes nine canonical workflow patterns, and compiles a catalog of common failure modes. Seven end-to-end real-world examples demonstrate the approach in practice. By retaining Excel as a familiar interface for input and output while integrating version control, automated refreshing, and seamless incorporation of statistical and machine learning methods, the proposed framework enables governed, reproducible, and auditable tabular data analysis.

This study investigates whether large language models (LLMs) can efficiently construct and maintain large-scale, multi-module software systems using only natural language prompts, particularly in emerging programming language ecosystems lacking mature toolchains. Leveraging Claude Code (Opus 4.5), the authors employed a fully prompt-driven workflow to develop a 7,420-line terminal user interface (TUI) framework within three days—implementing production-grade features such as window management, event-driven architecture, and interactive components—without writing any code manually. The project was realized through 107 concise prompts, enabling highly iterative development. This work provides the first empirical evidence that LLMs can sustain architectural consistency throughout the construction of complex software systems, thereby validating prompt-driven development as a viable new paradigm in software engineering.

Automatically generating verifiable Python formal specifications remains challenging, and developers often abandon automated verification tools due to the tediousness of manually writing contracts. This work proposes a closed-loop approach that integrates large language models with symbolic execution (CrossHair) to automatically generate and iteratively refine icontract-style contract annotations without modifying the original code. The method leverages feedback from symbolic execution to drive specification refinement and simultaneously produces coverage-guided pytest stubs and debugging artifacts. Experimental results demonstrate that the approach successfully generates CrossHair-compatible specifications for most programs, significantly enhancing the practical feasibility of automated verification, while also revealing real-world limitations arising from the boundaries of symbolic exploration and behavioral discrepancies in large language models.