Skip to content

AI Engineering

Turning an Assignment Brief Into a To-Do List With AI

4 min read

The core idea behind Tracademic is simple to say and harder to build: take an assignment brief and turn it into a structured to-do list, so a student never has to face a blank page. This post is about what it actually took to get that working reliably, and the caching decision that ended up mattering more than I expected.

The problem with a blank page

Assignment briefs are written for humans, by academics, in prose. They bury the actual deliverables inside paragraphs of context, word counts, marking criteria and formatting instructions. A student opening one of these documents has to do two jobs at once: understand what's being asked, and then plan how to tackle it. Tracademic's job is to do the first part for them, so they can get straight to the second.

That means the AI isn't just summarising the brief. It's extracting a plan: distinct tasks, in a sensible order, from a document that was never structured as a list in the first place.

The first version: free text in, free text out

My first pass just asked the model to read the brief and describe the tasks in prose. It worked in the sense that the output was usually sensible-sounding. It failed in the sense that it was useless as data. I needed a to-do list I could render as checkboxes, store, and let a student tick off — not a paragraph that happened to mention some steps.

The fix was to stop treating the output as free text and start treating it as structured data with a fixed shape: a list of tasks, each with a short title and, where relevant, an implied order. Once I constrained the response to that shape and validated it before saving, the "it looks fine but I can't actually use it" problem mostly went away. The lesson generalises well beyond this one feature: if you need structured data from a model, ask for structure, then verify it landed correctly — don't parse hopefully.

Caching per user, not just per brief

The other lesson was about cost and speed rather than correctness. Brief analysis isn't instant, and it isn't free — every call to the AI costs both time and money. Early on, every visit to a brief's task list triggered a fresh analysis, even if nothing about the brief had changed since the last time that same user looked at it.

The fix was to cache the analysis result per user, keyed off the brief content itself, so a second look at the same brief is a cache hit instead of a second AI call:

function getCacheKey(userId, briefText) {
  return `${userId}:${hash(briefText)}`;
}

async function analyseBrief(userId, briefText) {
  const key = getCacheKey(userId, briefText);
  const cached = await cache.get(key);
  if (cached) return cached;

  const result = await callBriefAnalysis(briefText);
  await cache.set(key, result);
  return result;
}

Keying the cache per user, not just per brief, matters for a subtle reason: two students can paste in briefs that are word-for-word identical (a shared module brief, for instance) but there's no reason one student's cached plan should silently appear for another without going through the same flow. Scoping the cache to the user keeps the behaviour predictable, even though it costs a little in cache-hit rate compared to a fully shared cache.

I made the output a to-do list because it's far more visual and easier to follow than a block of text. It also makes Tracademic more accessible, and it works for a much wider range of students.

What still doesn't work perfectly

Not every brief analyses cleanly. Briefs that mix multiple deliverables into one document, or bury the real task inside an appendix, still sometimes produce a plan that needs manual tidying. I haven't tried to solve that with more prompt engineering alone — the more durable fix is giving students an easy way to edit the generated list rather than chasing a model that gets every edge case right on the first pass. A generated plan that's mostly right and trivially editable beats one that's occasionally perfect and rigid.

I also learned not to over-trust confidence-sounding output. A model can produce a plausible, well-formatted list from a brief it has fundamentally misread. Structured output solves the "unusable" problem; it doesn't solve the "usable but wrong" problem, which is why the feature is built around a student reviewing and adjusting the plan rather than accepting it blindly.

The takeaway

If a model-generated feature needs to be usable as data, force the shape of the output and validate it — don't parse prose. And if that feature is expensive or slow to run, cache by the thing that actually determines the result (here, the brief content) scoped to the user it belongs to, not just the raw input. It's a small decision that quietly keeps a product both cheaper to run and faster to use.

I've written more about the wider build in Building Tracademic — An AI-powered Student SaaS Platform, and about the Firestore security work that sits alongside this feature in Hardening Firestore Write Security in a Solo-Built App.