If AI does the work, why does AI education matter?

We are a startup that teaches AI.

We want students to understand how AI works, to build evidence from data, and to use AI on real problems.

But we never wanted to teach any of that through lectures alone.

Students need to use AI themselves — to analyse data, run a model, build something, fail, and fix it.

So we started building an Agentic Tool for students.

Like Claude Code or Codex, it gives an Agent an environment where it can read code, edit files, run tools, and repair its own errors when something breaks.

The goal was not to build one more Coding Agent for developers.

It was to give students learning AI a place where they can actually work with AI.

That was the point.

But the more we built, the more we ran into an uncomfortable question.

If AI does the assignment well on the student's behalf, why teach at all?

"Students should be able to do it themselves" wasn't a good enough answer

Our first instinct was the familiar answer.

"Finishing an assignment and being able to do it yourself are not the same thing."

That's true, of course.

But it wasn't enough.

In real problem-solving, the result is what ends up mattering.

Suppose we hand a student a dataset and say this.

"Analyse this data and find out why customers are churning."

One student types a single line to the Agent.

"Analyse this data and find the cause of churn."

Another student knows far more statistics and data analysis, and gives much more specific instructions.

But what if both got results of the same quality in the same amount of time?

What difference does the second student's extra knowledge actually make?

If it makes no difference at all, the case for teaching that knowledge as a core skill gets weaker.

We needed to admit that.

Once AI can reliably do a task, testing whether a person can still perform that task the old way matters less and less.

So we changed the question.

The purpose of AI education may not be to make humans capable of redoing what AI can already do.

The more important question is this.

Given the same AI, can this person solve harder problems better?

What we want to teach is less "how to beat AI at what AI can do" and more how far you can extend AI's capability into your own problem-solving capacity.

The human role is moving outward, away from execution

Look at recent frontier models and you can see this shift already underway.

In July 2026, Anthropic said it had removed over 80% of Claude Code's system prompt for its newest models, including Claude Opus 5 and Fable 5, with no measurable loss on its coding evaluations.[1]

The long rules and examples accumulated for earlier generations could now conflict with each other, or crowd out the space where a newer model would have made a better call on its own.

The official guide for Fable 5 shows a similar change. Instruction following has improved enough that a short instruction can steer behaviour instead of enumerating each behaviour by name, and the guide recommends revisiting prompts and skills written for earlier models, because overly prescriptive ones can degrade output quality.[2]

The point is not simply that prompts got shorter.

It is that the place where humans improve AI's performance is itself moving.

Using AI well used to be mostly this question.

How do I say this to the AI more precisely?

Now the question is expanding outward.

• What Context do we provide?
• What Tools and execution environment do we give it?
• Inside what feedback loop does it verify and repair its own work?
• How do we connect Agents, Validators, deterministic systems, and people?

Written as shorthand, the surface being designed keeps widening,

Prompt → Context → Harness → Loop → Graph

roughly along those lines.

Recently, the problem of designing dependencies and execution flow among multiple Agents, Tools, Validators, and people has started to be called Graph Engineering. It isn't an industry-standard term yet, but it appeared to describe an orchestration problem that genuinely exists.[3]

None of this means Prompt disappears and Context arrives, or Context disappears and Graph arrives.

Prompts still matter. Context still matters. Harness and Loop don't replace each other either.

A more accurate way to put it is this.

As AI improves, the range humans can design and judge keeps expanding outward.

Rather than controlling execution that AI already does well in ever finer detail, the human leverage point is moving toward designing structures in which AI can reliably do bigger work.

If that's true, shouldn't AI education follow the same move?

Why the same AI produces different results

Give two people the same Agent.

Same model, same tools, comparable time and budget.

Yet one can only delegate simple work reliably, while the other hands over far more complex problems.

One uses whatever the Agent produced; the other finds the important error in it.

One micromanages the Agent and ends up slowing the work down; the other grants high autonomy and intervenes only at the moments that matter.

One produces a result and stops; the other also builds the evaluation system that would catch the result being wrong.

If that difference actually

• raises the success rate,
• raises the quality and reliability of the result,
• reduces catastrophic failures and risk,
• reduces cost and time, and
• makes harder problems solvable,

then whatever produces that difference is a human capability with real value in the age of AI.

That is what we think AI education should be looking for.

Direct execution has to be able to step down from the centre

That gave us an important principle.

When AI reliably takes over a task, the ability to perform it directly should be able to step down from the centre of education too.

That doesn't mean the knowledge stops mattering.

AI can run the regression for you, but you still need to understand confounding and selection bias to judge the result properly.

AI can write the code, but working out why a system failed may still require understanding the fundamentals of software.

"AI can do this task" and "the knowledge behind that task is now unnecessary" are two different claims.

Still, if performing a task by hand no longer changes the outcome, the case for keeping that performance at the centre of a curriculum weakens.

The same goes for Prompt Engineering.

Communicating goals and constraints clearly still matters. But there's no reason to assume that "writing long, elaborate prompts" is a permanent core skill.

Composing Context, choosing Tools, verifying and recovering an Agent — models or harnesses may absorb much of this eventually.

Each time that happens, education has to move.

If a curriculum changes more slowly than AI does, we may be handing students problems that AI has already solved.

The job of AI education is not to preserve a particular technique as a permanent subject.

It is closer to continually finding out which capabilities still separate one person from another when both are working with today's AI.

So we look at AI-era capability along three axes

Right now we see the necessary capabilities along three broad axes.

MODEL is understanding how AI learns, represents information, reasons, and fails. It covers the basics of machine learning and deep learning through tokenization, embeddings, neural networks, transformers, training, and inference. This knowledge isn't only about immediate productivity; it's the foundation for judging AI's output and limits in the other two areas.

DATA is building trustworthy evidence from data. Reading data quality, interpreting patterns, judging statistically, designing experiments, separating correlation from causation, and deciding under uncertainty. The more analysis AI performs, the more judging whether that analysis can be trusted, and on what basis a decision should be made, may actually matter.

WORKFLOW is designing the system in which AI does the work. Giving goals and Context, assembling the Tools and execution environment, building the Loop that verifies the result, and — where needed — connecting multiple Agents and deterministic systems.

Cutting across all three is Evaluation: judging what AI produced.

We think of it simply, like this.

Understand AI, build evidence from data, design the system AI works in, and judge what comes out.

What the capability is called matters less than what it changes

But naming a capability doesn't make it real.

If we judge that a student "designs Context well", then on a problem they've never seen, that student should actually raise the same Agent's success rate or the reliability of its output.

If we say a student "evaluates well", they should find important errors in an Agent's output better than others do.

If we say a student "handles Agents well", they should be able to hand a highly autonomous Agent bigger work while still managing failure and cost.

If not, our capability scores are just points in an educational game.

So what we ultimately want to measure is neither which terms a student knows nor how many times they used a feature.

How much better a result can they actually produce with the same AI?

A better result doesn't mean a single number going up.

It might be more accurate, or more trustworthy. It might cut cost and time. It might catch a dangerous error early, or stop a bad decision.

In the end the standard that matters most is whether a human's judgment made a meaningful difference to the actual result.

Which means projects have to change too

Seen this way, education projects have to change as well.

Repeatedly handing students a standardised assignment that AI can finish almost perfectly on its own is worth less and less as assessment.

For example, if the latest Agent can more or less automatically solve

"Build a survival prediction model on the Titanic dataset,"

then whether the project was completed tells you almost nothing about a person's AI capability.

What's needed instead is a problem where human judgment can still make a difference.

For example:

Improve retention among new customers.

You have two weeks of engineering resource.

Price discounts are off the table.

You also can't significantly hurt new-signup conversion.

Decide which action to take, and design how you would verify whether that decision actually worked.

An Agent can analyse the data and generate several proposals.

But several judgments are required at once.

What are we optimising?

Which trade-offs do we accept?

Is the observed relationship a cause we can actually intervene on?

What result would make us change strategy?

How do we verify the Agent's proposal?

And when AI gets good enough at these judgments too?

Then this project has to change as well.

A good education project is one where today's AI alone doesn't flatten the outcome, and differences in human judgment still show through.

We want to see what the action changed, not the action

Grading every message a student sends to an Agent isn't the direction we want either.

Say a student edits the Agent's plan.

If that edit made the result worse, it's hard to call it good capability.

Conversely, if a student spots a real problem in the Agent's reasoning, demands new verification, and a wrong conclusion gets corrected, that intervention has real value.

Suppose an Agent's model reports 95% accuracy.

The student suspects data leakage.

They ask for a re-evaluation on a time-based split.

Real performance was 72%.

By the numbers alone, performance dropped from 95% to 72%.

But this student's intervention didn't make the result worse.

It stopped a bad decision.

The AI capability we care about shows up in moments like that.

What matters is not how often a person intervened in the Agent's work.

It's whether that judgment raised quality, caught an error, reduced risk, lowered cost, or made a better decision possible.

Of course, a better result after one intervention doesn't immediately prove the intervention caused it.

The Agent might have reached the same place on a retry, or the gain might have come from spending more time or tokens.

So where possible, we need to see whether the same pattern repeats on comparable tasks and on new problems.

What we want to see isn't a log of actions.

Action → verifiable change → a better result that repeats

That chain.

Not using AI is not independence

So we have no intention of stopping students from using Agents.

If anything, we want them using Agents heavily.

The independent student, as we see it, is not the one who does everything without AI.

It's the student who can solve a problem with an Agent even when the education system isn't telling them what to do next.

As Agents grow more autonomous, the human role may move from execution to supervision, from supervision to direction, and from direction to evaluation.

If so, AI education will care less about how many lines of code a student wrote and more about what goals and constraints they defined, what they delegated to the Agent, when they intervened, and how they verified the result.

We're building a student's "competency map"

Recording which Courses a student completed can't capture that kind of change.

So we want to accumulate a record of which capabilities a student actually demonstrated while doing projects.

In one project, data analysis and Evaluation might be what counts.

In another, Context and Harness.

In a third, the ability to design the roles and connections among several Agents and systems.

And doing it well once isn't the end of it.

On different data, in a different industry, under different goals and constraints, on a problem they've never seen, the same capability has to work again.

We treat this kind of Transfer as stronger evidence of growth than simple repetition.

The competency map isn't fixed either.

As AI advances and some human execution skill stops producing a difference in outcomes, its weight can come down.

If a new Agent architecture arrives and demands a new kind of judgment, a new capability can come up.

It's a structure where education and the AI frontier move together.

We didn't want to build a product that ends when the courses do

This view shaped the content structure too.

Finish the AI fundamentals Course, finish the Data Science Course, finish the applied AI Course — then what?

Keep producing new Courses?

We have something a little different in mind.

In Academy, you learn the core concepts and fundamentals.

In Lab, you use those same capabilities repeatedly on a variety of new problems.

In Studio, you bring your own data, code, and real problems, and solve them with AI.

In Frontier, you experiment directly with newly arriving models and ways of using Agents.

AI education content may end up looking less like a finished textbook and more like a practice environment that keeps moving.

What we're actually trying to build

We started building an Agentic Tool so students could learn by actually using AI.

Along the way we met a more fundamental question than we expected.

Why should people learn what AI can do for them?

Here's our answer for now.

When AI reliably takes over a task, the ability to perform that task by hand can step down from the centre of education.

But understanding that task, judging what AI produced, and using AI to solve bigger problems — those don't go away.

If anything, we have to keep looking.

Even when both people are using the best AI available,

why can one of them delegate a bigger problem?

Why do they finish with fewer failures?

Why do they catch the important errors?

Why do they get better results out of the same AI?

And we have to find the judgments and interventions behind that difference inside real projects, train them, and check whether they show up again in new situations.

The system we're building keeps moving closer to this shape.

We don't want to teach students how to compete with AI.

Teaching people to redo what AI already does isn't the goal either.

What we want to teach is how to keep growing the size of the problem one person can solve, because of AI.

How far AI can go keeps changing.

Which means what education has to look for keeps changing too.

Given the same AI, why can some people go further?

Finding that difference, teaching it, and measuring it.

What we want to build is education that moves along with the frontier of AI.

Sources

1. Anthropic, The new rules of context engineering for Claude 5 generation models (24 July 2026) — "We removed over 80% of Claude Code's system prompt for models like Claude Opus 5 and Claude Fable 5 with no measurable loss on our coding evaluations."
2. Anthropic, Prompting Claude Fable 5 (Claude Platform Docs) — see "Strong instruction following" and "Refactor existing prompts and skills"
3. LangChain, 3 Years of Graph Engineering with LangGraph (22 July 2026)