Learning Standards Carry Events, Not Competence

Your training team had done the responsible thing.

They imported course completions from the LMS. xAPI statements from a simulator.

Grades from an LTI tool.

A handful of Open Badges.

All of it into the new skills graph.

The file was called capability_evidence_FINAL_v7_USE_THIS_ONE.csv.

Naturally, it had a column named proficiency.

Nobody put it there maliciously.

The board wanted a view of capability.

The workforce-planning model wanted a clean input.

The AI product wanted to recommend people for work.

A completion record arrived with a learner identifier, a course title, a status and a date.

What else could it possibly be?

Quite a lot, unfortunately.

A learning standard carries a record about learning activity. Competence is a claim about performance.

Those objects can be related.

They are not interchangeable.

SCORM, xAPI, cmi5 and LTI are very good at the jobs they were designed for.

They stop an LMS, a course, a simulator and a remote assessment tool conducting their own private data-exchange ritual involving a CSV, an SFTP folder and somebody called Denise who understands the field mappings.

They do not decide whether a person can do your work.

Four standards walk into a skills graph

Start with SCORM, because that is usually where the innocent-looking completion begins.

SCORM is designed for a self-contained web course that an LMS can import and launch.

The package is a ZIP archive with a manifest. Its sharable content object runs in the browser and talks to an exposed API.

That is a useful contract.

A course can launch elsewhere and report a conventional attempt.

The contract is not “this person can now perform the associated job.”

The completion status, success status and score fields all belong to one attempt, at one content object, in one LMS.

The content object supplies the score.

Its package can use its own rule or threshold for completion.

So a completion says the course completed, according to the package rule.

A raw score says the content object supplied a raw score.

Both can matter greatly.

Neither names the work condition, the performance criterion, or the evidence a capability decision needs.

xAPI travels more widely, which makes the confusion more efficient.

An xAPI statement is a sentence built from an actor, a verb and an object, each present exactly once.

Its result may carry score, success, completion, response and duration. Its context may carry a parent activity, a grouping, an instructor, a registration or a team.

A learning record provider creates the statement.

A Learning Record Store keeps it.

Excellent for keeping an event trail from a simulator, a performance-support tool, an offline application or an LMS.

It is not an epistemology engine.

Statements are immutable apart from limited processing fields.

A late correction needs a void or a superseding record, rather than a quiet edit after lunch.

Useful provenance.

Still an event.

cmi5 makes the next distinction pleasantly unglamorous.

It uses xAPI, and adds an LMS-constrained launch and lifecycle model. An assignable unit emits prescribed statements: launched, initialized, terminated, completed, passed, failed.

That constraint is exactly why cmi5 is useful.

A generic xAPI producer can say “experienced” and leave your LMS to contemplate the mysteries of existence. cmi5 gives it a defined launch context and predictable reporting.

But a passed lifecycle signal is still a signal. A point score and a pass-fail flag answer separate questions, and two tools can use both faithfully while meaning entirely different things by them.

LTI solves another problem altogether.

It lets an institutional platform give a remote tool a scoped launch context.

User.

Course.

Roles.

Resource link.

Available services.

It does not turn that tool into LMS-native content. And it does not make the tool’s internal telemetry a transcript.

Its advantage services add assignment and grade services, roster and role provisioning, and deep linking, so a tool can create its own line items and an instructor can select a resource.

Splendidly practical.

Also not a competence verdict.

The skills graph makes the mistake look official

The trouble starts when these records get attached to a skill label, and the attachment is read backwards.

Somebody completes a course aligned to “data analysis.” Your LMS sends a status. Your skills graph awards “data analysis.” Your talent marketplace proposes the person for work involving analysis they have never done.

The dashboard is very pleased with itself.

The work is less impressed.

This gets more dangerous when the label comes from a respectable taxonomy, because a respectable taxonomy makes the inference look like architecture.

Alignment says what the activity was intended to address.

It does not say the learner now meets the definition.

Which is not a subtle distinction, provided you keep the objects apart.

Capability is a versioned statement about something a person can demonstrate, under stated conditions, against a criterion.

Learning record is a source-system record that an activity occurred, or produced a particular result.

Taxonomy reference is an identifier and label used to organise or translate the capability statement.

Assessment evidence is the observations, conditions, instrument, scale and scorer provenance that can support a capability decision.

Flatten those four into a row and the AI sees a fact.

The original systems supplied several incomplete facts and a polite suggestion.

The standards are doing real work, which is the difficulty

None of this argues against learning standards.

They solve problems you would otherwise be solving by hand.

SCORM gives you portable package-and-runtime behaviour, wherever you launch it. xAPI gives multiple systems a common event format and a store that retains it. cmi5 gives xAPI a portable launch and lifecycle contract.

LTI gives remote tools controlled access to course context and grade services.

CASE adds the equally useful ability to publish competency definitions and their relations. Two systems can retain an opaque identifier and a human-readable statement from a framework authority.

An assessment item can point at a canonical definition, without anyone pretending the definition is a learner attempt.

Open Badges and Comprehensive Learner Records solve a different portability problem again. A badge assertion records one issued achievement for a recipient.

A learner record aggregates assertions.

The verifiable-credentials model supports cryptographically verifiable claims with multiple proof formats.

Keep all of it.

The thing to defend is the exchange.

The thing to resist is the category error that arrives afterwards, usually in a well-intentioned transformation job called derive_employee_skills.sql.

A signed credential can authenticate an issuer and protect integrity under its rules. It cannot establish that two issuers used the same rubric, the same conditions, or the same performance threshold.

CASE can publish a target.

It cannot validate the assessment.

LTI can return a score.

It cannot tell another tool what that score means.

Transport is not validation.

Build the evidence chain before the inference

The operational answer is not to discard completions.

It is to make the relationship explicit.

For every record you import, retain four provenance dimensions.

Source system.

Observation or issue time.

Identifier namespace.

Specification or profile version.

A derived value also needs its calculation date.

The gap between when an event happened and when the store received it matters when an offline tool synchronises late. Which is an everyday reality, not a philosophical exercise.

Then retain everything the standard does not normalize for you.

The assessment conditions.

The criterion.

The score scale.

The instrument.

And who or what produced the score.

Your system needs to know whether 92 is a point score, a percentage, a simulator measure, or an unhelpfully enthusiastic number emitted by an authoring tool.

Before it becomes any kind of evidence.

The capability reference needs its own version too.

Occupational and skill classifications revise their codes and their labels between editions, and a course-alignment field that stores only a label has already misplaced the thing it claims to classify.

So an internal canonical capability statement links out to a public framework, and the link says what kind of link it is.

Direct alignment.

Partial alignment.

Assessment target.

Supporting evidence.

Verified outcome.

Keep the external system and its version.

A mapping does not become more certain because it crossed an API boundary.

Finally, decide your inference rule before the AI arrives with a tasteful chart.

A completion may grant learning history.

A successfully scored assessment may grant supporting evidence.

Observed performance under retained conditions, against a stated criterion, may grant a validated capability claim.

And a missing scale, a missing scorer, or an ambiguous mapping routes to review. Not to a recommendation engine that has suddenly decided an employee is ready for a role.

The goal is not to make your graph less useful.

It is to stop it confidently recommending a person for work they have only watched a module about.

AI has made the shortcut irresistible

Learning systems evolved locally.

An LMS stored attempts.

A simulator stored its events.

A publisher tool stored grades.

A framework authority stored standards.

An issuer stored achievements.

Then organisations asked for one skills view, which was reasonable.

Then AI asked what every field meant, which was also reasonable.

And somebody handed it activity data with skill_name attached.

Good luck.

An AI system can ingest thousands of statements, lifecycle events, completion statuses and grades without becoming tired, distracted, or annoyed by the spreadsheet’s tab colour scheme.

That makes event data irresistibly easy to use.

It also scales every hidden ambiguity with impressive efficiency.

So the durable object has to be explicit in the schema. A versioned capability claim, supported by evidence, conditions, criterion and provenance.

And the wrapper has to be explicit too.

SCORM attempt. xAPI statement. cmi5 lifecycle record.

LTI grade.

CASE definition.

Badge assertion.

Once that distinction exists, automation has something honest to work with. It can find evidence, identify gaps, propose an assessment and explain its confidence.

It can stop treating course attendance as a career diagnosis.

That is not less ambitious.

It is merely the point at which your skills matrix stops confusing a receipt with the work.