Blog
An Academic Integrity Policy Template for CS Courses
A clear academic integrity policy tells students exactly what is allowed before they write a line of code. This template gives CS instructors and department heads a starting point they can adapt for assignments, labs, and exams.
Examination Center is in early access — we're onboarding institutions through our Early Access Program. The information here describes our current platform and direction and may evolve; it is not a contractual commitment.
By the Examination Center team · Last updated: 2026-06-18
Why a generic integrity policy fails in CS courses
Most university integrity policies were written for essays, not source code. They warn against plagiarism and contract cheating, but they rarely answer the questions a programming student actually asks: Can I use Stack Overflow? Can I copy a snippet from the course slides? Is an AI coding assistant allowed on homework but not on the exam? When the policy is silent, students fill the gap with their own assumptions, and honest students get caught out alongside dishonest ones.
Computer science also blurs the line between collaboration and copying. Pair programming, study groups, and shared starter code are normal and often encouraged. The same behavior that builds skill on a lab can be a violation on an exam. A good policy names the context, not just the act.
The arrival of capable AI coding tools made this worse. A blanket ban is unrealistic for assignments where the rest of industry uses these tools daily, but unlimited AI use turns a closed-book exam into a typing test. Your policy needs to draw the line per activity, in plain language, and your assessment design needs to make that line real.
What a CS integrity policy should cover
A strong academic integrity policy for computer science is specific about source code, tools, and the difference between learning activities and graded exams. Keep it short enough that students actually read it, and concrete enough that a TA can apply it consistently.
At minimum, cover these areas:
- Scope: which courses, assignments, labs, and exams the policy applies to, and who to ask when something is unclear.
- Allowed help: course materials, documentation, instructor-approved libraries, and the kind of peer discussion you permit (for example, talking through an approach but writing your own code).
- AI tools: state the rule per activity — for example, assistants allowed on homework with disclosure, and not available during exams.
- Attribution: how to cite borrowed code, snippets, or ideas, and what counts as too much borrowing.
- Exams: what a closed environment means in practice — no outside resources, no AI, no messaging, work done in the approved tool only.
- Evidence and process: how suspected violations are reviewed, that a human makes the decision, and how a student can respond.
- Consequences: the range of outcomes and how they escalate for repeat issues.
A reusable policy template you can adapt
The following is a starting template. Replace the bracketed parts with your course specifics and align the consequences section with your university's existing code of conduct so you are layering on top of it, not contradicting it.
1. Purpose. Work you submit in [COURSE] must reflect your own understanding. This policy explains what help is allowed so you can use resources confidently and avoid accidental violations.
2. Homework and labs. You may read documentation and course materials, and discuss general approaches with classmates. You must write and understand your own code. If you adapt more than [a few lines] from any source, including AI tools, cite it in a comment. [AI assistants are / are not] permitted; if permitted, add a short note describing what you used them for.
3. Exams and quizzes. Exams are closed-resource unless stated otherwise. No outside websites, no AI assistants, no autocomplete, no communication with anyone. You must work only in the approved exam environment. Anything not explicitly allowed is not allowed.
4. Attribution. Cite the source of any borrowed snippet, algorithm, or idea in a comment next to the relevant code. When in doubt, cite and ask.
5. Review and fairness. Suspected violations are reviewed by a human instructor using the available evidence. Automated signals are never treated as proof on their own, and you will have a chance to explain before any decision.
6. Consequences. Outcomes follow [University]'s code of conduct and may range from a grade penalty to referral, with escalation for repeat violations.
Make the policy enforceable, especially at exam time
A policy is only as good as your ability to apply it fairly. The hardest line to hold is the exam: you can write "no AI and no outside resources," but on a normal laptop a student can open a second tab or an assistant in seconds, and you have no consistent record of who did what. Honest students then carry the suspicion created by a few.
This is where the assessment environment matters more than the wording. A purpose-built exam tool can make the closed-book rule real instead of aspirational. Examination Center gives every student the same plain editor with no built-in AI assistant and no autocomplete, so the exam tests what the student can do. It runs in the browser, so there is nothing to install on lab machines or personal laptops, and Python runs in-browser while C, C++, Fortran, and Java compile and run in a secure server sandbox.
Critically for a fair policy, the platform supports human judgment rather than replacing it. Instructors watch sessions live, and integrity signals — paste events, large or sudden edits, and cross-student code similarity — are surfaced as evidence for human review, never automated accusations or verdicts. That fits the "a human decides" clause in your template, and it gives you something concrete to discuss with a student rather than a hunch.
Autosave and session recovery back up the fairness promise from the other direction: a frozen or closed browser does not cost a student their work, which removes a common source of disputes during a graded exam.
Roll it out so students actually follow it
Publishing the policy is the easy part. Adoption comes from repetition and from removing ambiguity before the high-stakes moment, not during it.
A few practical steps that help:
- Put the policy in the syllabus and restate the exam rules on the first page of every exam.
- Run a low-stakes practice exam in the same environment so students know exactly what the closed setting looks and feels like.
- Give TAs a one-page rubric for handling integrity signals consistently across sections.
- Keep exportable records of sessions and evidence so any review is grounded in what actually happened.
- Revisit the AI clause each term — the tools change fast, and your policy should keep pace.
Related reading
Examination Center vs autograders · Python lab exams · Coding exam and academic integrity glossary · Security and data handling
Run fair coding exams
Early Access scope: up to 40 students and 1 exam. Indicative pricing only — see pricing or apply for Early Access.
FAQ
How should an academic integrity policy for computer science handle AI coding tools?
Set the rule per activity rather than banning AI everywhere. Many CS courses allow AI assistants on homework with disclosure, since the rest of the field uses them, while keeping exams closed to AI entirely. The key is to make the exam rule enforceable — an exam environment with no built-in AI assistant and no autocomplete makes a closed-book policy real instead of just stated.
Should the policy treat code similarity as proof of cheating?
No. Code similarity is useful evidence, but two students can independently arrive at similar solutions to a constrained problem. Treat similarity, paste events, and sudden large edits as signals for a human instructor to review, give the student a chance to explain, and let a person make the final judgment. Examination Center is built around this distinction: it surfaces integrity evidence and never issues automated verdicts.
Does a CS integrity policy need a separate exam section?
Yes. Collaboration and outside resources that are fine on labs are usually violations on exams, so the contexts need separate rules. State plainly that exams are closed-resource, that anything not explicitly allowed is not allowed, and that work must happen only in the approved environment.
Is this policy template a substitute for our university's code of conduct?
No. It is a course-level layer that sits on top of your institution's existing code. Align the consequences section with the official process and referral path so the two never conflict, and point students to the university policy for formal definitions and appeals.