Post 2 of 5 in a series on primitives for higher education

A primitive is a simple idea doing a lot of work, which is why it helps to be precise about what qualifies and what doesn't. The first primitives post made the case for why education needs primitives at all. This one gets into the architecture: what a primitive actually is, which education primitives we've built, how the pieces fit into a stack, and how the same stack composes into very different solutions.

The four properties

In computer science a primitive is a basic operation or data type from which more complex structures are composed. AWS borrowed the term to mean a self-contained, general-purpose service (compute, storage, a database) that developers combine into applications. The definition has four properties worth naming explicitly, because a piece of infrastructure that satisfies only two or three of them is not nearly as powerful.

• Modularity. Each primitive performs one function, and can be used without the others. A CLEP prep course works whether or not a learner uses our AI tutor. A financing mechanism works whether or not the learner prepared with our content. If the pieces are modular, the system doesn't collapse when one of them is absent or when one of them changes (key for swappability below).

• Standardized interfaces. Primitives connect through well-defined boundaries. A course connects to an assessment through content fidelity (the course teaches what the exam measures). A voucher connects to an assessment through a payment mechanism. These interfaces are predictable and stable over time, which is what allows different actors to compose the same primitives without asking our permission.

• Composability. Different actors can assemble the same primitives into different architectures for different populations. A public library composes courses, vouchers, and an AI tutor into a self-directed pathway that runs without institutional intermediation. A university composes courses, vouchers, human advising, and cohort structures into a more supported program. Same primitives, different architecture.

• Swappability. A primitive can be replaced without breaking the system. If a better AI tutor emerges, it can substitute for the current one. If DSST exams exist for subjects where CLEP exams do not, they can replace CLEP in that context. The architecture is resilient to component-level change, which is another way of saying it is not permanently bet on any one component being the best one.

The four properties are what distinguish a primitive from a product or a program. Programs are not modular; pull one piece out and they stop working (note that a program could be built from primitives, and pulling one out without replacing it could cause it to collapse and that wouldn't be inconsistent with this definition). Products tend to be tightly coupled to one vendor. A primitive is designed on the assumption that the creator can give up substantial control of how it gets used, and that losing that control is the point.

The three layers

Education primitives as I'm thinking about them organize into three layers, loosely analogous to a technology architecture. The labels are borrowed on purpose.

Data and identity layer

The foundation. Learner identity (how the system recognizes and tracks an individual across interactions) and the learner transcript (the persistent record of courses completed, exams attempted, and credits earned). Partners don't "use" this layer directly; it is the connective tissue that allows every other primitive to interoperate. In AWS terms, this is the Identity and Access Management layer. Invisible to end users, essential to everything above it.

Core primitives

These are the composable building blocks that actors assemble into solutions. Roughly in order from discovery to evidence:

• Discovery. How learners, institutions, and partners find out the primitives exist and get matched to the right combination. Onramp tools, institutional landing pages, partner-facing documentation. Without a working discovery layer the rest of the stack is invisible.

• Courses. Free online preparation content, each matched with fidelity to a specific assessment endpoint. 32 courses today, each tied to a CLEP exam. Modern States uses CLEP exams as our endpoint, but other exams could work equally well.

• Student support tools. AI tutors, human advising, peer cohort structures. Each is a distinct primitive; each can be deployed independently or in combination. Collapsing them into a single "support" bucket obscures how different the mechanisms are.

• Assessments. The standardized exams that validate learning. CLEP (accepted at approximately 3,000 institutions) and DSST (accepted somewhat less widely but covering mostly non-overlapping subjects with CLEP) are the main endpoints today, with others possible. The assessment is the validation layer. Without a widely accepted exam, everything upstream matters a lot less. To put a fine point on it: traditionally MOOCs, which look like our courses, generally speaking lack the alignment to assessments that turn them into something legible and valuable in the broader system, so they exist as primitives but are much less valuable in the system as a whole and for individual learners.

• Vouchers. Financing that removes the cost barrier to assessment. This primitive is independently composable: a state system might use Modern States courses but fund vouchers through its own mechanism, or use Modern States vouchers with entirely different preparation content. Funding source and voucher mechanism are two separate pieces; either can be swapped without breaking the other.

• Acceptance data. The routing layer that documents which institutions accept which exam scores for which credits. This is what makes the system legible to learners and advisors; the equivalent of developer documentation in a technology platform. The acceptance tool is undervalued because it looks administrative, but it also is what helps learners make sense of their test scores.

There are other possible core primitives, but with this set in place, it's possible to understand the entirety of the system.

Articulation layer

The process by which a passed exam becomes credit on a transcript at a specific institution. Registrar workflows, equivalency tables, transfer policies. This is the layer where things actually break, and it is the layer we do not fully own. We map it and document it through the acceptance data primitive, more specifically our CLEP acceptance tool, but individual institutions control the credit-granting decision. That is worth saying out loud because it shapes the strategy: you can build perfect primitives upstream and still lose a learner to an opaque articulation process at the registrar's office. If a college ostensibly accepts CLEP but then makes it hard for a student with a qualifying score to actually get the credits they've earned, something has broken, and the something is usually here.

Composing the stack

The four properties and the three layers define what the stack can look like. Composability is the property that makes the stack worth building; the payoff shows up only when someone snaps the pieces together for an actual learner. So it's worth walking through two compositions of the same primitives, because they look almost nothing alike even though they draw on the same parts.

When a composition is good enough that other people can pick it up and reuse it, it becomes a pattern in its own right. A wonky but useful name for these patterns is reference architectures because they show how the system can look; they don't define all of the possible configurations. For now I just want to make the abstract stack concrete, so here are two.

The path most learners take

This is the composition that runs at scale today, and it's so routine that it's easy to miss that it's an architecture at all.

A learner finds Modern States, usually through a search or a referral (discovery). She picks a free course matched to a CLEP exam, say College Algebra, and works through it (course). Increasingly, an AI tutor and a sequence of nudges keep her moving when she stalls (support tools). When she's ready, she sits the proctored CLEP exam (assessment), and a voucher covers the exam fee so the cost of the attempt is close to zero (voucher). Before she registers, she checks our acceptance tool to confirm her target institution grants credit for a qualifying score (acceptance data). She passes, the score goes to the registrar, and 3 credits post to her transcript (articulation).

That's seven primitives composed for a single job: turn learner time into transcript credit at close to zero marginal cost. It produces credit one exam at a time, which is exactly what most learners need, and it's the architecture Modern States has put the most work into. I think its very ordinariness is part of why the underlying primitives go unrecognized. The composition is so familiar that nobody stops to notice it could have been assembled differently.

Stacking exams into a sector credential

Here's a second composition that uses largely the same primitives toward a different end.

A few months ago our team grouped the available credit-by-exam credentials, the CLEP exams that we already support and the DSST exams that we could, into clusters aligned to high-growth occupational sectors: for example, data and quantitative analysis, or healthcare administration, or even general education. Each cluster gathers several exams that build cumulative, sector-relevant knowledge, and each maps to specific Bureau of Labor Statistics occupations with projected growth and wage data.

Take the data and quantitative analysis cluster: College Algebra, Calculus, Principles of Statistics, Information Systems, and Computing and Information Technology. A learner who completes it comes away with a coherent body of validated quantitative knowledge that maps to occupations like data scientist (which BLS currently projects growing by about 34% through 2034) and operations research analyst. That bundle behaves a lot like a microcredential: a sub-degree, sector-aligned signal a learner can carry into the labor market now, assembled from primitives that already exist rather than designed from scratch.

Granted, the very specific courses and exams here might not be the perfect cluster. But ignore that for a moment, because I’ve admittedly done only the most preliminary work to map those clusters together, and a serious effort would require engagement with other partners.

This is where the composition loops back to an argument I made in Why the degree persists. I argued there that standalone microcredentials tend to struggle because they push transaction costs onto employers. A badge from an unfamiliar issuer, with no track record and no shared standard, is expensive to evaluate, and the labor market hasn't agreed to read it. So the learner is often left holding a credential that signals less than it should.

A cluster built from credit-by-exam primitives largely sidesteps that problem, for two reasons. First, every exam in the cluster is already a recognized primitive with a track record: CLEP scores articulate into credit at roughly 3,000 institutions, and College Board's research shows that students who earn CLEP credit tend to do as well or better in the subsequent course than peers who took the equivalent class on campus. Second, because each exam also generates college credit, the cluster does two jobs at once: it signals sector-relevant knowledge today, and it functions as a down payment on the degree the labor market already knows how to read. A learner who stops after the cluster keeps something legible. A learner who continues has a running start on the credential itself.

That's what makes this kind of microcredential more useful than the typical one: it builds on the recognition layer that already exists instead of asking employers to make sense of a new one. It's the (positive) half-a-loaf version of the argument I keep coming back to. A learner doesn't have to wait for the labor market to start trusting a new currency; she gets sector-relevant evidence now and loses nothing if she later finishes the degree.

Both of these are compositions of the same stack. The first is one we run at scale; the second is one we've started thinking about as a pattern that would require broader collaboration to adopt and adapt.

Sources & references

On modularity and the disruption framework

• Michael B. Horn (with Clayton Christensen and Curtis Johnson), Disrupting Class: How Disruptive Innovation Will Change the Way the World Learns (McGraw-Hill, 2008). Applies the disruption frame to education.

On standardized interfaces

• Marc Levinson, The Box: How the Shipping Container Made the World Smaller and the World Economy Bigger (Princeton University Press, 2006). The container's twistlock is the canonical example of an interface that enabled massive composability; a useful analogue for what standardized interfaces do for primitives.

On platform thinking

• Ben Thompson, Stratechery (ongoing). His essays on modularity, aggregation, and platform strategy are the closest contemporary articulation of how primitive-building works in tech.

On recognition and microcredentials

• Jefferson Pestronk, "Why the degree persists." The companion piece this section builds on: why standalone microcredentials face a transaction-cost problem the degree has already solved.

• Jing Feng and Jeff Wyatt, "The Validity of CLEP Scores for Course Placement Decisions" (College Board Research, May 2025). Students who earned CLEP credit performed the same or better than peers who took the equivalent introductory course on campus.

On labor-market projections

• U.S. Bureau of Labor Statistics, Occupational Outlook Handbook (Employment Projections, 2024–34). Source for the cluster growth and wage figures.

Part of a 5-post series on primitives for higher education. Previous post: The bundle is the challenge.