Skip to content

Learning Standard Standards

Description and Purpose

Learning Standards (LSs) are the smallest amount of learnable content. Learning Standards are new material introduced in the content that the learner will need to know to reach the Learning Outcome.

It’s important to note that Learning Standards are distinct from Learning Outcomes. Learning Outcomes define what learners will be able to (LWBAT) do after Introduction to New Material. Learning Outcomes are used to scope curriculum, while Learning Standards are derived from the Learning Outcomes.

Note: These definitions differ from some other usages in the online education community. This is a Codecademy-specific definition.

Content Location

Learning Standards are a precursor to content development. Once Learning Standards are finalized, they are added to Author. Learning Standards are associated in Author with specific content items: lessons, assessments, review cards, videos, articles, etc. (This list is not exhaustive. A content item can be associated with a Learning Standard if it has a Learning Standard List section in Author.) The Learning Standards themselves are not visible to learners.

A standard should be covered in its entirety during Introduction to New Material. This is usually a lesson or an article.

All parts of a Learning Standard must be covered by assessments. An assessment (such as a multiple-choice question) can also cover part of a Learning Standard or multiple Learning Standards.

The following diagram illustrates a quiz, in which each assessment is associated with a Learning Standard. Although not shown, the lesson and project would be associated with the same Learning Standards. A diagram of a quiz within a module. Each assessment has one learning assessment assigned to it.

Overarching Standards

Fields in Author


Learning Standard

The Text of the Learning Standard itself. Examples for each of these can be found in the Examples section below.

Learning Standards should be atomic
  • Learning Standards should include a single, testable concept that guides learners towards a Learning Outcome. (See examples in the Examples section below.)
  • The text of the Learning Standard itself is generally between 1 and 4 sentences long to maintain atomicity. This limit may be stretched when necessary and while remaining atomic.
Write Learning Standards as if you are writing documentation.
  • Learning Standards are NOT meant to provide instruction on their own. They should read as an impersonal statement of fact.
  • Avoid first- or second-person. Passive voice is okay! It's often necessary in order to avoid first- or second-person.
A Learning Standard should stand on its own
  • Learning standards can be viewed, accessed, or used as a basis for authoring without necessarily seeing the context of the lesson/article they were originally authored for.
  • When authoring, make sure that the necessary context is easy to grasp and clearly communicated in the Learning Standard's text itself.
The Learning Standard text itself should NOT include code examples
  • A Learning Standard should be general enough to encompass all of the ways the Standard can be implemented without prescribing specific instructions.
  • Code examples, when relevant, should be provided in the Notes section for reference. (See Internal notes section below.)



These are used to group, internally, similar Learning Standards.

  • Each Learning Standard should have two Tags, one for language or Grouping, such as #Python or #Algorithms, and at least one for the specific concept, such as #Functions or #Inheritance.
  • Groupings can include the container, language, concept.
  • If you want to create a new Tag, consult your domain lead.

Internal Notes

Notes are used to explain further details of the Learning Standard, offer syntax examples, explain scope, add context, link to external resources or demonstrate common or potential misconceptions, etc.

  • Notes support full markdown rendering including tables, images, and code blocks.
  • Code examples should go in the notes, NOT in the Learning Standard itself.
  • Code-based Learning Standards should have a code example as well as a link to documentation if readily available.These examples may be used later when creating Review Cards.
  • Conceptual Learning Standards should have a source if readily available.
  • If directly quoting documentation or trusted sources, you MUST include a link to the source in the Notes section.

Linked Content

Linked Content Items

Content items in Author that use this Learning Standard.

  • There should be at least one linked content item.

Linked Review Cards

The associated Review Card for this specific Learning Standard.

  • There should be only one Review Card for each Learning Standard.

Linked Assessments

Assessments that are associated with the Learning Standard.

  • There should be at least three linked assessments.


Example: When writing Learning Standards, write as if you are writing documentation.

Poor example: uses second-person, reads like an instruction, provides a code example

To create a variable in JavaScript, you should write var and then the identifier like so: var name;.

Good example: An impersonal statement of fact

A variable in JavaScript is declared using the var keyword, followed by an identifier.

Example: A Learning Standard should stand on its own.

Poor example: missing important context

An iterative approach can be used to reduce loss: first, all loss is calculated, then parameters are recalculated and the new loss is compared to the old loss.

Good example: the addition of "In linear regression" adds context

In linear regression, an iterative approach can be used to reduce loss: first, all loss is calculated, then parameters are recalculated and the new loss is compared to the old loss.

Example: The Learning Standard itself should NOT include code examples

Poor example: includes specific code implementation in the learning standard text itself

The following Python code can be used to Quick Sort a list: [ LOTS OF CODE]

Good example: encompasses all ways this can be implemented

QuickSort can be implemented in Python.

  • A code implementation of QuickSort in Python is placed in the Notes section as an example of one specific implementation.
  • A pseudocode description of the QuickSort algorithm would live in its own Learning Standard.

Another good example: JavaScript variables

Variables in JavaScript are declared using the keyword var followed by a name, the equal sign, and a value.

Example: Learning Standards should be atomic

Poor example 1: not atomic

SQL injections can be mitigated by input sanitization, which removes unsafe characters, and prepared statements, which provide a SQL query to execute in advance.

  • Includes two ways to mitigate SQL injections AND the definitions of input sanitization and prepared statements.

Good example 1: previous learning standard becomes three atomic learning standards

  1. SQL injections can be mitigated by input sanitization and prepared statements.
  2. When mitigating SQL injections, input sanitization refers to removing unsafe characters.
  3. When mitigating SQL injections, prepared statements refers to providing a SQL query to execute in advance.

Poor example 2a: too granular

  1. Learning Standard 1: <h1> tags are the largest level of heading tag. They are used for headings at a higher level than <h2>.
  2. Learning Standard 2: <h2> tags are the second level of heading tag. They are used for headings at a higher level than <h3> but a lower level than <h1>.
  3. ...

Poor example 2b: not granular enough

HTML supports heading elements.

Good example 2: just right

HTML has six different heading elements for titling content. Heading tags are ordered from highest level (<h1>) to lowest level (<h6>): <h1>, <h2>, <h3>, <h4>, <h5>, <h6>.

  • HTML heading elements are related enough that separating each heading element into individual Learning Standards actually detracts from the learning. HTML headers, as a whole, are one atomic and accessible concept, each individual header isn’t truly a new concept.

Live Examples