Countergrade

One-line pitch

Countergrade helps teachers pressure-test an assignment with GPT-5.6, see whether each learning objective is actually observable, redesign the task around evidence of student reasoning, and run the identical tests again to verify what changed.

Short description

Polished work is not the same thing as visible learning. Countergrade runs three concurrent assignment-design pressure tests—surface compliance, outsourced synthesis, and evidence theater—then maps every stated learning objective to an observable, weak signal, or not observable evidence classification. It produces an editable redesign with process checkpoints, decision receipts, a revised rubric, and an explicit AI-use policy. The redesigned assignment faces the same tests, yielding an honest before/after matrix and a teacher-ready print or Markdown export.

Countergrade is an assignment-design tool, not an AI detector. It never claims to prove authorship or make an assignment “AI-proof.”

Full project description

Inspiration

Teachers are being asked to respond to generative AI with tools that often focus on detecting a student after submission. That framing misses an earlier and more actionable question: does the assignment itself produce evidence of the thinking it claims to assess?

Countergrade moves the intervention upstream. It is built for a secondary-school humanities teacher preparing a take-home essay and treats that assignment as something the teacher can test, inspect, and improve before students begin. The seeded demonstration uses a 10th-grade French Revolution essay so the full need is concrete rather than generic.

What it does

A teacher enters an assignment’s instructions, learning objectives, rubric, and permitted-AI policy. Countergrade then follows one complete, inspectable flow:

1. Three GPT-5.6 pressure-test lanes run concurrently:
   • Surface compliance: can polished form stand in for the intended thinking?
   • Outsourced synthesis: can AI perform the integration the student is meant to practice?
   • Evidence theater: can citations look credible without real evaluation?
2. A separate evidence verifier classifies each original objective as observable, weak signal, or not observable, with assignment evidence and a rationale.
3. GPT-5.6 proposes a teacher-editable redesign that preserves the objectives while adding observable decision points: source selection and rejection, claim receipts, accepted and rejected AI suggestions, counterfactual transfer, process checkpoints, a revised rubric, and a clear AI-use policy.
4. After the teacher edits the package, Countergrade runs the same three pressure tests and the same objective-verification method on the redesign.
5. A before/after matrix shows what improved and what risks remain. The teacher can print a clean pack or export Markdown for an LMS.

The public sample is deliberately labeled “Labeled sample snapshot · no API call.” Deterministic fixture output is also labeled as such. Live stages are identified by server-validated model receipts, so the interface never passes curated output off as a live generation.

How it was built

Countergrade is a strict TypeScript application built with Next.js App Router, React, Tailwind CSS, Zod, the OpenAI JavaScript SDK, and optional Supabase persistence.

The server calls the OpenAI Responses API with the model explicitly set to gpt-5.6-sol. Each model stage uses a strict Zod-backed structured-output schema. The three attack lanes execute concurrently with low reasoning effort; the objective verifier and redesign stages use medium reasoning effort. Requests use store: false, a server-derived pseudonymous safety identifier, bounded timeouts and retries, and per-subject plus process-global spend guards. The OpenAI API key is server-only.

The orchestration layer streams semantic NDJSON progress events to the browser. If one lane fails, successful lanes remain intact, only absent lanes regenerate, and the verifier reruns over the merged lane set. Optional Supabase anonymous sessions use row-level security so each browser session can access only its own runs; no service-role key is required by the app.

The product is installable as a PWA, includes an offline fallback and reduced-motion/keyboard support, and generates print and Markdown teacher packs. Unit, component, API, orchestration, export, browser, and conditional live integration tests cover the golden flow and its failure modes.

How Codex accelerated the build

Codex was the primary engineering collaborator for the build. It converted the product brief into typed domain schemas and a state machine; implemented the Responses API provider, concurrent orchestration, retry semantics, RLS persistence, exports, and the editorial interface; and then exercised the product through unit tests, Playwright, responsive browser inspection, and accessibility-focused QA.

The useful acceleration was not just code generation. Codex kept the product claim honest as the implementation evolved: it separated sample, fixture, and live states; preserved evidence when model calls partially fail; exposed model receipts; verified mobile overflow and keyboard behavior; and produced the deployment, testing, and submission handoff in the same primary session. The final submission must include the Session ID returned by /feedback for that primary task.

How GPT-5.6 is used meaningfully

GPT-5.6 performs the core reasoning work, rather than decorating a conventional form:

• It generates three distinct, evidence-cited attacks against the submitted assignment.
• It verifies each objective against exact assignment evidence using a constrained classification schema.
• It synthesizes those gaps into an implementable, editable redesign.
• It analyzes the redesign with the identical method so change—including no change or regression—is compared rather than assumed.

The UI displays validated results and receipts; it does not expose unvalidated free-form model text.

Challenges

• Preserving partial value when one of several concurrent model calls fails.
• Making “observable learning” concrete enough for a structured verifier without implying authorship detection.
• Keeping the original normalized, submitted objective wording exact through redesign and verification.
• Showing a compelling credential-free public sample while labeling it unambiguously as curated rather than live.
• Fitting a deep analytical workflow into an interface a teacher can understand quickly and still edit before export.

Accomplishments

• One coherent teacher workflow from assignment input to a verified, exportable redesign.
• Concurrent pressure tests with per-lane progress, partial-failure preservation, and targeted retry.
• Objective-level evidence classifications before and after redesign.
• An editable redesign package that focuses on process evidence and teacher judgment.
• Transparent sample, fixture, and live-result provenance.
• Server-only model credentials, privacy-preserving safety identifiers, and owner-scoped optional persistence.

What we learned

The strongest response to AI-assisted schoolwork is not a stronger detector. It is better assessment design: asking students to expose consequential choices, revisions, transfers, and evidence judgments that a teacher can sample. AI can help teachers locate those design gaps, but the output still needs explicit evidence, a constrained schema, and room for teacher editing.

What’s next

• Classroom pilots across humanities and non-essay assignments.
• Teacher-authored pressure-test templates by discipline.
• Shared department libraries of redesign mechanisms and rubrics.
• Longitudinal feedback on which observable checkpoints are useful without increasing grading load.
• Accessibility and localization review with educators and students.

Built with

Next.js · React · TypeScript · Tailwind CSS · OpenAI Responses API · gpt-5.6-sol · Zod · Supabase · PostgreSQL RLS · Vitest · Playwright · Vercel · Codex

Responsible-use and privacy statement

Countergrade evaluates assignment design, not students. It does not infer whether a student used AI, assign misconduct probabilities, process student submissions, or claim any task is AI-proof. Teachers remain responsible for reviewing and adapting generated materials.

The live model key stays on the server. OpenAI requests are sent with store: false. In production, the server derives a pseudonymous safety identifier from the validated anonymous subject; it contains no email address or student identity. If Supabase is configured, anonymous authentication plus row-level security isolates saved runs by owner. The public sample and deterministic fixture require no model call and are labeled in the product.

Known limitations

• A redesigned assignment can make reasoning more observable; it cannot prove unaided authorship.
• Generated suggestions may not fit every school policy, accessibility need, discipline, or age group and must be teacher-reviewed.
• Live analysis requires deployment access to gpt-5.6-sol; the labeled sample remains available without credentials.
• Anonymous saved runs are tied to the originating browser session unless a future account system is added.
• The current experience is English-first and optimized for text-rich assignments.

Judging criteria map

The four criteria are weighted equally. In a tie, the published priority order is technical implementation, design, impact, then idea.

Criterion	Judge-facing evidence
Technical implementation	Explicit gpt-5.6-sol Responses API calls; strict structured outputs; three-way concurrency; semantic streaming; phase-correct partial retries; server-only secrets; RLS isolation; automated tests. Codex performed the primary-session implementation and audit work, evidenced by the dated build journal, milestone commits, test history, and required /feedback Session ID.
Design	A focused four-stage rail, visible model/source provenance, objective evidence matrix, editable redesign, responsive editorial visual system, keyboard/reduced-motion/print support.
Impact	Gives a secondary-school humanities teacher an immediate intervention before a take-home essay launches. The seeded 10th-grade French Revolution flow exports an implementable teacher pack instead of only diagnosing a problem.
Idea	Reframes the AI-in-education problem from detecting students to pressure-testing the evidence an assignment elicits, then verifies the redesign with the same method.

Built With

• codex
• gpt-5.6-sol
• next.js
• openai-responses-api
• playwright
• postgresql-rls
• react
• supabase
• tailwind-css
• typescript
• vercel
• vitest
• zod