Self-assessment prompts

What self-assessment is in Red Stet

An assignment can carry an optional list of self-assessment prompts — short questions the student answers in free-text boxes alongside instructions and the rubric.

Answers save on the submission row, not a side document or comments thread.

Reflections are not scored

Rubric scoring lives on rubricScore. Reflections sit in selfAssessmentResponses and never feed a number.

Want a graded reflection? Build it as its own assignment — a journal entry, a process memo. These prompts are the in-line version.

Adding prompts to an assignment selfAssessmentPrompts

In the New Assignment modal, scroll to Reflection questions. Add prompt per question. Three fields:

• Prompt — the question.
• Required — if on, the student can't switch to submitted until they've written at least one non-whitespace character.
• Remove (×) — drop a prompt.

Editing a prompt changes the question text for everyone, including students who've already answered. Existing responses survive under the new wording.

The Required toggle and the submit gate

On submit, the server checks each required prompt against the saved responses. Any empty or whitespace-only response throws a hard error; the submission stays in in-progress.

The error names the offending prompts — up to two by name, then "+N more". The student fills in the boxes and re-submits.

Teachers and developer accounts bypass the gate — submitting on a student's behalf for testing or recovery is never blocked.

The student-side flow

The Reflection section sits beneath Instructions and Sub-tasks. One textarea per prompt; required prompts carry a small red "required" label.

Students can answer any time — before drafting, mid-draft, right before submit. The reflection lives alongside the writing.

Save reflection calls saveSelfAssessment. A "Saved" tick flashes; responses persist to the submission row.

If there's no submission yet, the mutation creates the row lazily and stamps the responses onto it.

How responses are stored on the submission selfAssessmentResponses

Each entry:

• promptId — stable id on the parent assignment. Survives question-text changes.
• response — the free-text answer.
• submittedAt — server timestamp of the last save.

Saves overwrite the whole array — no per-prompt history. Edit ten times, only the final text is on record.

Keyed by promptId, so reordering prompts doesn't scramble responses. Deleting a prompt orphans its response but doesn't delete it — the data stays on the submission, hidden from the UI.

Where you read the reflections

The grading workspace renders a Reflection block beneath the rubric scorer. Each prompt is a card with the response inline; required prompts carry a badge, blank responses show "No response".

Read-only — only the student writes through submissions.saveSelfAssessment. Full walkthrough in the Grading doc's Reflection block section.

Pedagogical patterns that work

A few prompts pull more honest reflection than others.

Strongest-and-why

"What was your strongest paragraph and why?" Forces a critical re-read and a specific pick. The "why" pushes past "I just liked it."

Change-with-more-time

"What would you change with more time?" Most students know the weak spot. The prompt gives permission to say so without losing points.

Process post-mortem

"Walk me through how you wrote this — where did you start, get stuck, what did you do when you got stuck?" Metacognition about process, not product. Pairs with the recording.

Audience check

"Who is your reader? What did you assume they already know?" Catches writing-for-the-grader.

What to avoid

• "Rate your effort 1-10." Students rate themselves an 8.
• "Did you proofread?" Always "yes."
• "Reflect on your learning." Too abstract — produces summaries with no signal.

Reflection across revision and resubmit

When maxAttempts > 1, the student writes, reflects, gets feedback, and revises with their prior reflection visible — they can see what they called the weak spot and decide whether the revision addressed it.

The same prompt list runs every attempt by default. To ask something different on attempt 2 — usually "what did you change?" — use per-attempt mode (next section).

Different prompts on attempt 1 vs. attempt 2 selfAssessmentPrompts.attempt1 / attempt2

The editor has two tabs: Attempt 1 and Attempt 2 (optional). Leave attempt 2 empty and the student sees the attempt-1 prompts again.

Use case: "what's the strongest paragraph" on attempt 1, "what did you change between drafts" on attempt 2 — craft reflection shifts to revision reflection without a second assignment.

How the shape is stored

selfAssessmentPrompts accepts two shapes:

• Per-attempt object — { attempt1: [...], attempt2?: [...] }. Empty attempt 2 falls back to attempt 1.
• Flat array — backward-compatible. Treated as attempt-1 with no attempt-2 override.

The renderer picks the list from the current attempt. Responses save under promptId, so attempt-1 and attempt-2 reflections coexist on the row.

Reflection as part of the writing record

Responses live on the same submission row that anchors the writing record. Each save carries a server timestamp (submittedAt), so reflections can't be backdated.

Not part of the cryptographic chain like keystrokes — it's a row patch, not a recording event — but server-timestamped and included in the writing-record export.

Reusing prompts across assignments

Three routes:

The kitchen-sink starter template

"All options demo (kitchen sink)" ships with three default prompts (strongest-paragraph, change-with-more-time, struggle-with-most). Pick it from the starter list, then keep, edit, or remove.

Duplicate an existing assignment

Duplicating copies title, instructions, due date, rubric, max-attempts, style preset, and reflection prompts in source shape (flat or per-attempt).

Save your prompts as a personal template

For a prompt set you want across many future assignments, save it as a personal template (next section).

Personal reflection-prompt templates

Two controls below the prompt list: Load from template… and Save as personal template.

Saving snapshots the current list — text, required flags, ordering — under a name only you see. Loading drops a saved set into the editor. Applying a template copies the prompts — editing the template later doesn't change assignments built from it, and vice versa. Past assignments stay frozen.

How per-attempt mode interacts with templates

Templates store a single ordered list. Save and Load operate on the active tab: saving from Attempt 2 snapshots attempt-2; loading into Attempt 1 fills attempt-1. The other tab is untouched. Build attempt-1 and attempt-2 templates separately when needed.

Related

→ Creating an assignment — every section of the New Assignment modal.

→ Grading submissions — the workspace where you score the rubric.

→ Returning work for revision — pairs with reflection in a revision-and-resubmit workflow.

→ Back to the help library.

Got a prompt that consistently pulls great responses? Email feedback — this doc grows from real classroom practice.