NAV · CIRCLE · NAV · CIRCLE · NAV · CIRCLE · NAV · CIRCLE ·
NAV
[SLC]WeWise Labs · Early Access
The world's first spec-native language

Anlanguage & framework.

SLC is the world's first token-efficient, spec-native language for cognition. Two files. Every AI session reads them first. No re-explaining. No drift. No wasted context.

Request access See how it works
SLC mascot carrying a code folder
Scroll to explore ↓

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 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
01

Deterministic read order

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

02

Explicit memory tiers

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

03

Declared dependencies

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

The Law

Memory.

Overrides.

Creativity.

SLC puts a MEMORY.md at the root of every project. Every decision, every constraint, every assumption — recorded and numbered. When the AI contradicts any of it, execution stops. That’s not a workaround. That’s the spec.

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.

01

Write CONTEXT.md

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

02

Define ARCH.md

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

03

Specify SECURITY.md

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

04

Build task_index.md

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

05

Tag memory tiers

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

06

Run SLC-aware agent

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

07

Verify CONTRACT.md

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

08

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

0

invented context

The Files

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

03 · The Architecture

Spec Graph

This portal was built with SLC.
Scroll to see the spec that built it.

03 · Architecture — SLC Spec Graph

Click node to open tree · Drag to explore
Root
Spec dirs
Files
Tasks

The Verdict

Spec first.

Code second.

Memory anchored.

No drift.

That’s SLC.

Request AccessSign in
WeWise Labs | 2026