version: "1.0.1" name: alterlab-syllabus-ai-policy description: "Drafts course-level generative-AI use policies and syllabus statements: assigns each graded task a permitted/restricted/prohibited tier (modeled on Cornell's prohibit/allow-with-attribution/encourage framework), writes the disclosure clause with current APA (2025: cite the shared chat or the tool) and MLA generative-AI citation templates, and adds assessment-integrity, accessibility, and equity language bound to the institution's own academic-integrity code. Ships scripts/policy_builder.py to emit a paste-ready statement and scripts/policy_lint.py to flag a vague or self-contradicting draft. Use when the request mentions a syllabus AI policy, a course statement on ChatGPT or generative AI, an academic-integrity clause for AI tools, an AI-disclosure rule, or per-assignment permitted/prohibited AI tiers. For full course/backward design, syllabus, or rubrics use alterlab-teaching-design; for human-subjects AI-tool ethics use alterlab-research-ethics. Part of the AlterLab Academic Skills suite." license: MIT allowed-tools: Read Write Edit Bash(python:*) WebFetch compatibility: No API key or network required — emits institution-parameterized policy text from local templates via uv run python; WebFetch is used only to read a linked institutional academic-integrity code when the user supplies its URL metadata: skill-author: AlterLab version: "1.1.0" last_updated: "2026-09-23" depends_on: "alterlab-teaching-design (owns full syllabus/backward design; this is the focused AI-policy add-on)"

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:

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.

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 (APA Style blog, September 2025 update) — the author is the AI

company, not the tool. Cite the specific chat when it generated ideas, content, or information: Company. (Year, Month Day). Title of chat [Generative AI chat]. Tool/model. URL-of-shared-chat; cite the tool for general uses such as editing your own writing: OpenAI. (2025). ChatGPT (GPT-5) [Large language model]. https://chatgpt.com/. The chat title and the tool name are italicized. In-text (OpenAI, 2025). (This replaces the 2023 "Mar 14 version" example.)

• MLA 9 (MLA Style Center, revised August 2025) — Works Cited via the

template of core elements, with the tool as the container, not the author, and the model named in the version element: "<Description of prompt>" prompt. ChatGPT, model <model>, OpenAI, <date>, <shareable chat URL>. Use the tool's general URL only when it offers no share link. MLA also asks writers to acknowledge functional uses (editing, translation) in a note.

references/disclosure_and_citation.md carries both templates with examples, 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:

1. Integrity binding — one sentence tying prohibited-tier misuse to the named

institutional code (e.g. "violations are handled under <CODE_REF>"). This is what makes the policy enforceable; leave <CODE_REF> as a fill-in if the user has not supplied it, and say so.

1. 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.

1. 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 as prohibited with a visible "instructor to confirm" note.

• --doc-standard apa|mla|chicago|none selects the citation template block.
• --integrity-code "<ref>" is inserted verbatim; omit it and the output keeps a

<CODE_REF> placeholder plus a warning.

• Omit --out to 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.py pass (no error findings)?

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 and MLA 9 AI-citation

templates as revised in 2025, a Chicago note option, 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 blog, Citing generative AI in APA Style: Part 1 — Reference formats

(September 2025) — cite a specific chat [Generative AI chat] or the tool [Large language model], company as author; supersedes the 2023 How to cite ChatGPT example. apastyle.apa.org (templates cross-checked against the UBC and Oregon State University library guides, 2026-09-23).

• MLA Style Center, *How do I cite generative AI in MLA style? (Updated and

Revised)* (August 2025) — tool as container, model in the version element, shareable chat URL preferred. style.mla.org.

Part of the AlterLab Academic Skills suite.