SLC Early Access — WeWise Labs

The Diagnosis

0session memory

by default. Every new AI chat starts cold — no memory of your architecture decisions, no memory of your constraints, no memory of what was already built last time.

N+1re-explains

Stack, structure, conventions, boundaries. You explain the same project in every new session. The model listens, nods, then guesses anyway.

∞drift

without a spec. The AI fills every gap it finds — not with nothing, but with something plausible that quietly contradicts what you decided two sessions ago.

The Syntax

Every block is a contract. Nothing is implied.

spec/SPEC.slc

# SLC - Spec Language for Cognition

# Every block is a contract between spec and machine.

@block INDEX root_index

  priority: critical

  intent: "Global router for execution"

  failure_if_skipped: true

  read_order:

    - CONTEXT.md

    - SECURITY.md

    - ARCH.md

    - tasks/task_index.md

@end

@block TASK auth_login

  priority: critical

  depends_on: [ARCH.auth, SECURITY.tokens]

  memory_tier: hot

  content:

    - validate credentials against bcrypt hash

    - issue RS256 JWT with 15min expiry

    - set HttpOnly cookie, SameSite=Strict

@end

@block ARCH memory_system

  scope: global

  tiers:

    hot:  always loaded - SPEC, ARCH, SECURITY

    warm: on-demand - task files, contracts

    cold: indexed-only - historical, examples

@end

Deterministic read order

AI always loads context in the same sequence. No inference, no drift.

Explicit memory tiers

Hot / warm / cold. Nothing is loaded that isn't needed for this session.

Declared dependencies

Each task block knows exactly what context it requires before execution.

The Framework

Eight steps. Zero ambiguity.

Write the spec once. From then on every AI session reads it first and follows the same deterministic path — the framework decides what happens next, not guesswork.

Write CONTEXT.md

Project identity, constraints, tech stack, and deployment target — in SLC block format.

Define ARCH.md

Every system boundary, module, and cross-cutting concern declared as a named block.

Specify SECURITY.md

Auth patterns, session rules, trust boundaries — loaded in every AI session automatically.

Build task_index.md

All planned work as @block TASK entries with explicit priorities and dependencies.

Tag memory tiers

Decide hot/warm/cold per file. AI only loads what the current session needs.

Run SLC-aware agent

Agent reads the INDEX block first. Read order is deterministic. No guessing.

Verify CONTRACT.md

Every route, schema, and interface declared. Agent never deviates from the contract.

Ship with confidence

No unexplained rewrites. No invented patterns. Architecture is the law.

The Math

Most of your context window is context you've already explained.

Session #47 · Without SLC

Ok so here's the context for this session.

We're building a Next.js 14 / TypeScript SaaS platform.

Backend: FastAPI on Python 3.11, PostgreSQL.

JWT auth — access token 30 min, refresh 7 days.

Admin guard is separate from user auth middleware.

User model: id, email, hashed_password,

is_verified, is_active, is_admin, timestamps.

Downloads: pre-signed tokens, 15-min expiry.

Users must verify email before downloading.

Rate limiting: 100 req/min auth, 10 req/min tokens.

SlowAPI + Redis. Never expose is_admin publicly.

/api/admin routes live outside the main router.

Don't modify migration files directly.

Tailwind v4 syntax — bg-linear-to-b, not gradient.

Oh and the constraint from session #44 still applies...

[52 more lines of decisions you re-paste every time]

setup cost

~8,200

tokens · before you write a single line of code

Every session · With SLC

> read SPEC.md

✓ global router + read_order loaded

> read MEMORY.md

✓ 12 decisions anchored · drift protection active

> read ARCH.md

✓ 8 modules declared · boundaries clear

> "add the user profile endpoint"

→ /routers/profile.py · ARCH §User module existing auth guard · starting now

setup cost

~420

tokens · AI knows the rest already

↓90%context overhead

~90%

token reduction

3 tiers

hot / warm / cold

invented context

Two spec files. Every AI starts here.

SLC.md holds the syntax rules — the machine-readable grammar every agent understands. SLC universal structure.md is the universal framework your project maps to. Drop both in your root. The third file is your personal getting-started guide — read it once, never re-explain your setup again.

SLC Spec Files

SLC.md

SLC universal structure.md

SLC getting started guide.md

Click the folder to open

Every other system leaves it to the agent. SLC builds it into the framework.

15 capabilities that make an AI build deterministically instead of guessing. Below: which are built into each system, which are partial, which are missing entirely.

[SLC]SLC

15/15

Spec Kit

2/15

Claude Code

0/15

GitHub Copilot

0/15

Cursor

0/15

▦AGENTS.md

0/15

●Built in◐Partial / by convention–Absent

	Claude Code	Copilot	Cursor	AGENTS.md	Spec Kit	SLC
Spec structure
Typed, machine-parseable block grammar	–	–	◐	–	◐	●
Explicit per-item priority	–	–	◐	–	◐	●
Separate ARCH / CONTRACT / TASKS artifacts	–	–	–	–	●	●
Single source of truth for task status	◐	–	–	–	◐	●
Dependencies & determinism
Dependency graph (depends_on)	–	–	–	–	◐	●
Mandatory read-order routing	–	–	–	◐	◐	●
Conflict-authority hierarchy	–	–	–	◐	◐	●
Frontend derives from backend contract	–	–	–	–	–	●
Context economy
Context tiering (HOT / WARM / COLD)	◐	◐	◐	–	◐	●
File-split protocol with index	–	–	◐	◐	◐	●
Live-docs freshness rule (MCP)	◐	◐	◐	–	–	●
Anti-hallucination memory anchor	◐	◐	◐	◐	●	●
Integrity & safety
Mandatory security-redaction law	–	–	–	–	–	●
Hash / version drift detection	–	–	–	–	–	●
Structured diagnostics / error codes	–	–	–	–	◐	●
Built in	0	0	0	0	2	15

15 of 15, built in. The nearest rival manages 2. On structure, SLC isn't ahead of the field — it's a different category.

Honesty note: “built in” means defined by the SLC format. The structural rows (grammar, references, split protocol, contract derivation, redaction) are mechanically enforced today by slc doctor; hash/version drift detection is defined in the spec and lands with the v0.3 validator.

Your agent is the runtime. SLC is the framework it runs.

Every block is a contract. Nothing is implied.

Memory.

Overrides.

Creativity.

Eight steps. Zero ambiguity.

Every SLC session leaves a record.

Two spec files. Every AI starts here.

Spec Graph

Every other system leaves it to the agent. SLC builds it into the framework.

Spec first.

Code second.

Memory anchored.

No drift.

That’s SLC.