acceptodds
Under review as a conference paper at ICLR 2027

SEW: Style-Encoded Watermarking of LLM-Generated Code

Abstract

Code watermarking supports provenance tracking for code generated by LLMs. Modifying token selection to embed watermarks as an LLM generates code can create a trade-off between detectability and functional correctness. Other methods instead watermark completed code using predefined transformations or trained neural models. Recurring patterns can make watermark choices predictable across programs, while treating patterns common in unwatermarked code as watermark evidence can cause false detections. We therefore introduce **SEW**, which embeds and detects watermarks in already generated code through three components: (i) code style rules collected from style guides and transformation rules, with style choices determined by a secret key and each program's structural context; (ii) style-preference calibration, which evaluates watermark evidence using style probabilities estimated from human-written code; and (iii) context-aware style aggregation, which combines evidence from structurally matching locations assigned the same code style choice, preventing repeated applications of that choice from inflating watermark evidence. On CodeContests across three LLMs and three programming languages, SEW achieves a mean relative improvement of 11.90% in TPR@FPR5% over the baselines and is robust to four non-LLM code-editing attacks, with only a 0.94% mean relative decrease. Our code is available at https://anonymous.4open.science/r/Code_Watermark.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Code Watermarking, Large Language Models, Code Style, Program Transformations

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_bo59OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposed SEW which is a watermarking method for code generated by LLMs, which addresses several limitations of existing code-watermarking techniques, such as the potential for compromising program functionality, the vulnerability of fixed code-transformation patterns to inference by attackers, and the risk of false positives arising from natural variations in coding style. Unlike methods that modify token probabilities during the code-generation process, SEW embeds watermarks after generation is complete by applying semantic-preserving transformations to the code's style. This approach requires neither access to the generative model nor the training of additional neural networks.

Critical strengths
  1. This paper proposed SEW which can directly watermarking the generated code which can embed watermarks directly into already-generated code, without requiring access to the original LLMs or the training of additional neural networks. By employing code-style transformations combined with checks for type, semantics, and structure the authors minimize the risk that the embedded watermark might interfere with the program's functionality.
  2. The experiment is comprehansive and this paper is easy to follow.
Critical weaknesses
  1. This paper apply program structural information and return statements with a secret key to determine the watermark style. However, a big concern is that the information can be modified easily without affecting the code's functionality. For example, an attacker could simply add a function that is never called. This would alter the overall program context, causing the watermark target calculated during detection to deviate from the original. Such an attack does not even require knowledge of the secret key.
  2. Another concern is that the probability distribution resulting from a majority vote across multiple locations is not necessarily identical to the style probability distribution for a single location. In addition, ablation study did not consider the contributions of program context, structural markers, and key-based style assignment.
Questions for authors
  1. This paper uses the number of functions, parameters, loops, and return statements to determine the watermark style. Could the author explain how SEW handles these types of simple structural changes? Furthermore, to what extent would the watermark detection performance be impacted if one were to simply add an extraneous function or loop?
  2. This paper apply majority voting to code locations within the same Grade, and then perform statistical tests using style probabilities estimated from human-written code. However, I am not entirely clear on how these probabilities are determined. After majority voting is applied across multiple locations, the resulting probability distribution is not necessarily the same as that of an individual location. In addition, different grades may not necessarily independent of one another.
  3. Please provide an more ablation that isolates the specific contributions of the application context and structural identifiers, which could explain why it is necessary to use the Secret Key, siteID, and application context in combination?
  4. This paper counts any watermark decision that the attacker has not previously observed as a prediction error. I find this evaluation method maybe unfair. If such combinations are automatically classified as errors, does a lower prediction accuracy truly indicate that the watermarks are harder to predict, or does it simply reflect the fact that there is little overlap in these structural combinations across different programs?
10 comments
AuthorsOpenReview ↗

Response to Reviewer bo59[1/6]

W1. This paper apply program structural information and return statements with a secret key to determine the watermark style. However, a big concern is that the information can be modified easily without affecting the code’s functionality. For example, an attacker could simply add a function that is never called. This would alter the overall program context, causing the watermark target calculated during detection to deviate from the original. Such an attack does not even require knowledge of the secret key.

Q1. This paper uses the number of functions, parameters, loops, and return statements to determine the watermark style. Could the author explain how SEW handles these types of simple structural changes? Furthermore, to what extent would the watermark detection performance be impacted if one were to simply add an extraneous function or loop?

Response to W1 / Q1

Thank you for raising this concern. Our additional experiments show that SEW is sensitive to structural insertions, but unused-function insertion also affects other evaluated post-hoc watermarking methods. These structural insertions can be mitigated through simple static-analysis preprocessing that excludes safely identified unused or unreachable constructs when computing χ(C)\chi(C) during embedding and detection. For example, tools such as Ruff and Vulture can help identify such constructs in Python. We report the structural insertion results in Appendix H of the revised manuscript.

[Structural Insertion Attacks]

SEW derives watermark targets using the structural context χ(C)\chi(C). Inserting a function or loop can change these targets during detection even when existing watermark-bearing styles remain unchanged. We evaluate four behavior-preserving insertions: an unused function containing return 0, a zero-iteration loop, an unused parameter with updated call sites, and a return statement in an unreachable branch. Across Python, Java, and C++, unused-function insertion reduces SEW's mean TPR@FPR5% from 98.21%–99.49% to 16.06%–24.99%, while loop insertion reduces it to 15.64%–26.33%. SrcMarker and RoSeMary also fall to 3.11%–22.98% under unused-function insertion, while ACW reaches 0.00% in Python. Under loop, parameter, and return insertion, SEW shows larger reductions than SrcMarker and RoSeMary. The table below reports TPR@FPR5% as the unweighted mean across three backbone models within each language.

LanguageMethodNo attackUnused functionLoopParameterReturn
PythonSrcMarker90.2121.3664.5575.7389.86
RoSeMary97.8622.9896.5697.7197.50
ACW90.100.000.9490.1014.83
SEW99.4922.3926.3318.1121.22
JavaSrcMarker71.5211.9271.1671.6971.72
RoSeMary31.003.1131.0031.0031.00
SEW98.2124.9921.5254.1626.06
C++SrcMarker69.889.3965.1169.7870.04
RoSeMary81.2611.5780.1581.2681.26
SEW98.4216.0615.6456.0114.47
AuthorsOpenReview ↗

Response to Reviewer bo59[2/6]

W2. Another concern is that the probability distribution resulting from a majority vote across multiple locations is not necessarily identical to the style probability distribution for a single location. In addition, ablation study did not consider the contributions of program context, structural markers, and key-based style assignment.

Q2. This paper apply majority voting to code locations within the same Grade, and then perform statistical tests using style probabilities estimated from human-written code. However, I am not entirely clear on how these probabilities are determined. After majority voting is applied across multiple locations, the resulting probability distribution is not necessarily the same as that of an individual location. In addition, different grades may not necessarily independent of one another.

Q3. Please provide an more ablation that isolates the specific contributions of the application context and structural identifiers, which could explain why it is necessary to use the Secret Key, siteID, and application context in combination?

Response to W2 / Q2 / Q3

Thank you for raising these concerns. Our additional analyses show that replacing single-location style probabilities with grade-level majority probabilities leaves the reported FPR and TPR@FPR5% unchanged, while component ablations show complementary contributions from the secret key, program context, and structural markers in siteID. We also evaluate empirical false positives under potential grade dependence. We report these analyses in Appendices D and G of the revised manuscript.

[Null Probabilities and Majority Voting]

We estimated qrq_r from the frequency of variant 1 at eligible sites for rule rr in human-written LeetCode solutions (Section 3.1). We clipped the estimates to [0.05,0.95][0.05,0.95] and assigned qr=0.5q_r=0.5 to rules with fewer than 30 observations or unstable estimates. The detector uses πg=qr\pi_g=q_r when the target tg=1t_g=1 and πg=1−qr\pi_g=1-q_r otherwise. This approximates the majority-vote probability, which need not equal the probability at an individual site. Our analysis shows that 66.5%–67.0% of grades contain one site, while 93.5%–94.5% of multi-site grades are unanimous. The grade-count-weighted mean absolute difference between observed majority frequencies and qrq_r is 0.030–0.042 for multi-site bins with at least 30 grades. We additionally evaluate majority probabilities estimated directly from human-code grade outcomes, separately by rule and grade-size bin (2, 3, 4, or at least 5 sites), using Laplace smoothing (k+1)/(n+2)(k+1)/(n+2), where kk of nn grades have majority variant 1. Ties count as variant 1, estimates are clipped to [0.05,0.95][0.05,0.95], and single-site or sparse bins retain qrq_r. Across all nine settings, human-code FPR and TPR@FPR5% remain unchanged, while AUROC changes by at most 0.02 points on the 0–100 scale. Table W2-1 reports grade statistics, while Table W2-2 compares current and alternative calibration. In Table W2-2, each arrow indicates current →\rightarrow alternative calibration, and AUROC diff. denotes the absolute difference on the 0–100 scale.

[Table W2-1. Grade Statistics of Human-Written Code]

LanguageSingle-site (%)Unanimous (%)Prob. diff.
Python66.794.30.042
Java67.094.50.032
C++66.593.50.030

[Table W2-2. Current and Alternative Calibration]

LanguageModelFPR (%) ↓\downarrowT@5 ↑\uparrowAUROC diff.
PythonQwen3.51.43→1.431.43 \rightarrow 1.43100.00→100.00100.00 \rightarrow 100.000.00
gemma-42.37→2.372.37 \rightarrow 2.37100.00→100.00100.00 \rightarrow 100.000.00
gpt-oss2.04→2.042.04 \rightarrow 2.0498.47→98.4798.47 \rightarrow 98.470.00
JavaQwen3.50.00→0.000.00 \rightarrow 0.0096.60→96.6096.60 \rightarrow 96.60≤0.02\leq 0.02
gemma-40.00→0.000.00 \rightarrow 0.00100.00→100.00100.00 \rightarrow 100.00≤0.02\leq 0.02
gpt-oss0.00→0.000.00 \rightarrow 0.0098.04→98.0498.04 \rightarrow 98.04≤0.02\leq 0.02
C++Qwen3.50.00→0.000.00 \rightarrow 0.0098.00→98.0098.00 \rightarrow 98.00≤0.01\leq 0.01
gemma-40.51→0.510.51 \rightarrow 0.5198.98→98.9898.98 \rightarrow 98.98≤0.01\leq 0.01
gpt-oss0.43→0.430.43 \rightarrow 0.4398.28→98.2898.28 \rightarrow 98.28≤0.01\leq 0.01
AuthorsOpenReview ↗

Response to Reviewer bo59[3/6]

[Grade dependence]

Grades within the same program can share style preferences, so independence is a modeling approximation. We additionally evaluate empirical FPR on intact, unwatermarked CodeContests human reference programs using 200 random keys, preserving within-program dependencies. At α=0.01\alpha=0.01, the mean FPR is 0.91% for Python (198 programs), 0.89% for Java (213), and 0.35% for C++ (237), all below the nominal 1% level. The fixed-key Python FPRs in the calibration table correspond to only 2–4 false positives per setting, making them sensitive to individual cases. These results support empirical false-positive control on average across the evaluated programs and keys, without establishing grade independence or guaranteeing control for every fixed key.

[Component ablations]

We additionally evaluate variants that separately remove the secret key, program context χ(C)\chi(C), or structural markers from siteID across all nine settings. All variants retain the same transformation rules and applicability checks, and pass@1 matches Vanilla. Removing the secret key increases mean human-code FPR to 7.43% in Python and 15.45% in Java. Removing χ(C)\chi(C) increases mean rule-inference accuracy at N=100N=100 from 24.03%–45.17% to 94.47%–96.56%, indicating greater transferability of observed decisions across programs. Removing structural markers reduces mean TPR@FPR5% under 50% style flipping from 81.52%–94.91% to 75.02%–79.87%. These results support combining all three components: the secret key prevents direct target computation, program context limits cross-program decision transfer, and structural markers improve robustness under partial style flipping. The table reports unweighted means across three backbone models within each language. Human-code FPR uses α=0.01\alpha=0.01, Atk. averages T@5 over four non-LLM editing attacks, Flip 50/75 denotes 50%/75% style flipping, and inference accuracy is measured at N=100N=100 with unseen decisions counted as errors.

[Table W2-3. Component Ablation Results]

LanguageConfigurationT@5 ↑\uparrowFPR (%) ↓\downarrowAtk. ↑\uparrowFlip 50 ↑\uparrowFlip 75 ↑\uparrowInference acc. ↓\downarrow
Pythonw/o key99.497.4398.7499.2998.9544.54
w/o χ(C)\chi(C)100.000.0099.3392.9165.8195.44
w/o structural markers99.760.6094.3375.8450.4952.39
SEW99.491.9599.0093.6364.8145.17
Javaw/o key98.7015.4597.4796.9792.8223.47
w/o χ(C)\chi(C)98.700.5298.6696.1869.3396.56
w/o structural markers93.850.3993.0379.8756.3631.26
SEW98.210.0097.9594.9170.5224.57
C++w/o key99.560.1799.3499.3998.6518.80
w/o χ(C)\chi(C)99.220.3197.6995.8077.4794.47
w/o structural markers99.560.0095.7475.0242.6627.75
SEW98.420.3196.3881.5252.3224.03
Reviewer_s4nuOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposed a style-encoded watermarking framework SEW for LM-generated code. It decides code variants using a secret key and the structural context. SEW contains two additional components: “calibration” evaluates watermark evidence; “aggregation” prevents inflating evidence. The evaluations are conducted with 3 LMs and 3 programming languages.

Critical strengths
  • The proposed approach is simple and impressive, and the experimental results appear to be better than those of prior work.
  • This paper show some insights, for example, the repeated style choices may harm the watermarking evidence. The calibration and aggregation are posed for that. They are not only patches to SEW, but also works for any style-based watermarking techniques, which can suffer from the same issues.
Critical weaknesses
  • Robustness to changes in program structure seems a practical concern. The secret key depends on the global counts of functions, loops, and returns, while semantic preserving insertion may change the counts. I am not sure whether it is the limitation of SEW or general style-based methods. What happens if an attack adds one unused function (dead code) or alters the global counts? Or can the authors propose some refinements to reduce the sensitivity to the context?
Questions for authors

What happens if an attack adds one unused function (dead code) or alters the global counts? Or can the authors propose some refinements to reduce the sensitivity to the context?

3 comments
AuthorsOpenReview ↗

Response to Reviewer s4nu

W1. Robustness to changes in program structure seems a practical concern. The secret key depends on the global counts of functions, loops, and returns, while semantic preserving insertion may change the counts. I am not sure whether it is the limitation of SEW or general style-based methods. What happens if an attack adds one unused function (dead code) or alters the global counts? Or can the authors propose some refinements to reduce the sensitivity to the context?

Q1. What happens if an attack adds one unused function (dead code) or alters the global counts? Or can the authors propose some refinements to reduce the sensitivity to the context?

Response to W1 / Q1

Thank you for raising this concern. Our additional experiments confirm SEW's sensitivity to structural insertions and show that other evaluated style-based watermarking methods are also vulnerable to unused-function (dead-code) insertion. We propose consistent static-analysis preprocessing during embedding and detection to reduce this sensitivity. We report the structural insertion results in Appendix H of the revised manuscript.

[Structural Insertion Attacks]

We additionally evaluate four behavior-preserving insertions: an unused function containing return 0, a zero-iteration loop, an unused parameter with updated call sites, and a return statement in an unreachable branch. Unused-function insertion reduces SEW's mean TPR@FPR5% by 74.6%–83.7% relative to no attack. SrcMarker and RoSeMary also fall to 3.11%–22.98%, while ACW reaches 0.00% in Python. Under loop, parameter, and return insertion, SEW shows larger reductions than SrcMarker and RoSeMary. The table below reports TPR@FPR5% as the unweighted mean across three backbone models within each language.

LanguageMethodNo attackUnused functionLoopParameterReturn
PythonSrcMarker90.2121.3664.5575.7389.86
RoSeMary97.8622.9896.5697.7197.50
ACW90.100.000.9490.1014.83
SEW99.4922.3926.3318.1121.22
JavaSrcMarker71.5211.9271.1671.6971.72
RoSeMary31.003.1131.0031.0031.00
SEW98.2124.9921.5254.1626.06
C++SrcMarker69.889.3965.1169.7870.04
RoSeMary81.2611.5780.1581.2681.26
SEW98.4216.0615.6456.0114.47

[Proposed Refinement]

We propose consistent static-analysis preprocessing during embedding and detection to identify unused or unreachable constructs before computing χ(C)\chi(C). Tools such as Vulture in Python can help identify such constructs, while value-flow and side-effect checks can restrict their exclusion from structural counts to behavior-preserving cases. This preprocessing is intended to keep χ(C)\chi(C) consistent across embedding and detection when structural insertions can be safely excluded, thereby reducing mismatches in reconstructed watermark targets.

AuthorsOpenReview ↗

Additional Experiments for Reviewer s4nu (W1 / Q1): Updated with Java and C++ Results

Thank you again for suggesting that we examine refinements to reduce SEW's sensitivity to structural changes. Following our response to W1 / Q1, we implement and evaluate the proposed static-analysis preprocessing against four structural insertion attacks in Python and extend this evaluation to Java and C++. The results show that this preprocessing reduces SEW's sensitivity to the evaluated structural changes across all three languages, without changing its watermark assignment mechanism or reducing pass@1. Across the four attacks, the unweighted mean TPR@FPR5% over the three backbone models ranges from 99.06% to 99.49% in Python, from 98.38% to 98.70% in Java, and from 95.07% to 99.22% in C++. These additional results are reported in Appendix H of the revised manuscript.

For Python, we use Ruff to identify unused variables and parameters, and Vulture to identify unused functions and unreachable code, supplemented by a simple rule for zero-iteration loops with statically empty iterables, such as range(0) or empty literals. For Java, we use PMD to identify unused methods, parameters, and constant-condition branches, supplemented by simple rules for zero-iteration loops and methods without references elsewhere in the file. For C++, we use clang-tidy to identify unused static functions and parameters, supplemented by simple rules for zero-iteration loops and unreachable branches. During both embedding and detection, we exclude the identified constructs from the structural counts used to compute χ(C)\chi(C), without modifying the executable code. The tables below report model-specific TPR@FPR5% / AUROC / pass@1, including no-attack results with preprocessing.

[Table 1. Python]

ModelNo attackUnused functionLoopParameterReturn
Qwen3.5-9B100.00 / 100.00 / 41.43100.00 / 100.00 / 41.43100.00 / 100.00 / 41.43100.00 / 99.98 / 41.4399.29 / 99.52 / 41.43
gemma-4-12B-it100.00 / 100.00 / 87.5799.41 / 99.58 / 87.57100.00 / 100.00 / 87.5799.41 / 99.77 / 87.5799.41 / 99.58 / 87.57
gpt-oss-20b98.47 / 98.93 / 43.8898.47 / 98.93 / 43.8898.47 / 98.93 / 43.8898.47 / 98.93 / 43.8898.47 / 98.93 / 43.88

[Table 2. Java]

ModelNo attackUnused functionLoopParameterReturn
Qwen3.5-9B96.60 / 97.39 / 36.0595.92 / 97.35 / 36.0596.60 / 97.38 / 36.0596.60 / 97.39 / 36.0596.60 / 97.40 / 36.05
gemma-4-12B-it100.00 / 100.00 / 78.92100.00 / 100.00 / 78.92100.00 / 99.95 / 78.92100.00 / 100.00 / 78.92100.00 / 100.00 / 78.92
gpt-oss-20b99.51 / 99.63 / 41.1899.51 / 99.63 / 41.1899.51 / 99.62 / 41.1899.02 / 99.58 / 41.1898.53 / 99.02 / 41.18

[Table 3. C++]

ModelNo attackUnused functionLoopParameterReturn
Qwen3.5-9B98.67 / 98.95 / 36.6789.33 / 94.04 / 36.6798.00 / 98.87 / 36.6798.67 / 98.95 / 36.6798.00 / 98.91 / 36.67
gemma-4-12B-it98.98 / 99.20 / 81.6398.47 / 99.07 / 81.6398.47 / 99.04 / 81.6398.98 / 99.20 / 81.6398.98 / 99.18 / 81.63
gpt-oss-20b100.00 / 99.98 / 42.9297.42 / 99.17 / 42.92100.00 / 99.84 / 42.92100.00 / 99.98 / 42.92100.00 / 99.94 / 42.92
AuthorsOpenReview ↗

Revision Summary for Reviewer s4nu

We have uploaded the revised manuscript, with changes highlighted in blue. We evaluate changes in program structure and global counts, compare SEW with other style-based methods, and test a simple static-analysis refinement in Python to reduce the sensitivity to the context (Appendix H). We welcome further discussion and are committed to addressing any remaining questions during the discussion period.

Reviewer_vmV8OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes SEW, which embeds and detects watermarks in AI-generated code through code style rules, style-preference calibration, and context-aware style aggregation.

The work involves some new designs and the written is easy to follow.

In general, I consider that the paper shows some defects and is not enough to be published at ICLR. I will give detailed reviews as follows.

Critical strengths

(1) The authors propose a new strategy for code watermarking, i.e., through code styles.

(2) The proposed SEW is training-free with wide adaptability, and the code style is ontext-aware rather than fixed.

(3) The paper is easy to follow.

Critical weaknesses

My main concern regarding the work is whether the experiments are fair, as follows.

(1) In table 3, the baselines, like STONE, show poor performance. I doubt the implementation of the baselines, whether the results were obtained under unfair settings.

(2) In table 3, some result values like 40.00 and 43.37 appear repeatedly in different baselines, more explanation is required on how such results were obtained.

(3) In addition, Figure 2 shows strong AI smells.

Questions for authors

Please kindly answer the questions in the above weaknesses (1) - (3).

2 comments
AuthorsOpenReview ↗

Response to Reviewer vmV8

W1. In table 3, the baselines, like STONE, show poor performance. I doubt the implementation of the baselines, whether the results were obtained under unfair settings.

Response to W1

The baselines in Table 3 were implemented using their released code or documented procedures and evaluated under consistent conditions, without adjustments intended to favor SEW. We include the corresponding implementation details in Appendix A of the revised manuscript.

[Baseline Implementations and Evaluation Settings]

We used the authors' implementations of KGW, SWEET, Unigram, STONE, STA-1, SrcMarker, and ACW. RoSeMary was reimplemented following its paper and trained for 20 epochs, as detailed in Appendix A. Token-level baselines retained their recommended hyperparameters. All methods used the same problems within each model-language setting, the same CodeContests prompts, three backbone models, and a maximum generation budget of 8,192 tokens. Post-hoc methods operated on identical Vanilla outputs, and all detectors followed the same evaluation procedure for TPR@FPR5% and AUROC, as described in Sections 4.1–4.2 and Appendices A–B.

[Pre-hoc and Post-hoc Watermarking]

Pre-hoc methods influence token selection during generation, where code syntax and functional requirements constrain available token choices and can limit watermark evidence. Post-hoc methods instead embed watermarks through transformations of completed code. This methodological difference provides a possible explanation for the performance variation in Table 3. Under the shared evaluation conditions, SEW achieved the highest TPR@FPR5% across all nine settings (96.60%–100.00%), while maintaining the same pass@1 as Vanilla.

W2. In table 3, some result values like 40.00 and 43.37 appear repeatedly in different baselines, more explanation is required on how such results were obtained.

Response to W2

The repeated pass@1 values of 40.00% and 43.37% in Table 3 are not errors. They result from different methods producing identical numbers of passing problems. We include the corresponding analysis of repeated pass@1 values in Section 5.1 of the revised manuscript.

SrcMarker, RoSeMary, and ACW were applied to the same Vanilla outputs and evaluated on the same problems, as described in Appendices A and B. For Qwen3.5 Python, Vanilla passed 58 of 140 problems, and each method introduced two failures, leaving 56 passing problems (40.00%). For gpt-oss Python, Vanilla passed 86 of 196 problems, and each method introduced one failure, leaving 85 passing problems (43.37%). SrcMarker and RoSeMary share syntactic transformation code and failed on the same problems, whereas ACW failed on different problems despite producing identical passing counts. The table below lists the problems that passed Vanilla but failed after watermarking.

ModelSrcMarkerRoSeMaryACW
Qwen3.5test/17, test/48test/17, test/48test/14, valid/71
gpt-osstest/48test/48valid/79

W3. In addition, Figure 2 shows strong AI smells.

Response to W3

We designed and drew Figure 2 ourselves, using AI assistance only to replace the small icons representing code styles. We acknowledge that “Style Rale” in the first panel was a typographical error and corrected it to “Style Rule” in the revised manuscript. We apologize for this oversight and appreciate the reviewer bringing it to our attention.

AuthorsOpenReview ↗

Revision Summary for Reviewer vmV8

We have uploaded the revised manuscript, with changes highlighted in blue. We clarify the implementation of the baselines and evaluation settings (Section 4; Appendix A), explain the result values repeated across different baselines (Section 5.1), and correct the typographical error in Figure 2. We also clarify in our response the scope of AI assistance used for Figure 2. We welcome further discussion and are committed to addressing any remaining questions during the discussion period.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.