The Crisis of Programming and Algorithm Contests in the AI Era

A 2026 list is a warning, not a rate

On August 30, 2026, an X post about the first round of the 2026 Baidu Star programming contest showed a public table of 49 entries labeled cheating and another table labeled violations. The post says the current first batch contains 49 cheating cases and 63 violation cases, compared with 30 people involved in cheating or violations two years earlier. The attached images visibly contain 49 cheating rows and 57 violation rows: rows 1–25 and 32–63 are shown, while rows 26–31 are missing. This is a useful incident signal, not a complete or independently verified dataset. The original post

The visible 106 rows cover 87 schools. The cheating table has 49 rows from 45 schools; the visible violation table has 57 rows from 50 schools. Most schools appear once. The three most frequent schools in the cheating table account for 6 of 49 rows, and the three most frequent in the violation table account for 8 of 57. That looks geographically and institutionally dispersed, not like a small group of schools producing the whole problem.

The table also includes secondary schools, universities, and vocational institutions. A school appearing three times is not a school-level cheating rate: we do not know how many students entered, whether the school organized a common test session, or whether the records describe the same type of violation. The right comparison needs a denominator and a stable definition of “violation.”

The rules are moving from “no ChatGPT” to provenance

Codeforces’ 2024 AI rule drew a practical boundary. Direct translation and small syntax suggestions may be allowed, while asking an AI system to create the algorithm, understand a subproblem, or repair a rejected solution is prohibited. It also describes code similarity and prior public availability as evidence in an investigation. Codeforces AI rule

AtCoder’s recent rule update goes further. It extends the generative-AI rules to AGC, prohibits AI code completion and AI-based language conversion, and restricts deliberate use of AI-generated search overviews. AtCoder’s reason is blunt: a rule that allows code completion is difficult to police because advanced suggestions can cross the intended boundary without a clear user action. AtCoder rule update

That is the first crisis: the old input/output model assumes that the contestant is the only problem-solving agent. In 2026, the system must decide whether it is judging a person, a person plus a toolchain, or a team that includes a remote model. A checkbox saying “I did not use AI” is not an audit trail.

The machine crossed the old baseline years ago

In 2022, Google DeepMind reported that AlphaCode reached roughly the median competitor level on ten recent Codeforces contests that were newer than its training data. The system generated many candidate programs, filtered them by execution, clustered them, and submitted a small set. It did not resemble a student typing one solution from scratch. DeepMind on AlphaCode

AlphaCode 2, described in a 2023 technical report, solved 43% of evaluated problems within ten attempts, compared with 25% for the earlier system, and was estimated to perform better than 85% of participants on average. These are not claims that a model understands every contest problem. They are enough to invalidate the assumption that a strong leaderboard score is automatically evidence of unaided human reasoning. AlphaCode 2 technical report

The benchmark community met a related problem: public tasks can enter training data. LiveCodeBench therefore collects newly released problems from Codeforces, AtCoder, and LeetCode, and evaluates code generation alongside execution, self-repair, and test-output prediction. Its listed release v6 contains 1,055 problems published through April 2025, and its repository documents cases where strong performance on an older benchmark does not transfer to newer tasks. LiveCodeBench repository LiveCodeBench paper

The same weakness appears in education. A student can memorize templates, search old editorials, borrow a library, or prompt an AI agent. These actions are not identical, but they all force the contest to answer a question it used to avoid: is the score measuring algorithm invention, implementation speed, information retrieval, tool orchestration, or some mixture?

Three crises are being confused

Measurement

An online rank is only meaningful when the production conditions are comparable. If one contestant uses a local model, another uses a hosted agent, and a third works alone, a single rank hides unequal resources. If the contest bans all tools but cannot verify the environment, the rule becomes a statement of intent rather than a measurement protocol.

Enforcement

AI-generated code is not a visual species. Style, comments, variable names, and formatting are weak evidence. Code similarity, unusual submission timing, editor telemetry, process logs, and a short oral or written defense can be useful, but each signal has false positives. A detector score should trigger review, not become a verdict by itself.

Educational purpose

Algorithm contests once served as a compact proxy for software ability. That proxy is weaker now because production programming increasingly includes specification, test design, debugging, code review, dependency judgment, and responsible use of tools. A contestant who can explain an invariant, design adversarial tests, and reject a plausible but unsafe model answer may be better prepared than someone who types a fast solution without understanding its proof.

A workable redesign

Contests should separate at least three modes:

Human-only: one controlled device, an explicit list of allowed editor features, reproducible environment logs, post-contest similarity review, and an appeal process. The rule must say whether translation, autocomplete, local documentation, and pre-written templates are allowed.
AI-assisted: disclose the model, version, tools, prompts, generated code, edits, tests, and cost or latency where relevant. Score the final program, the explanation of the algorithm, failure analysis, and the quality of verification.
Learning mode: allow AI after the contest, but require the student to annotate what the model suggested, what was wrong, and how the final solution was proved and tested.

The 2026 trial rules for China’s National College Student Mathematical Modeling Contest explicitly cover large language models, generative AI, code assistants, and AI agents. That broader vocabulary matters: “AI use” is no longer a single chat window. 2026 mathematical modeling AI rules

Codeforces’ recent third-party-code rule also exposes the provenance problem. It distinguishes code published before a round from code generated by a tool that was itself published before the round. That may be reasonable for a template library, but it makes a contest’s definition of “your code” depend on when a tool and its output entered the world. Codeforces third-party code rule

What should survive

The crisis is real, but “competitive programming is over” is too easy a conclusion. The valuable parts are still valuable: reducing a vague statement to a formal model, finding invariants, proving bounds, constructing adversarial tests, and making decisions under time pressure.

What is ending is the idea that a one-shot online leaderboard can answer all questions about a student. The next generation of contests should publish the conditions, record the process, separate human-only from AI-assisted results, and reward explanations that survive hostile testing. The best competitor in the AI era will not merely produce code; they will know when the code is wrong, why it is wrong, and how to prove the correction.