AlterLab-IEU Syllabus AI-Use Policy Drafter — Per-Course, Per-Assignment GenAI Statements
The focused add-on that turns "what's my AI policy?" into a concrete, paste-ready
syllabus statement. It does one thing well: given a course and its graded
tasks, it assigns each task an explicit permitted / restricted / prohibited
tier, writes the matching disclosure and attribution clause, and binds the whole
statement to the institution's own academic-integrity code — so the policy is
enforceable, not aspirational. It deliberately does not author the rest of
the syllabus, learning outcomes, or rubrics; that is alterlab-teaching-design.
When to Use This Skill
Use it when the request is about the AI-use rules of a course or assignment:
Draft an AI-use policy for my syllabus.
Write a course statement on ChatGPT / generative AI for students.
I need an academic-integrity clause that covers AI tools.
Give me per-assignment rules: where can students use AI, where not?
How should students disclose and cite AI they used in an essay?
Make my AI policy consistent with our university's integrity code.
→ Gather the course context (level, discipline, the list of graded tasks, the
institution's integrity-code reference), assign each task a tier, then run
scripts/policy_builder.py to emit the statement and scripts/policy_lint.py
to catch contradictions before you hand it back.
Does NOT Trigger
This skill is a narrow add-on. Route adjacent asks to the right sibling:
| The ask is really about… | Route to | Why not here |
|---|---|---|
| Designing the whole course / syllabus, learning outcomes, rubrics, lesson plans, backward design | alterlab-teaching-design |
Owns full course/backward design; this skill only writes the AI-policy section |
| Ethics of using an AI tool on human-subjects data (IRB, consent, de-identification) | alterlab-research-ethics |
Research-ethics / IRB territory, not a teaching policy |
| Whether a student submission was AI-generated; running a detector | alterlab-teaching-design (assessment) |
This skill writes policy; it does not adjudicate or detect individual cases |
| Verifying that citations a student or author produced actually exist | alterlab-citation-verifier |
Citation existence-checking, not policy drafting |
| Turkish-system integrity/ethics process (ÜAK, YÖK etik kurul) | alterlab-tr-research-ethics |
Turkey-specific ethics workflow, parameterized differently |
| Institutional accreditation / assurance-of-learning reporting | alterlab-accreditation-aol |
Program-level AoL, not a course AI clause |
If the request mixes "design my course" and "write my AI policy", do the AI
policy here and hand the rest to alterlab-teaching-design.
The Tier Model
Every graded task is assigned exactly one tier. The three-tier shape mirrors the Cornell University faculty-committee framework (prohibit / allow-with-attribution / encourage) — a published, citable model — but the wording is yours and is bound to your institution's integrity code, never invented.
| Tier | Meaning | Student obligation |
|---|---|---|
| Prohibited | No generative-AI use; the task measures a skill AI would substitute for | None permitted; use is an integrity violation under the cited code |
| Restricted | AI permitted for named sub-tasks only (e.g. brainstorming, grammar), not for the assessed deliverable | Disclose what tool was used, for what, and how — see the disclosure clause |
| Permitted | AI use is allowed and may be encouraged (e.g. as a tutor, for accessibility) | Disclose and attribute per the citation template; remain responsible for accuracy |
Default-deny when unstated. If the course gives no tier for a task, the
statement says the task is Prohibited until the instructor decides — never
silently "anything goes". A vague "students may use AI responsibly" line is the
single most common failure and policy_lint.py flags it.
See references/tier_framework.md for the full decision tree (which tier fits
which assessment type), worked per-discipline examples, and the verbatim Cornell
tier definitions this is modeled on.
The Disclosure & Attribution Clause
A tier alone is not a policy. Restricted and Permitted tasks require students to disclose and cite AI use, and the statement must hand them an exact citation format — not "cite it appropriately". Use the documentation standard the course already uses:
- APA 7 — reference-list entry credits the maker, not the tool as author:
OpenAI. (2023). ChatGPT (Mar 14 version) [Large language model]. https://chat.openai.com/chat, with in-text(OpenAI, 2023); reproduce the prompt and output in an appendix or the Methods section. (APA Style, How to cite ChatGPT.) - MLA 9 — Works Cited via the template-of-core-elements, treating the tool as
the container, not the author:
"<prompt>" prompt. ChatGPT, <version>, OpenAI, <date>, <URL>.MLA also requires acknowledging functional uses (editing, translation) in a note. (MLA Style Center, How do I cite generative AI in MLA style?.)
references/disclosure_and_citation.md carries both verbatim templates, a
Chicago-style note option, and a ready-made student "AI-use declaration" block
the statement can append to each submission.
Assessment-Integrity, Accessibility & Equity Language
Three clauses every statement should carry, all parameterized — never asserted as fact about a specific tool:
- Integrity binding — one sentence tying prohibited-tier misuse to the named
institutional code (e.g. "violations are handled under "). This is
what makes the policy enforceable; leave
<CODE_REF>as a fill-in if the user has not supplied it, and say so. - Accessibility / equity — note that some students rely on AI assistive tools and that not all students have paid-tier access, so required AI use should be free-tier-achievable or provided. Do not claim a specific tool is accessible/compliant unless the user supplies that fact.
- No-detector-as-proof — if the user asks the policy to lean on an "AI detector", flag that detector outputs are probabilistic and should not be the sole basis of an integrity finding; the policy states process, it does not adjudicate. (Adjudicating an individual case is out of scope — see the routing table.)
Detail, sample wording, and the equity checklist live in
references/integrity_accessibility.md.
How to Run It
1. Build a statement from course context
uv run python skills/faculty-life/alterlab-syllabus-ai-policy/scripts/policy_builder.py \
--course "PSY 201 Research Methods" --level undergraduate \
--doc-standard apa \
--integrity-code "IEU Student Disciplinary Regulation" \
--task "Literature review essay=restricted:brainstorming and outlining only" \
--task "In-class exam=prohibited" \
--task "Data-analysis report=permitted:as a coding tutor" \
--out ai_policy.md
--task "<name>=<tier>[:<scope/notes>]"— repeatable; tier ∈prohibited|restricted|permitted. A task with no tier is emitted asprohibitedwith a visible "instructor to confirm" note.--doc-standard apa|mla|chicago|noneselects the citation template block.--integrity-code "<ref>"is inserted verbatim; omit it and the output keeps a<CODE_REF>placeholder plus a warning.- Omit
--outto print the Markdown statement to stdout.
The script is stdlib-only (no network, no keys): it fills local templates and never invents an integrity code, a tool capability, or a citation URL.
2. Lint a draft (yours or the generated one)
uv run python skills/faculty-life/alterlab-syllabus-ai-policy/scripts/policy_lint.py ai_policy.md
policy_lint.py flags the common failure modes: a vague catch-all ("use AI
responsibly") with no per-task tier, a Restricted/Permitted tier with no
disclosure clause, a missing or placeholder integrity-code reference, a citation
instruction with no concrete template, and "prohibited" language that
contradicts a "permitted" line for the same task. It exits non-zero on any
error-level finding so it can gate a CI or a pre-handoff check.
3. Read back and hand off
Present the statement, the lint verdict, and every unresolved placeholder
(<CODE_REF>, unconfirmed tool claims). If the user also wants the surrounding
syllabus, outcomes, or a rubric, hand off to alterlab-teaching-design rather
than improvising them here.
Self-Check Before Returning a Policy
- Does every graded task have an explicit tier, with unstated tasks defaulted to Prohibited (not "responsible use")?
- Does every Restricted/Permitted task carry a disclosure clause and a concrete citation template (not "cite appropriately")?
- Is the integrity-code reference real (user-supplied) or a clearly-marked placeholder — never an invented regulation name?
- Did you avoid asserting that a specific tool is accurate, compliant, or accessible unless the user gave you that fact?
- Did
policy_lint.pypass (noerrorfindings)?
References
references/tier_framework.md— the prohibit/restrict/permit decision tree, per-assessment-type guidance, worked examples, and the verbatim Cornell faculty-committee tier definitions this models.references/disclosure_and_citation.md— APA 7, MLA 9, and Chicago AI-citation templates (verbatim), plus a student AI-use declaration block.references/integrity_accessibility.md— integrity-binding wording, accessibility/equity checklist, and the detector-as-evidence caution.
Sources (verified)
- Cornell University, Report of the Committee on Generative Artificial Intelligence in Education — prohibit / allow-with-attribution / encourage course-policy framework. teaching.cornell.edu.
- APA Style, How to cite ChatGPT —
OpenAI. (2023). ChatGPT (… version) [Large language model]. https://chat.openai.com/chat. apastyle.apa.org. - MLA Style Center, How do I cite generative AI in MLA style? — tool-as-container Works Cited template; do not treat the tool as author. style.mla.org.
Part of the AlterLab Academic Skills suite.