technical communication

Non-English developers face significant barriers in contributing to open-source projects due to the predominance of English-language technical documentation. To address this, we propose TRIFID, the first framework enabling automated, structure-aware quantitative evaluation of translations involving mixed-content artifacts—natural language, source code, URLs, and Markdown—and supporting translation-aware continuous integration. We conduct English-to-German README translation experiments using ChatGPT-4 and Claude, validating results through both human evaluation and automated metrics. Our findings reveal that while large language models (LLMs) achieve high semantic fidelity, preserving formatting and code structure remains challenging; moreover, community-provided human translations are scarce and heavily concentrated among top-tier projects. This work empirically validates the feasibility of LLM-driven automated documentation internationalization, establishing a reproducible methodology and a standardized benchmark for multilingual support in open-source ecosystems.

To address insufficient content controllability when compressing lengthy technical documents (e.g., research papers) into concise formats (e.g., blog posts), this paper proposes an interactive reverse-source outline mechanism. It explicitly models LLM-based summarization as an editable, traceable, structured outline—comprising hierarchical, semantically grounded nodes—enabling iterative user refinement of functional points to precisely govern information coverage. The method integrates large language models, dynamic content-to-outline mapping, and an interactive UI to realize an end-to-end, fine-grained summarization system. Empirical evaluation and real-world deployment demonstrate significant improvements: author satisfaction with content coverage increases markedly; information change per editing operation rises by 37%; and retention of critical research insights improves 2.1×. This work achieves, for the first time, bidirectional controllability—both selection and synthesis—over content in technical document summarization.

To address the error-prone and inefficient manual rewriting of data transformation logic upon JSON Schema evolution, this paper proposes a type-directed, top-down program synthesis approach for automatically generating semantics-preserving JSON Schema converters. Our method integrates type inference, semantic constraint modeling, a rewrite system, and intermediate representation (IR)-driven code generation to guarantee lossless data transformation and formal verifiability. It natively supports complex nested schemas and synthesizes correct, efficient, and human-readable Python and JavaScript conversion code. We evaluate our approach on real-world API configuration schemas and healthcare data integration scenarios, demonstrating its safety—via formal guarantees and empirical validation—its practical utility in industrial settings, and its generalizability across diverse schema evolution patterns. Experimental results confirm high accuracy, robustness to structural changes (e.g., field additions, type refinements, nested object restructuring), and scalability to large, deeply nested schemas.

Existing element-attribute grid representations for graphic design completion tasks struggle to model variable-length, type-heterogeneous, and multimodal (text-image) structures. Method: We propose a unified interleaved multimodal tokenized document model that jointly encodes syntactic and semantic structures of markup languages (e.g., SVG/HTML) alongside variable-size, alpha-channel-aware local image generation. We introduce a specialized image quantizer for efficient transparent-image tokenization and integrate an enhanced code-large language model with an interleaved multimodal sequence architecture. Contribution/Results: Our model achieves significant improvements over baselines on three design completion tasks—missing template attributes, image synthesis, and text generation—demonstrating its effectiveness in jointly modeling structural logic and visual semantics in design documents.

Large language models (LLMs) often produce text with weak factual grounding, poor coherence, and misalignment with user intent. To address these issues, this paper proposes WritingPath—a novel outline-driven, structured writing framework that explicitly models human writing planning logic as a hierarchical outline and integrates it throughout the LLM generation process. Methodologically, WritingPath combines outline-aware generation, multi-stage prompt engineering, and human-in-the-loop evaluation for alignment optimization. It also introduces the first benchmark dataset for joint outline-text quality assessment, comprising real-world blog outline–text pairs. Experiments across multiple LLMs demonstrate significant improvements in factual accuracy, coherence, and user-intent alignment of generated text. Both automated metrics and expert writer evaluations confirm the framework’s effectiveness, establishing a new paradigm for controllable, high-fidelity LLM-based content generation.

This work addresses the limitations of existing software documentation, which often suffers from poor consistency, weak relevance, and unclear expression, while purely automated generation methods struggle with insufficient reliability and controllability. To overcome these challenges, the authors propose a human-AI collaborative approach that integrates empirically derived quality guidelines with large language model (LLM) assistance through a generate–evaluate–iterate workflow. This method preserves developers’ domain control while enhancing explanation quality by embedding experience-driven quality criteria directly into the LLM-assisted writing process, enabling controllable, efficient, and high-quality output. Preliminary experiments demonstrate a 24.4% average improvement in authoring efficiency with tool support, and user studies reveal significantly higher satisfaction with the generated explanations compared to purely manual writing (p = 0.003, effect size = 0.86).

Existing code documentation often suffers from incompleteness, obsolescence, or inaccuracies, hindering developer comprehension and limiting the performance of large language models (LLMs) in software engineering tasks. This work introduces, for the first time, the concept of “code-document equivalence” and presents Documentary, a novel approach that synthesizes code semantic analysis with LLM-driven natural language generation to automatically produce high-quality, semantically consistent documentation. Experimental results demonstrate that Documentary generates equivalent documentation for 53.4% of functions, significantly improving LLM accuracy on code understanding and editing tasks by 12.8–24.5% compared to both human-written and baseline documentation. Furthermore, developers consistently rate Documentary-generated documentation higher in quality and usefulness.

This work addresses the challenges of structural inconsistency, missing content, and cross-section incoherence commonly encountered in automatically generated scientific papers, particularly between narrative text, experimental evidence, and visual elements. To resolve these issues, the authors propose a multi-agent collaborative framework grounded in a persistent shared visual contract, comprising architect, writer, optimizer, renderer, and evaluator agents. These agents operate within a generate–evaluate–adapt loop that dynamically updates the contract to align textual structure with visual components throughout the document. The approach introduces, for the first time, a contract-driven mechanism to regulate multi-agent collaboration. Evaluated on the Jericho corpus, the method achieves an expert rating of 6.145, significantly outperforming DirectChat (3.963) and Fars (5.197), thereby demonstrating substantial improvements in both structural coherence and text–figure consistency.

Traditional literate programming struggles to dynamically link program execution with intermediate results. This work proposes a novel paradigm called “executable literate programming,” which treats explanatory content—such as narrative documentation and visualizations—as first-class constructs on par with code. Built upon the Fluid language and its runtime system that supports fine-grained provenance tracking, this approach explicitly records dependency relationships between inputs and outputs. For the first time, it achieves deep integration between explanatory artifacts and program execution, enabling an interactive programming environment where users can explore how intermediate values influence final outcomes. This significantly enhances both the interpretability and exploratory capabilities of computational workflows.

The widespread adoption of AI writing tools has blurred the boundaries of authorship, accountability, and intellectual contribution, while existing disclosure practices often lack transparency regarding the specifics of AI involvement. This study proposes a multidimensional, fine-grained attribution framework that systematically characterizes AI-assisted writing across document and paragraph levels through three core dimensions—form, generation, and evaluation—further extended by intent, control, and traceability. Employing a structured modeling paradigm integrated with metadata annotation and hierarchical description mechanisms, the framework enables, for the first time, operational and scalable recording of both AI intervention points and human oversight actions. Empirical validation through real-world writing cases demonstrates that this approach establishes a practical, transparent baseline for attributing contributions in AI-assisted text production.