BitsAI-Fix: Automated Lint Error Remediation

Updated 8 July 2026

BitsAI-Fix is an automated lint error remediation workflow that uses LLMs and tree-sitter to extract contextual code segments for precise patch generation.
It generates unified diff patches in a search-and-replace format, ensuring minimal, robust, and token-efficient modifications even during code evolution.
The system employs progressive reinforcement learning with online feedback to continuously refine its repairs, achieving around 85% remediation accuracy in production.

BitsAI-Fix is an automated lint error remediation workflow based on LLMs, developed for industrial-scale codebases in which the volume of lint errors exceeds engineers’ manual remediation capacity, leading to continuous accumulation of technical debt and hindered development efficiency. It employs tree-sitter for context expansion, generates search-and-replace format patches through specially trained LLMs, and performs lint scan re-verification before outputting remediation results. Its training pipeline introduces a progressive reinforcement learning strategy that acquires verifiable training data during the project cold-start phase and continues to iterate through online feedback after deployment. In production deployment at ByteDance, it supported over 5,000 engineers, resolved more than 12,000 static analysis issues, achieved approximately 85% remediation accuracy, and reached around 1,000 weekly active adopters (Li et al., 5 Aug 2025).

1. Problem Setting and System Scope

BitsAI-Fix targets unresolved lint errors in large-scale enterprise repositories. The motivating premise is that enterprise codebases continue to grow in scale and complexity, while lint error volume far exceeds the remediation capacity of human engineers. The system is therefore framed as an automated code remediation solution for a domain in which the error location is already known: for each detected lint error, the location is already known, which allows the workflow to focus on contextualization, patch synthesis, and validation rather than fault localization (Li et al., 5 Aug 2025).

The system architecture is organized into two primary modules: a Lint Error Fix Workflow and a Model Training Module (Progressive RL). This division is significant because it couples online repair generation with a continuous data-and-reward pipeline. The design is described as a streamlined, high-throughput alternative to complex agent-based systems, and the paper explicitly characterizes it as a lightweight, non-agent workflow suited to the massive, well-localized lint error domain.

2. Remediation Workflow and Patch Representation

The lint remediation workflow proceeds through context extraction, patch generation, and validity verification (Li et al., 5 Aug 2025). Context extraction is two-tiered. First, BitsAI-Fix uses tree-sitter to identify and extract the smallest function, method, or syntactic unit containing the lint error. Second, it augments that unit with the definitions of directly referenced symbols within the function, using tree-sitter for AST-based dependencies and LLM-based inference for external packages as needed. The stated purpose of this two-tier extraction is to balance repair accuracy and token efficiency by providing enough, but not overwhelming, context.

Patch generation is carried out by a specially fine-tuned LLM that receives the extracted context together with the lint error message and produces a search-and-replace style patch in unified diff format. The paper attributes three properties to this representation: it is robust to line changes during code evolution, token-efficient because it modifies only changed lines, and immediately applicable by automation tools or user approval. An example given for the search-and-replace format is:

### project/project_workflow_main_loop.go
<<<<<<< SEARCH
errg.Go(func() error {
    if err = task.InitIDL(ctx); err != nil {
        return err
    }
    return nil
})
=======
errg.Go(func() error {
    defer func() {
        if r := recover(); r != nil {
            logs.CtxInfo(ctx, "Recovered from panic: %v", r)
        }
    }()
    return task.InitIDL(ctx)
})
>>>>>>> REPLACE

Validity verification is fully automatic. The generated patch is applied to the code, the project’s lint tool is run again, and the system checks whether the original error disappears. If validation fails, patch generation is retried up to three times. Only validated, lint-passing patches are proposed to developers through the MR UI. Developers can accept, reject, or further modify the patch, and only explicit acceptance leads to a commit. This verification loop makes remediation success operationally tied to the target lint signal rather than to a purely textual similarity criterion.

3. Progressive Reinforcement Learning Strategy

BitsAI-Fix trains its repair model through a progressive reinforcement learning framework with a cold-start phase and an online user feedback phase (Li et al., 5 Aug 2025). The cold-start phase addresses the absence of hand-labeled “golden” patches. It constructs semi-synthetic executable data by extracting minimal project dependencies with tree-sitter-based AST dependency pruning, inferring third-party imports through LLMs, and then running a reproducibility test to ensure that the pruned context still reproduces the original lint issue. Sample selection retains only instances that pass the reproducibility check, compile successfully, span a range of difficulty using DeepSeek-R1 attempts per sample, and preserve balanced error type coverage at approximately 30 samples per category.

After deployment, the system enters an online feedback phase in which it collects user-accepted fix samples from actual usage. These accepted samples serve as real “ground truth” for text-matching reward computation. The paper describes this as a progressive dual-mode data pipeline that enables continual model refinement with increasingly reliable, verifiable data.

The reward mechanism is rule-based and is described as being inspired by GRPO. It combines format rewards, compilation rewards, and correctness rewards, while penalizing redundant modifications. The format reward checks that the patch is in the correct search-and-replace diff format, is minimal, and that only one patch is generated per error. The reward components are specified as follows:

$r_f(C) = \begin{cases} 0.0, & \text{if patch is correctly formatted} \ -0.1 \cdot i - 0.1 \cdot j, & \text{for each format or application error} \ -0.1 \cdot k, & \text{for each redundant patch} \end{cases}$

The compilation reward is $0.0$ if the result is not compilable and $+0.3$ if it is compilable. The correctness reward is $+0.7$ when, in the cold-start phase, the patch eliminates the error, whereas in the feedback phase it is proportional to similarity, expressed as $+0.7 \times F_\beta$ between the generated and ground-truth patch. The total reward is:

$r(C) = r_f(C) + r_p(C) + \pi[r_p(C) > 0] \cdot r_c(C)$

The training objective is described as a standard PPO-style objective with importance-sampled advantage and a KL penalty to a reference policy. The intended effect of this reward design is not merely correctness, but correctness under constraints of patch minimality and non-redundancy.

4. Continuous Assessment and “Code Diff Matching”

BitsAI-Fix introduces a “code diff matching” methodology to continuously track online effectiveness (Li et al., 5 Aug 2025). The motivation is operational rather than algorithmic: developers often apply fixes in their IDEs and push code directly, instead of using explicit “Adopt” buttons in web interfaces, which makes click-based telemetry an unreliable measure of actual adoption.

The method records the generated patch for each lint error as a diff and later extracts the actual diff from the user’s merge request or commit. If the user’s actual diff fully contains the LLM-generated patch, the fix is counted as adopted; otherwise it is counted as not adopted. This definition measures real-world tool effectiveness even when developers do not interact with the web UI in a traceable way. The paper further states that this mechanism enables the construction of a large, reliable feedback dataset for retraining.

Two aggregate metrics are also reported in formula form:

$\text{Fix Accuracy} = \frac{\sum_{i=1}^N \mathbb{I}(S_i)}{N}$

$\text{Fix Redundancy} = \frac{\sum_{i=1}^N \mathbb{I}(P_i > E_i)}{N}$

These formulations align assessment with the system’s stated objective: repairs should both solve the targeted issue and avoid unnecessary edits.

5. Deployment at ByteDance and Reported Outcomes

The reported production deployment at ByteDance establishes BitsAI-Fix as an industrial system rather than a laboratory prototype (Li et al., 5 Aug 2025). The deployment figures are summarized below.

Metric	Reported value
Engineers supported	over 5,000
Static analysis issues resolved	more than 12,000
Weekly fixes	over 2,000
Weekly Active Adopters	around 1,000
Remediation accuracy	approximately 85%
Redundant patch rate after RL	1.72%

The paper states that remediation accuracy corresponds to patches that both compile and resolve their targeted lint errors. It also reports a staged improvement through training: the base LLM reaches approximately 54% accuracy, the SFT-trained LLM approximately 65%, and the RL-trained LLM approximately 85%. In parallel, fix redundancy is reduced from almost 10% to 1.72%. The paper attributes this reduction to RL and reward shaping, especially the explicit redundancy penalties.

These results are framed as evidence of practical feasibility in enterprise environments. The stated contribution is not only technical performance, but the demonstration that an LLM-based remediation system can sustain broad organizational adoption while continuously improving through usage-derived feedback.

6. Position Within Automated Repair Research

BitsAI-Fix sits within a broader research landscape concerned with recurring repair regularities, automated patch generation, and empirical studies of how developers fix defects. Earlier work on crash repair in Eclipse showed that almost all exceptions belonging to a certain exception type can be fixed by less than ten fix types, and that across NullPointerException, IndexOutOfBoundsException, and ClassCastException, fewer than ten fix types account for more than 95% of fixes (Nam et al., 2013). A related study on FindBugs violations mined fix patterns from tracked revisions and reported that developers accepted and merged 69 of 116 submitted fixes generated from inferred patterns (Liu et al., 2017). These results suggest a long-standing empirical basis for repair systems that exploit highly repetitive remediation structures.

Neural code repair systems provide a second relevant context. SeqTrans formulates vulnerability fixing as sequence-to-sequence learning with transformers, leverages data flow dependencies to construct code sequences, and reports 23.3% statement-level fix accuracy and 25.3% CVE-level fix accuracy on Java vulnerabilities (Chi et al., 2020). BitsAI-Fix differs in operating conditions: it is centered on lint errors whose locations are already known, uses tree-sitter-based function-and-dependency context extraction, outputs unified diff search-and-replace patches, and grounds acceptance in lint re-verification and online adoption tracking rather than in CVE-level reconstruction tasks.

Research on non-traditional software domains further sharpens the distinctiveness of BitsAI-Fix. A study of DNN bug repair concluded that DNN bug fix patterns are substantially different from traditional software fix patterns and identified distinctive repair classes such as data dimension fixes and neural network connectivity fixes (Islam et al., 2020). SelfHeal extended repair research to LLM agents, using two independent ReAct agents—a fix agent and a critic agent—together with internal fix rules and external web search, and evaluated the resulting system on the AgentDefect benchmark (Islam et al., 20 Apr 2026). Against this background, a plausible implication is that BitsAI-Fix occupies a different operating point: rather than adopting a multi-agent critique loop or targeting domain-specific semantic failures, it prioritizes a lightweight workflow of context extraction, patch generation, verification, and feedback-driven RL for industrial lint remediation.

Taken together, the surrounding literature indicates that automated repair systems often depend on the regularity of fix patterns, the choice of contextual representation, and the availability of verifiable feedback. BitsAI-Fix contributes to this trajectory by showing that a non-agent LLM workflow, combined with tree-sitter context expansion, unified diff patch generation, lint re-verification, progressive RL, and code diff matching, can be deployed at enterprise scale and serve as a reference for automated code fix in large-scale industrial scenarios (Li et al., 5 Aug 2025).