1. What exactly is the problem
During rounds, a specific pattern has appeared: a participant gets ready-made code from an LLM and simply submits it, almost without understanding it. This is not always caught by plagiarism: a person can rename variables, swap some parts of the code.
2. The idea
Xeppelin — an open-source tool, originally made for ICPC, which:
- is launched locally before the contest
- logs file changes in the working directory
- stores a development timeline (when and how the code changed)
- does not record the screen, keyboard, network, or tabs
- after the contest builds a visualization of activity
This is not my tool, but you can find it here
3. What exactly is proposed for Codeforces (implementation, not an idea)
The proposal is to use Xeppelin as an external source of behavioral data, without interfering with CF infrastructure. Workflow:
The participant launches Xeppelin before the round
Solves problems as usual (locally, in an IDE)
After the round Xeppelin produces:
- a file changes log
- an activity timeline
This log can be automatically linked with CF submissions (by contestId + handle)
CF at the same time:
- does not change the submission process
- does not receive data in real time
- does not require anything complex and global except installing 1 piece of software and linking it with codeforces.
4. What data is obtained
From Xeppelin, clear and simple metrics are available:
- number of file changes before AC
- sizes of individual changes
- active work time vs idle time
- whether the code was written gradually or “in one chunk”
- whether the same pattern repeats across multiple problems
These are process metadata, not screen content and not user input.
5. Why this works well specifically against cheaters:
A typical pattern of copying or cheating with an LLM-solution:
- long idle period
- one large file update
- almost no edits
- immediate AC
This pattern:
- rarely occurs for people who actually write code
- is clearly visible exactly in the file timeline
- is hard to fake without actually rewriting the solution
6. How this can be used in practice (without bans)
Xeppelin is not proof, but a signal. Realistic use cases:
- additional input for post-contest analysis
- a basis for provisional rating in clearly anomalous cases
- a tool for moderators/authors, not automatic punishment
7. Why this is safe for CF
- no proctoring
- no interference with submissions
- no mandatory installations
- no real-time load
Xeppelin works completely outside, CF receives data after the contest or only upon request.
8. Limitation and compromise solution
Limitation
An obvious downside of this approach is that it is impossible and unnecessary to cover 100% of participants. Some people will not be able or willing to use an external logger (devices, installation policy, personal reasons).
Trying to make such software mandatory for all rated rounds is indeed too strict and may harm Codeforces accessibility.
Compromise solution (without changing the core CF system)
Instead, the following option is proposed:
- The rating remains the same as now
- Each result gets a status:
Verified — if the participant attached an activity log (Xeppelin)
- Unverified — normal participation, without logs
This is not a separate rating and not a “second league”
- This is an additional layer of trust, similar in spirit to unofficial standings or verified badges
In practice, this gives:
- the ability to filter the leaderboard by Verified
- priority of trust for verified results
- fewer provisional checks for verified participants
At the same time:
- nobody loses access to rating
- the contest format does not break
- honest participants get a clear incentive to confirm the process
9. TL;DR
There is already an existing tool (Xeppelin) that logs the development process without surveillance. It can be directly linked to CF rounds and used as an additional signal against LLM-solution copy-paste — without bans and without breaking the platform.
Auto comment: topic has been translated by soullless (original revision, translated revision, compare)
Calling Xeppelin "made for ICPC" is misleading. It was made for ICPC, but as a tool for analyzing performance in virtual contests by a single team. It was not made for invigilation purposes and it's not affiliated with the ICPC.
As said here, Xeppelin requires a very specific work flow. I do not think it is suitable for codeforces.
I mean we could use some tools like xeppelin to recover the actions and behavior
You can just ask AI to edit the logs to make them seem legit
More like, it's extremely easy to rig the logs. Just yap gibberish on the .cpp file until GPT gives you the answer.
You can read exactly what part of the code a person is changing, what they're rewriting, and how they're debugging. Of course, you can't tell if a person cheated in just one round, but if suspicious activity accumulates over several rounds, it will become obvious that they did.
Write the logs in encrypted form. (Similar to RSA). They won't be able to modify it meaningfully unless they have quantum computers. I also suggest that the logs should be written no in a straightforwardly structured manner, but in an informal manner. Because structured writing can make it easier to reverse engineer it
Edit the logs before they're encrypted. Possibly even override all inputs of the tool. Reverse engineering ftw.
Non-straightforwardly structured also means harder to parse afterwards — proportionally so.
implementing some system such that logs are always properly timestamped (i.e. cannot be created with an arbitrary timestamp) should solve this (needs another machine/server with a trusted clock). then, at some point of time, assuming you do not have the solution yet (your llm is still thinking), a sufficiently advanced system will be able to recognize that your inputs aren't meaningfully leading you to the solution, even if you reverse engineer the tool and gain some way to create whatever inputs of your choosing.
A sufficiently advanced system will need so much effort to develop you're better off racing Musk to Mars.
humans are a sufficiently advanced system :)
for example, if we made the logs public or public to people with a rating > x (definitely compromises some privacy though), then motivated contestants would have a much easier time spotting cheaters.
Humans are also not on the catching cheaters side any more than the cheating side. The current situation is proof of that. Your idea is like saying that a sum of n bits is close to n or that in a tug of war, the rope will quickly accelerate because there's a lot of people pulling.
I think all of the blogs about cheaters are enough proof that there is at least some motivation for catching cheaters. The purpose of this tool was never to outright find all cheaters, but instead to provide a way to easily check if a given contestant is definitely cheating, which I think is relatively practical to implement compared to the large majority of cf anticheat proposals.
Again it's not if there's at least some motivation but if there's significantly more motivation. I say if there was, all cheaters would be caught near-instantly, it wouldn't be just the occasional blog.
You've had a ton of reasons why it's not practical pointed out. Go do an experiment with catching cheaters your way and report the results if you believe it'll work.
Actually, for non-cheaters, copying a template during a contest should be considered normal behavior.
This problem can be easily solved
Isn't developing a desktop application for Codeforces contests a valid option? Enforcing restrictions would be easier.
The desktop application could come with an integrated IDE for coding. If you want to use a template or something similar, the application could remember your own notebook (or those from other users who made them public) and give you access to your templates inside the IDE. Leaving your local environment would be the trade-off, but over time the IDE could support more features for customization.
The idea is something like a Lockdown Browser, but for Codeforces.
It is recommended to refer to LeetCode's online IDE, which allows for real-time monitoring of code status and facilitates inspection by setting breakpoints at points of submission and large-scale modifications
It's pretty good, but maybe it's limited to browser, there are many ways to use local setups to use AI, CLI or smth.
TopCoder did it a while back and their arena is very crap to use.
Also, what if, say, I compete on a mips64-openbsd-musl? Do you have a binary for me?
Idk, in TopCoder case it's hard to say why the arena is what it is, maybe the tech stack available at the time.
I get the point, maybe the only fair option is creating a linux distribution or smth but it gets too forced and even with that, you will be able to use AI.
Maybe the only way is to come up with an optimal way to verify proctoring if you want to get rating change.
yeah, like I compete on aarch64, except on Asahi Linux, except using UV python. Xeppelin wouldn't work whatsoever for me necessarily, especially because Neovim rewrites the whole file by default (:w functionality vs whatever x is or whatever that no one really uses)
Wow
Sounds like far too much data to analyze, there's 30k contestants in most contests nowadays.
I found it might not consider some who writes codes on local editor.
I suggest to do something like this tool, but relying on catching cheaters
it wont catch users who ask AI to get the idea, then implement from scratch on their own
There is no solution for THIS problem, but my idea destroys cheaters who don't even understand solutions
What if they just look at the code and retype it, maybe moving functions / code blocks around?
Sure that would be different from someone solving / implementing legitimately, but telling the difference is difficult if not impossible, especially considering that behaviour would differ from person to person.
In fact, if someone does do it that way, then they will probably also test their retyped "solution" just to know that it's correct, so you can't even rely on them not testing or something like that.
It seems to me that inhuman actions like too little debugging or too few rewrites can accumulate over time, and this will ultimately give such a person too much of a suspicion penalty.
What if a grandmaster writes the contest? What if he comes up with a solution and implements it without errors, but is considered a cheater?
I think that if your idea is approved and they start monitoring this method of cheating, people who were cheating will simply start rewriting the code manually, changing more variables, replacing BFS with DFS and vice versa (not always, of course, but where possible), as well as with other algorithms, test, write their own stress tests, and test. Are you sure you can completely defeat cheating? P.S.: There was a case when a person took first place in a contest, and it was LGM, and he turned out to be a cheater. How do you suggest fighting fairly intelligent cheaters who know a little or maybe a lot about sports programming?
To be honest, I think it will decrease the number of cases when person doesn't even know what is going on in his code, and also cheating will become more uncomfortable
I agree with that, but haven't you considered that those who want to continue stealing will find other ways to do so? For example, they could hire a special person (a booster) or find some other way?
Other ways of cheating weren't such an annoying, and people usually didn't pay attention to this because the small amount of such a cheaters.
That's how it was. And the problem is that it will be. That's why looking at ratings isn't always cool. But for some reason, when I write a comment with a low rating, they just delete my post. Super platform. By the way, it is still impossible to delete an account on this platform. Why is that? Let's all just leave and let the cheaters compete among themselves to see who can better use artificial intelligence in the allotted time. That's it. This will solve all issues related to cheating.
Let's take online chess, for example. One cheater's account was banned, so he created a second one and went back to playing and satisfying his needs. There have also been cases of cheating offline. We can also recall that not so long ago, two participants (from the Chinese team) were found with phones at the IOI. Does anyone like the fact that a cheater at the IOI, for example, may simply not receive a medal because the cheater is smart enough to find a very cunning way to hide their fraudulent activities? It's annoying that there are more cheaters now — yes. But they have always been around, and now it has reached a very large scale. By the way, now it's really possible to level up your skills so much in a year that I think ANYONE can get into the top in any online competition. Someone wrote earlier that they had reached the master level, but if they start constantly writing contests now, their rating will drop by about 500 points (this is not my opinion, because I have never been a master on this platform). Are you still sure that you can combat cheating in this way? P.S.: You probably just wanted to get a lot of likes to try your luck at blogging and possibly earn some money?)
Dude, I don't have any advandage because of my contribution, I just suggested way to solve the huge problem, why are you trying to find negative sides?
I'm not looking for negative aspects. What I wrote, I thought, was obvious to you, that it won't solve the problem, but will only force cheaters to do their dirty deeds in a different way. Or was that not obvious to you?)
I didn't say that it will solve the problem with all cheaters, I mentioned that it will illuminate cheaters who don't even understand the problems and solutions, who just use chatgpt and 0% brain, idk how did you read my post
To be honest, I didn't read your post in its entirety, just skimmed through it. But what's the point of fighting cheaters who don't understand what they're doing? Well, they'll start learning basic algorithms and using more intelligence. And? Will you completely eradicate cheating? What's the point of your post? Let's say your ideas start to catch on, and cheaters start using more complex algorithms in contests. What then?
I do not think there is any possible solution to this way of cheating
There is basically no way to catch this if you can't monitor them physically, just like if you ask your roommate or somebody for help.
My thought that its not solve of problem, but anyway its better than plagiat system, on other side most of people just want to solve contest without headache with this stuff.
For real, but I think this idea cuts off cheaters who don't even understand the ideas
i like how almost every blogpost talking about AI-cheating is written by chatgpt :)
i am not saying it's bad, i just find it funny to imagine that codeforces is just two armies of machines fighting each other.
I think writing posts using chatgpt is pretty nice, because you use less time and provide your idea so that the person will understand easily.
Also, what do you think about that idea?
https://paulgraham.com/writes.html
There is nothing we can do
Perhaps for some authors, English is not their native language, so using AI-assisted response can be better than posting directly in broken English (as with some of my blogs and this comment).
I still have reservations about replies that feel overly "machine-like" from ChatGPT, as they make me feel like I'm communicating with LLMs rather than with people.
It seems that the only way I can distinguish LLM-generated text is by the presence of too many meaningless bullet points. People with stronger English skills, or native speakers, are probably much more likely to notice the traces of AI polishing.
What about someone using two computer — one for getting the AI ready code and other for doing the contest?
person who cheat this way wont"t almost make any errors, will write their code fast, and won't debug for a long time
Sucks for people who don't suck...
That's actually a very cool idea. We can even extend this process further.
We can train AI models to detect cheating based on the development timeline. People write code differently when they understand the solution and when the don't, or even when they understand the solution, but didn't came up with it themselves.
If successful, this could detect cheating with high accuracy. We could drastically reduce cheating, by simple making the process more difficult
People like Dominater069 that use online IDEs (in his case codechef IDE) wouldn't like this.
I guess we can add this for IDE-online also.
How about demanding every participant to open his camera and use AI to detect whether they use LLM?
This is far too intrusive.
Similar to suggestions like "build an online IDE within Codeforces", this is something that could be perhaps considered for things like job interviews or online university exams. Maybe some important online contests. Something big and important.
A Codeforces round is not a Big Important Event. I wouldn't participate under conditions like that, and I don't think many would.
Oh~ I was only joking. Awa.
what i think so far is One practical way to reduce cheating is ethical behavior from LLMs. Since LLMs can detect live Codeforces contests, they could refuse to provide problem-specific solutions during ongoing contests and instead ask users to solve independently. This would not stop all cheating, but it would reduce easy misuse.
This is not something you will be able to get LLM providers to do.
This clearly helps, but it certainly won't the problem, because the solution is:
Simply type the code from LLM manually, without copy-pasting.
It will be obvious that person cheated if he didn't almost debug, didn't change the code and wrote the code fast.
I am sure most of us do it in every A, B problem. And I am certain more skilled people probably don't even debug C and D.
https://mirror.codeforces.com/blog/entry/150074
As a developer of Xeppelin contest watcher, glad to see the tool mentioned — even though the context is unexpected. Several thoughts on the topic:
cheaters gonna cheat anyway but nice thought