Solo Path for Power Users · The Cognition Factory · v1.2

How the Factory closed loop actually runs

Not a course catalog. A field picture of how one person runs The Cognition Factory — builds a living domain map, pressure-tests it, and keeps the work alive when sessions break — under real load.

Prefer plain English first? Busy adults: start with the everyday solo path (TCF as offering, less operator jargon). Return here when you want engines and lattice named.

Who this is for. High-agency learners who already own the problem: cert or role deadlines, career pivots, domains that punish fuzzy explanations. You bring a capable language model (local or cloud). If you want passive content and a completion badge, TCF will frustrate you. That is intentional.

Offering first

TCF is the product. Everything below is how the Factory is built — not a menu of separate SKUs. Do not flatten this into “chat with an AI tutor.”

Depth engine · HAL-E · the Core

A Core is the living map of a domain — the single source of truth for Deep learning. It is not a playlist of videos. It is structured architecture: what always holds, named concepts you can teach, how clusters hang together, and curricular paths through the whole. Operator language: bedrock truths → teachable concepts → schema maps → spine and paths.

Practice engine · AAE · the course kit

A course kit (cart / cartridge) is a built-to-spec assessment pack for a defined outcome (exam weights, competency goals, error routing). It samples the Core. It does not invent a second curriculum. If the kit and the Core disagree, the Core wins — you fix the kit, or you promote a real change into the Core on purpose.

Save-place engine · CSS · + lattice · CMS

Not peer products on a shelf. CSS (Cognitive Save States) is the save-place engine: cuts re-entry tax when tokens die, life interrupts, or you switch focus. CMS (Cognitive Mapping System) is the lattice: bridges inside a domain, offramps into a practice kit when fidelity matters, crosswalks later if you hold more than one Core.

Inside TCF: depth builds. Practice proves. Save place keeps the loop alive. Clean re-entry is how the Factory survives being a human with a calendar.

What you need before day one

A domain that hurts if you stay fuzzy (exam, engagement, identity — pick one primary).
A capable model you control. Thin models produce thin teach-back and thin exams.
Honest constraints: hours, interruptions, deadline.
Willingness to write structure into files — not only into a chat thread.
A rule you will not break: the Core is SSOT; the course kit samples it.

The operator loop (not a marketing week)

Real work is rarely a neat seven-day cartoon. Treat the following as phases you can compress into a hard week or stretch across a densify cycle. The order matters more than the clock.

Phase A · MAP (build or load the Core)

Name the big pieces of the domain. Force “what always holds” into short statements (invariants). Hang named concepts on those truths. Sketch how clusters move together. End a session when you can redraw a slice of the map from memory — not when a progress bar fills.

Between sessions: leave a save with intent depth so tomorrow is not a cold boot.

Phase B · SPAR + teach-back (pressure the map)

Attack weak joints. Spar until the explanation holds or a real gap shows. Then teach a hard slice as if training a sharp peer — notes closed first. Where you stall is the work. Update the Core, not only the chat wording.

Classify misses when you can: concept · mechanics · integration. That taxonomy is what makes later assessment useful instead of theatrical.

Phase C · Offramp into a course kit (exam fidelity)

When the goal is blind competence — not open sparring — take a lattice (CMS) offramp into a Practice kit built from the same Core. Domain weights should match the real end-state you care about. Every item should point back at Core concept IDs so the cart cannot quietly fork the truth.

Run blind blocks: no notes, no “I know this neighborhood” shortcuts. Log misses as item or topic | what I wrongly believed.

Phase D · Densify from the miss list only

Do not rewrite the whole bank for sport. Fix what failed: Core nodes if the architecture was wrong, cart items if the sample was thin, drills if the gap was mechanical. Then re-test the same pressure. That is how a draft cart becomes assessment-ready — operator green light after honest blinds, not after a pretty file count.

Phase E · Re-entry (the part most systems ignore)

Sessions end mid-thought. Models compress lossily. Life interrupts. Re-entry means you resume from a save and a Core slice — not from “where were we?” Intent matters: resume depth, resume drill, or hand off to assessment without drifting into a different map by accident.

Interruptions are the design environment. If a method only works in unbroken four-hour blocks, it is not a system — it is a vacation fantasy. This architecture assumes token ceilings, caregiving, work, and sleep. Re-entry is not polish; it is load-bearing.

One Core, many course kits (why specificity matters)

A mature Core can feed more than one kit: different exams, roles, or weightings — still one living map. That is how you avoid forking “Financial version” and “Managerial version” into contradictory truths. Split pressure at the cart; keep bedrock in the Core.

Build the first course kit against a goal you know cold. Hyper-specific beats generic. The pattern is portable; the first kit is allowed to be personal.

What “good” looks like

You can redraw domain structure without the chat open.
You can name load-bearing truths that survive context changes.
You have logged at least one honest blind fail — and a repair plan, not a shrug.
Kit items point at Core IDs; you are not maintaining two curricula.
Next session starts from save place + intent, not archaeology in message history.
You know whether you are in depth, drill, or assessment — and you chose it.

What this is not

Not a binge playlist or gamified streak.
Not “the model will remember for you.” You own the Core.
Not seat-time LMS theater.
Not three peer products (HAL-E / AAE / CSS) — engines inside TCF; CMS is lattice, not a SKU.
Not a full rewrite of the exam bank every time you miss one item.

If you only do three things

Write the map (Core), however rough — files, not vibes.
Blind pressure from a cart that samples that map; log what you wrongly believed.
Save intent so re-entry is deliberate; densify from the miss list only.

A note on layers (optional depth)

When a Core is mature, operators often organize it roughly as:

L0 — invariants (what always holds)
L1 — named concepts you can teach or target
L2 — schema maps (how a cluster hangs together)
L3 — spine and paths (curricular routes)
CMS nodes — offramps into assessment, bridges between ideas

You do not need perfect IDs on day one. You need the habit: structure first, then pressure, then repair.

Next step

If this matches how you already try to learn — and you want a Core, a course kit path, or a conversation about fit — use Talk with us on the main site. Bring domain, constraints, and what mastery has to mean in your life.

Prefer theory first? TCF Methodology · Executive Whitepaper · then return to this operator picture.

The Cognition Factory · Solo Path for Power Users · v1.2 · TCF is the offering · engines + lattice named for operators · public-safe.
Engines: HAL-E (depth) · AAE (practice) · CSS (save place). Lattice: CMS — not peer SKUs.
Course kit samples Core. Miss-list repair. Re-entry is load-bearing.