Group assignments

Solo vs. Group — the toggle kind

Every assignment is Solo (default) or Group. The toggle sits below Instructions.

Group is for artifacts that have to be one piece — co-authored research report, panel response, collaborative editorial. If students should discuss a shared idea but each submit their own, stay on Solo and use peer review.

Saving a group assignment opens the group manager. A second field — How groups form — offers four modes.

Four ways groups get formed groupFormationMode

After picking Group, the modal shows How groups form:

• Teacher-assigned — build every team by hand. Use for explicit control (mixing ability, splitting friends, pairing mentor/mentee).
• Auto-assign — random — shuffles the roster into groups of N. Use for quick K-8 work.
• Auto-assign — balanced — same shuffle, spreads tagged students evenly (one ESL per group, one honors per group).
• Student-self-form — students see forming groups and unplaced peers, pick or create their own up to a cap. Use for HS/college.

Mode is changeable until the first group fills. After that, switching keeps existing groups until you Auto-assign now, which archives and rebuilds.

Auto-assign — random groupTargetSize

Set target size (default 4). Auto-assign now shuffles into ⌈roster ÷ N⌉ groups named Group 1, Group 2, etc. First student per group becomes lead.

23 students at target 4 → five groups of 4 plus one of 3. No padding. Roster smaller than target → one group with everyone.

Re-running archives the prior round (memberships soft-removed, group docs preserved) and reshuffles. Warn the team first — text in an archived doc stays there, not in the new one.

Auto-assign — balanced by tag groupBalanceTags

Same shuffle as random, but uses enrollment tags to spread cohorts evenly. Type tag names into Balance tags, comma-separated:

• ESL — multilingual learners one-per-group.
• honors — advanced writers spread so no team is stacked.
• IEP, 504 — accommodations distributed.

The algorithm deals tagged cohorts round-robin first, then fills with untagged. Close enough for most class sizes — 3 ESL across 5 groups → 3 groups with one ESL each, 2 without.

Tags are case-insensitive strings matched against the enrollment tags column.

Student-self-form groupFormationLockedAt

Set target size. After publish, students see a Join or start a group chip. Two halves:

• Forming groups list — every active group, member chips, Join / Leave. Capped groups show Full.
• Available students sidebar — not-yet-placed students.

Starting a team: name + Create & join. Creator becomes lead.

Locking formation

Lock formation freezes joins, leaves, and creates. Existing groups keep working. Reversible — unlock when a late student needs to slot in.

Setting up groups after creating

Saving a group assignment opens the Assignment groups manager. Each row is one team.

Type a name in New group — "Team Citrus", "The Eliot Project" — Create. Red Stet inserts a row in assignmentGroups and spins up an empty shared doc owned by you, writable by members.

Names show in the team chip and the shared draft title — keep them short ("Essay 2 — Team Citrus").

No cap on group size. Internal limit: 200 groups per assignment.

Assigning students & picking a lead groupMemberships.role

Each row has an Add member form: email, role, Add. Student must already be enrolled.

Two roles: member (read + write), lead (member + lock + submit). Co-leads allowed.

Lead is optional. No lead → no submit. Re-add as lead to promote, member to demote. Both idempotent.

Removing a member

× on a chip stamps removedAt; the row stays. Past blocks keep their authorship. Their personal submission doc is unaffected; they lose write access to the shared draft.

The shared document assignmentGroups.groupDocId

One shared doc per group, created on Create. Title pre-fills as <assignment title> — <group name>.

Active members write unless locked or submitted. Edits propagate via Convex reactivity. Two students in the same paragraph is last-write-wins — no merge. Tell teams to claim a section before writing in it.

Teachers can always read and edit, including post-submission. Removed members keep read until archive.

Personal drafts and submitting chunks

Opening a group assignment lands the student on their personal draft — a solo submission doc only they and the teacher can read. Scratch space: outlines, paragraphs, pitches. Invisible to teammates until sent.

A header chip reads Submit selection to group: <group name>. Flow:

1. Highlight a passage.
2. Click the chip.
3. Confirm — modal shows text, char count, chain hash.
4. Passage appends to the shared doc as a new block with authorship attached.

Teachers see both: the team's draft and each member's personal draft.

Per-block authorship tracking blockAuthorship

Every paragraph, heading, list, and blockquote has a stable blockId and a blockAuthorship row recording original author, subsequent editors, edit kind, timestamp, char delta.

Five event kinds:

• insert — first appeared (typed fresh or imported from personal draft)
• edit — text changed
• move — reordered
• split — one became two (Enter mid-paragraph)
• merge — two fused

Detection is client-side: a MutationObserver snapshots blocks 1.5s after the last keystroke and diffs. Each event fires recordBlockEdit. Append-only.

Provenance for groups sourceDocId · sourceChainHead

Per-student, not per-group. Each member records on their personal draft. Sending a chunk to the shared doc carries a back-reference — sourceDocId, sourceBlockId, sourceChainHead, provenance length.

Click any block in the shared doc and trace it to the contributor's personal recording — Diego's "Morrison forces the reader…" typed at 2:11 PM, paused, revised, sent at 2:14 PM, including paste warnings, burst-composition flags, rhythm anomalies.

For blocks typed directly into the shared doc, the chain head is captured at the edit moment. The authorship row is the provenance.

Teacher's contribution view

Opening a group submission rolls every block-authorship row into a breakdown. Two tables — Original authorship (contributor, blocks, edits to their blocks) and Editing activity (editor, events, char delta) — plus a per-block trail.

How the math works:

• Edits don't shift attribution. Ben rewording half of Ava's paragraph keeps it Ava's.
• Inserts count for the inserter. Whoever typed it first owns the block, even if a teammate 4× expands it later.

Diagnostic, not grade-binding. A 70/15/15 split tells you who carried the team; you decide whether grades reflect it.

Locking and submitting lockedAt · submittedAt

The lead can lock to freeze edits, and unlock. Teachers can override either way.

Submit is terminal and lead-only. submittedAt stamps, the doc locks, and goes read-only for everyone but the teacher. No un-submit — archive and recreate for a do-over.

Members see state as a banner. Otherwise the chip reads "Draft open — your team can still write."

Grading the group submission

Grade the shared doc like a solo — scored rubric, free-form comment, annotations. The contribution breakdown sits alongside the rubric.

The saved rubric is the team grade — every member scored on the same criteria.

Per-student grade adjustment

When contribution wasn't even, a Per-student adjustment sidecar nudges a member's percent off the team grade:

• Delta — signed percent-points. Positive lifts, negative drops.
• Reason — optional, saved with the adjustment. A delta without one reads as arbitrary.
• Effective grade = clamp(0, team% + delta, 100).
• Team rubric grade is unchanged for other members.
• AGS passback uses each member's effective grade.

Full walkthrough in the Grading doc's Per-student adjustment section.

Group + peer review peerReviews.reviewerGroupId / reviewedGroupId

With groupMode === 'group' and peer review on, the auto-fanout routes between groups, not individuals. Each group reviews N other groups; every member sees the same assigned reviews.

Each peerReviews row carries:

• reviewerGroupId — group doing the review. Reviewer-user fields exist for accountability; the unit is the group.
• reviewedGroupId — group being reviewed. No reviewed-user field — the artifact is the team submission.

Fanout matches solo: reviewers per submission = 2 means every group is read by two others; every group reviews two others. Groups don't review themselves.

Anonymization across groups

Reviewer identity is hidden from the reviewed group by default. setGroupReviewerRevealed flips a per-pair flag, and the reviewed group sees who wrote the feedback.

The reviewer-side notification — "your group's identity has been revealed" — is a follow-up.

Gotchas & limits

• One group per student per assignment. Red Stet picks the first active membership.
• Concurrent same-paragraph edits are last-write-wins. Two members within the 1.5s debounce overwrite each other. Have teams claim sections.
• Block-authorship detection is best-effort. Split/merge uses prefix/suffix heuristics; unusual reorgs may attribute as fresh insert. Clean-insert authorship is always correct.
• Group peer review pairs groups, not individuals. See group + peer review.
• Removed members lose write access; past blocks stay.
• No Solo → Group switch post-creation.

Hit a case this doc doesn't cover? Email feedback.

Related

• Creating an assignment — every section of the New Assignment modal.
• Peer review — when students should read each other's work without co-authoring.
• Grading — rubric and feedback flow.

→ Back to the help library.

Missing something? Email feedback.