← All sessionsHomeSearch
AI Sprints (Live Weekend Programs)·Claude Code with Antgravity Sprint·1:59:43

AI Sprint: Claude Code with Antigravity — Day 2 (CLAUDE.md, the 50% Context Rule, and the Sketch-to-App Build)

Dileep (KVSS Dileep) Head of Generative AI Education at Outskill; the advanced day — 'my actual setup, not the one I showed you yesterday' — orchestrating CLAUDE.md, memory.md, superpowers, UI UX Pro Max, and component-level design sources into a sketch-to-app build · Kartik Host — LMS triage, recap logistics
▶local recording  ·  LMS lesson

Session map

THE FILESTHE STACKTHE BUILDCLAUDE.md and memory.mdthe preloaded prompt and the running logThe 50% rulecontext degradation, the exit ritual, a…Orchestrating skillssuperpowers + UI UX Pro Max + design so…Sketch-to-appa scoped Lovable clone, sub-agents, adm…
The filesThe stackThe build
click a node — its card pops up (drag it anywhere, × to close)
Concept

The map reads left to right — the files flow into the stack, then into the build. Click any node to open that idea here; every timestamp jumps into the recording.

The short version

  1. The two files come first: CLAUDE.md is 'the knowledge always loaded — a sticky piece of text, a preloaded prompt' (his is built from Karpathy's coding guidelines: think before coding, simplicity first, surgical changes); MEMORY.MD is the running log — 'when your tokens expire and you restart, it reads CLAUDE.md and memory.md and catches up on what is happening.' Both local, on purpose: 'I teach multiple cohorts; I don't want it global.'
  2. The session's hardest number: THE 50% RULE — 'if your context is greater than 50 percent, you will see a degradation in performance. Once you reach 50: update memory.md, close out the important task, exit, and open with a fresh context' (the context-rot paper cited for the curious). Token doctrine follows: 'clarity is the biggest token saver — no package, no skill, no magic wand replaces it,' the caveman compression skill is rejected ('don't hyper-optimize tokens at the cost of clarity'), and CLAUDE-MEM is crowned 'the best unlock' — automated memory that showed 91% reuse reduction on the model-council repo.
  3. Skill orchestration is the advanced material: superpowers (the end-to-end dev workflow: brainstorm → design doc → TDD → structured execution) + UI UX Pro Max for interface quality + design as DATA (Super Design for the overall vibe; 21st.dev when you want component-by-component control — 'if you're particular about each section, use components'), with the anti-conflict rule: 'don't put two skills that do the same thing globally — the agent gets confused which to call.' Marketplace picks (skills.sh) are judged by installs and stars, and the security audit is declared mandatory 'especially if you are a non-tech person.'
  4. The build is a scoped Lovable clone: SKETCH-TO-APP — draw on a tldraw canvas or upload a wireframe, pick a model, get a working preview + downloadable code, iterate by chat or by re-sketching on top. Architecture chosen for security by default (Next.js server route 'protects the API key from day one'), 30 bite-sized tasks across 9 phases, executed sub-agent-style under --dangerously-skip-permissions ('admin mode — it will not keep asking; useful when I'm teaching').
  5. The MVP lands with honest edges: his hand-drawn 'Welcome to Outskill' login sketch becomes an app; a Pinterest wireframe generates 'decently — lots of overlaps, but pretty decent... don't expect it to work exactly like Lovable; the idea is to take a small part of it and make it work.' Then the finale: the Playwright e2e run 'killed my GPU so much it froze my entire Zoom' — the archive's best demonstration that agent workloads are hardware workloads.
  6. The recovery architecture running under everything: memory updated at phase boundaries so 'if this agent fails, I have another agent' — Antigravity picks up from the plans and memory, exactly as Day 1's outage rehearsed.

The concepts

01

CLAUDE.md and memory.md: the preloaded prompt and the running log

'CLAUDE.md is the knowledge always loaded — a sticky piece of text, a preloaded prompt. Memory.md is what has happened so far. Exit and come back, and together they tell the project status.'

The pair, precisely framed: CLAUDE.MD is NOT retrieval — 'it's not a RAG; think of it like a prompt always copied along with your information' — the place for project rules and behavioral guidance. His is seeded intelligently: Karpathy's Claude-coding notes, packaged by the community into a ready CLAUDE.md — 'behavioral guidelines to reduce common LLM coding mistakes... think before coding, simplicity first, surgical changes, goal-driven execution,' with the stated trade-off read aloud: 'these bias toward caution over speed — for trivial tasks, use judgment.' MEMORY.MD is the log: project overview, stack, completed/in-progress/pending steps, open questions, decisions — updated at his command ('update memory.md') at phase boundaries, so any fresh context or substitute agent resumes from artifacts, not recollection.

Scoping is a teaching decision made visible: both files LOCAL ('I teach multiple cohorts — I don't want this global; if you like it, make it global'), and the tablet rule for those drowning in global-vs-local confusion: 'you don't question the composition; the doctor prescribed it. Set it up as-is for now.'

Worked example · from the session

The recovery chain stated as design: 'in case something goes wrong, I look at my memory and recover from there' — and if Claude itself fails, 'I have another agent' reading the same files.

Why it matters

It's the formalization of the whole corpus's md-file doctrine: the harness (CLAUDE.md) and the state (memory.md), separated by decay rate.

People get this wrong

CLAUDE.md is documentation the agent consults when needed.

It's injected EVERY turn — which is why it must stay small, behavioral, and worth its permanent token cost.

CLAUDE.md is the knowledge always loaded — a sticky piece of text, a preloaded prompt.
For your projects

The caution-over-speed trade-off note is worth copying into any behavioral file you write: name the bias you're installing.

This idea elsewherecomplementssoul/user/memory is this pattern's role-sliced twincontinuesthe folder-is-the-harness doctrine, given its two canonical files
Go deeper

In one line: CLAUDE.md = always-loaded behavioral/system prompt (seed from proven guideline sets; caution-biased); memory.md = command-updated project log (status, decisions, pending); both scoped deliberately (local per project unless a habit is universal); together they make sessions and agents disposable.

Seeding from Karpathy's guidelines is the shoulders-of-giants move applied to the harness itself ()

The preloaded-prompt framing kills the RAG misconception cleanly ()

agents.md/readme.md acknowledged as siblings; his setup uses exactly two files — minimalism as policy ()

Hermes' soul/user/memory (that sprint) and this CLAUDE.md/memory.md are the same architecture with different slicing

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

What goes in CLAUDE.md vs memory.md when you learn a new project convention?

If it's how the agent should BEHAVE from now on (rule), CLAUDE.md; if it's what HAPPENED or was decided (state), memory.md. Behavior vs state is the sorting test.

02

The 50% rule: context degradation, the exit ritual, and clarity over compression

'One cardinal rule, very very important: if your context is greater than 50 percent, you will see a degradation in performance.'

The operating rule: past ~50% context utilization, Claude Code's quality drops (the CONTEXT-ROT paper offered for the curious). The ritual when you hit it: finish the important task, UPDATE MEMORY.MD, exit, reopen with a fresh context, and resume from plan + memory — 'spin up a new agent to continue from there.' This is also the token-economics answer: 'you don't lose tokens on re-understanding what happened; memory.md tells it exactly.'

The philosophy underneath gets its sharpest statement across his sessions: 'CLARITY is the biggest token saver. No packages, no skills, no magic wand can replace this.' The counter-example is examined honestly — the CAVEMAN skill (compress prompts to grunts: 69 tokens → 19) — and rejected with reasons: 'there is a lot of nuance when you explain things clearly. You're saving tokens but reducing context... don't hyper-optimize tokens at the cost of clarity.' The endorsed tool is CLAUDE-MEM: automated memory capture that replays project state on restart — demoed on the model-council repo showing '91 percent reduction from reuse' — 'this is actually true memory conservation... the best unlock you can get.'

Worked example · from the session

The live meter: 24 minutes of sub-agent building ≈ 33k tokens, 17% of the 200k window — the rule made concrete against his own build.

Why it matters

It converts vague 'long chats get dumb' intuition into an operable threshold with a recovery ritual — the missing piece of most agent workflows.

People get this wrong

Bigger context windows make context discipline obsolete.

Degradation is proportional, not absolute — the 50% line moves but the ritual (log, exit, resume fresh) stays the highest-leverage habit at any window size.

The 50% ritual Context climbs watch the meter ~50% reached quality degrades Update memory.md log state + decisions Exit session history is dead weight Resume fresh plan + memory reload 'If your context is greater than 50 percent, you will see a degradation in performance' — log, exit, resume
The 50% ritual: log to memory, exit, resume fresh
If your context is greater than 50 percent, you will see a degradation in performance.
Clarity is the biggest token saver. No packages, no skills, no magic wand can replace this.
You are saving tokens, but you are reducing the context. Don't hyper-optimize tokens at the cost of clarity.
For your projects

'Clarity is the biggest token saver' has now appeared in three sessions — it's earned a place in your toc-standards as a named principle.

This idea elsewherecomplementsfresh-context-per-iteration is this rule built into the loopcomplementsthe other token lever — pricing arbitrage vs context hygiene
Go deeper

In one line: Context discipline = treat ~50% utilization as the degradation line; at the line: complete, log to memory, exit, resume fresh from artifacts; economize tokens through CLARITY and automated memory (Claude-Mem), never through nuance-destroying compression.

The ritual's order matters: memory BEFORE exit — the fresh session's quality depends on what the old one wrote down ()

Claude-Mem vs caveman is the whole token debate in two tools: conserve by remembering, not by mumbling ()

Karpathy's guideline set and the 50% rule are complementary: behavioral caution + state hygiene ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

Why does compression lose what memory keeps?

Compression strips the nuance the model needs NOW; memory offloads what it needs LATER. One degrades every turn; the other cleans the window between turns.

03

Orchestrating skills: superpowers + UI UX Pro Max + design sources, without conflicts

'I have borrowed the brains of some of the best software engineers, who are now going to build this app slowly and in a proper manner.'

The stack, layer by layer: SUPERPOWERS — 'good software engineering habits turned into reusable skills... instead of ad-hoc coding, an end-to-end dev workflow': brainstorming/requirements, design doc, test-driven development, structured execution; globally installed because it's his daily driver (community signals read again: ~13k forks, ~152k stars as-heard). UI UX PRO MAX — the interface-quality layer (~65k stars). DESIGN AS DATA, two grains: Super Design for a single overall vibe ('everything at once'), 21st.dev for COMPONENT-level control — browse navbars/pricing/animations, copy the per-component prompt, or better: let the skill pick ('go to 21st.dev or use best practices to pick the right components — it's a thousand lines each; the skill knows'). MARKETPLACE picks from skills.sh judged by installs + stars: e2e-testing patterns (~33.5k) chosen over lower-signal options; security best-practices (~32.8k) chosen over a young low-star Firebase auditor — 'a substantial number of people using it day in and day out.'

The governance rules: DON'T install everything (Day 1's lesson standing); DON'T install conflicting skills globally — 'don't put UI UX Pro Max and another UI design skill globally; the agent is confused which skill to call'; and the non-negotiable: 'run the security check for your app — especially if you are a non-tech person.'

Worked example · from the session

The orchestration in one prompt: 'use the superpowers skill and the UI UX Pro Max skill in tandem — understand clearly which skill needs to be called where.'

Why it matters

It's the mature version of skills-as-recipes: not one recipe but a coordinated kitchen, with conflict rules and quality gates.

People get this wrong

Skill quality is about the prompt inside.

It's prompt quality times routing clarity times community proof — a brilliant skill that collides with another, or that nobody has battle-tested, loses to a proven, cleanly-scoped one.

I have borrowed the brains of some of the best software engineers, who are now going to build this app slowly and in a proper manner.
Don't put two conflicting skills globally — the agent is confused which skill to call.
Run the security check for your app. Especially if you are a non-tech person, you have to run the security check.
For your projects

The 'security check especially for non-tech' mandate maps to your security-change-procedure skill — same instinct, agent-build edition.

This idea elsewherecontinuesDay 1's selective import, matured into a coordinated stackcomplementsthe skills.sh audit skills return in the SEO/GEO session
Go deeper

In one line: Skill orchestration = layered stack (dev-workflow skill + UI skill + design-data sources + testing/security from marketplaces), community-signal selection, global only for daily drivers, never two overlapping skills in scope, security audit mandatory before shipping.

Design granularity is a choice: whole-vibe (Super Design) vs per-component (21st.dev) — match the tool to how opinionated you are ()

Let the skill choose components rather than pasting thousand-line prompts one by one — delegation inside the design step ()

Anthropic's own web-app-testing skill spotted on skills.sh — first-party skills are entering the marketplaces ()

Security-by-architecture appears in the build itself: the server route 'protects the API key from day one' ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

Why is a conflicting-skills pair worse than a missing skill?

A missing skill degrades one capability; conflicting skills corrupt ROUTING — the agent may pick either on any turn, making quality non-deterministic everywhere.

04

Sketch-to-app: a scoped Lovable clone, sub-agents, admin mode, and the GPU-killing finale

'Something like a Lovable clone, lesser scope' — draw a wireframe, pick a model, get a working app — built by 30 bite-sized tasks under dangerously-skip-permissions.

The brainstormed product: input by tldraw canvas OR uploaded wireframe; output as downloadable React AND live preview ('all of the above — the user picks'); iteration by chat refinement AND re-sketching annotations on the preview; models user-selectable via OpenRouter. Architecture chosen with the skill's own reasoning: Next.js, one app, server route proxying OpenRouter — 'protects the API key from day one'; TL;DR of the alternatives' trade-offs accepted rather than re-derived. Scope held by the middle option ('start with the middle, upgrade later'). Then execution: a design doc and an implementation plan of 30 bite-sized tasks across 9 phases; memory updated first; then the mode shift he flags as 'a little bit crazy — pay close attention': exit, restart with --DANGEROUSLY-SKIP-PERMISSIONS — 'admin mode: it will not keep asking should-I-do-this; it executes on its own. Useful when I'm teaching' — and sub-agent-driven dispatch ('auto-continue until you need review or input').

The landing is honest on every edge: his hand-drawn login sketch ('Welcome to Outskill / user / password') generates; the Pinterest wireframe generates 'decently... a lot of overlaps, but pretty decent — don't expect it to work exactly like Lovable; the idea is to take a small part and make it work'; the Gemini path errors and gets noted; and the finale is the archive's best hardware lesson: the Playwright e2e run 'killed my GPU so much it just froze my entire Zoom system... it was not an internet issue; it was extensive building' — on an M1 Pro. Agent workloads are compute workloads; budget the machine, not just the tokens.

Worked example · from the session

The admin-mode trade named exactly: speed and flow while teaching, bought by surrendering the per-action review gate — the same dial every sprint has been adjusting.

Why it matters

It's Day 1's methodology at full power: two skills, two md files, design-as-data, sub-agents, and a recovery layer — producing a real (bounded) product in one session.

People get this wrong

A Lovable clone needs Lovable's infrastructure.

A SCOPED slice of it (single screens, preview, download) is one session's work on commodity parts — the gap is breadth, polish, and hosting, not magic.

Sketch-to-app: a scoped Lovable clone tldraw sketch or uploaded wireframe Server route protects the API key Vision model user-picked, OpenRouter Live preview + downloadable code Iterate chat or re-sketch 30 tasks, 9 phases, sub-agents under admin mode — and an e2e test that froze an M1 Pro
tldraw sketch, key-protecting server route, vision model, preview + code
Dangerously skip permissions — this is like admin mode. It will not keep asking me; it will execute on its own.
Don't expect it to work exactly like Lovable. The idea is to take a small part of it and make it work.
The end-to-end testing killed my GPU so much that it froze my entire Zoom. It was not an internet issue — it was extensive building.
For your projects

The GPU-freeze finale is your hardware-budgeting anecdote for clients who think agent work is 'just typing' — compute is part of the bill.

This idea elsewherecomplementsthe sibling advanced-day build: spec-first there, skill-orchestrated herecomplementsthe Catalyst track's version of the same scoped-clone honesty
Go deeper

In one line: Sketch-to-app = tldraw/upload → vision model (user-picked via OpenRouter, server-route-protected) → preview + downloadable code, iterated by chat and re-sketch; built via design doc + 30-task plan, sub-agent dispatch under skip-permissions, memory-checkpointed for recovery; scoped deliberately below its inspiration.

Option analysis is delegated but the CHOICE stays human — 'go with option 1' after reading the trade-offs ()

Skip-permissions is a context-dependent dial, not a setting: teaching yes, unattended production no ()

The e2e freeze is a real capacity lesson: local test automation + agent build + Zoom exceeded an M1 Pro ()

'This is something we vibe-coded today' — his own label for the day's output, scope honesty to the end ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

What justified skip-permissions here but not in the Hermes Telegram loop?

Blast radius: a local teaching repo with disposable state vs an agent with messaging reach and paid API calls — admin mode is proportional to what a wrong action can touch.

Every concept, three clicks deep

The same concepts as a quick reference: the closed row is the glance, open is the study card, and every timestamp jumps into the recording.

01CLAUDE.md and memory.md: the preloaded prompt and the running logCLAUDE.md = always-loaded behavioral/system prompt (seed from proven guideline sets;›

CLAUDE.md = always-loaded behavioral/system prompt (seed from proven guideline sets; caution-biased); memory.md = command-updated project log (status, decisions, pending); both scoped deliberately (local per project unless a habit is universal); together they make sessions and agents disposable.

Seeding from Karpathy's guidelines is the shoulders-of-giants move applied to the harness itself ()

The preloaded-prompt framing kills the RAG misconception cleanly ()

agents.md/readme.md acknowledged as siblings; his setup uses exactly two files — minimalism as policy ()

Hermes' soul/user/memory (that sprint) and this CLAUDE.md/memory.md are the same architecture with different slicing

02The 50% rule: context degradation, the exit ritual, and clarity over compressionContext discipline = treat ~50% utilization as the degradation line;›

Context discipline = treat ~50% utilization as the degradation line; at the line: complete, log to memory, exit, resume fresh from artifacts; economize tokens through CLARITY and automated memory (Claude-Mem), never through nuance-destroying compression.

The ritual's order matters: memory BEFORE exit — the fresh session's quality depends on what the old one wrote down ()

Claude-Mem vs caveman is the whole token debate in two tools: conserve by remembering, not by mumbling ()

Karpathy's guideline set and the 50% rule are complementary: behavioral caution + state hygiene ()

03Orchestrating skills: superpowers + UI UX Pro Max + design sources, without conflictsSkill orchestration = layered stack (dev-workflow skill + UI skill + design-data sources + testing/security…›

Skill orchestration = layered stack (dev-workflow skill + UI skill + design-data sources + testing/security from marketplaces), community-signal selection, global only for daily drivers, never two overlapping skills in scope, security audit mandatory before shipping.

Design granularity is a choice: whole-vibe (Super Design) vs per-component (21st.dev) — match the tool to how opinionated you are ()

Let the skill choose components rather than pasting thousand-line prompts one by one — delegation inside the design step ()

Anthropic's own web-app-testing skill spotted on skills.sh — first-party skills are entering the marketplaces ()

Security-by-architecture appears in the build itself: the server route 'protects the API key from day one' ()

04Sketch-to-app: a scoped Lovable clone, sub-agents, admin mode, and the GPU-killing finaleSketch-to-app = tldraw/upload → vision model (user-picked via OpenRouter, server-route-protected) → preview…›

Sketch-to-app = tldraw/upload → vision model (user-picked via OpenRouter, server-route-protected) → preview + downloadable code, iterated by chat and re-sketch; built via design doc + 30-task plan, sub-agent dispatch under skip-permissions, memory-checkpointed for recovery; scoped deliberately below its inspiration.

Option analysis is delegated but the CHOICE stays human — 'go with option 1' after reading the trade-offs ()

Skip-permissions is a context-dependent dial, not a setting: teaching yes, unattended production no ()

The e2e freeze is a real capacity lesson: local test automation + agent build + Zoom exceeded an M1 Pro ()

'This is something we vibe-coded today' — his own label for the day's output, scope honesty to the end ()

Tools referenced

ToolCoverageMomentContext
Claude CodedemonstratedThe full advanced setup: CLAUDE.md/memory.md, superpowers + UI UX Pro Max orchestration, sub-agents, --dangerously-skip-permissions, live token metering
AntigravitydemonstratedMirror + warm standby again; 'whenever my Claude fails, I go to my memory and pick it forward'
superpowersdemonstratedThe end-to-end dev workflow skill — brainstorm, design doc, TDD, structured execution; his global daily driver
UI UX Pro MaxdemonstratedThe interface-quality layer (~65k stars as-heard), installed live
Claude-MemdemonstratedAutomated memory capture; '91% reduction from reuse' shown on the model-council repo — 'the best unlock'
skills.shdemonstratedMarketplace picks by installs/stars: e2e-testing patterns, security best-practices; Anthropic's own web-app-testing spotted
21st.devdemonstratedComponent-level design prompts (navbars, pricing, animations) — the per-section alternative to whole-vibe design
Super Design (superdesign.dev)demonstratedThe overall look-and-feel scaffold ('feels like the Lovable type stuff')
PlaywrightdemonstratedThe e2e layer that froze the M1 Pro — agent testing as a hardware workload
OpenRouterdemonstratedUser-selectable vision models behind the key-protecting server route
Wispr FlowdemonstratedDictation through the brainstorm
tldrawexplainedChosen canvas for in-browser sketching (over Excalidraw for this build)
ExcalidrawmentionedCanvas alternative considered and passed over
LovablementionedThe named inspiration, treated respectfully: 'don't expect it to work exactly like Lovable'
Vercelmentioned'Deploy to Vercel in one click later' in the chosen architecture

Action items

Resources mentioned

Resources
  • docKarpathy-derived CLAUDE.md guidelines
  • docContext Rot paper
  • docClaude-Mem
  • docCaveman skill
  • docskills.sh marketplace
  • doc21st.dev + superdesign.dev
  • docPM Skills (Day 1 recap link)

Extraction notes

This page was built from an auto-generated transcript, which garbles product and people's names. Those were corrected silently in everything above and logged here for transparency. The warnings flag claims that were true on the recording day but change fast.

Transcript corrections applied

The transcript saysThe trainer actually means
plot code / cloud code / Glod code / prod dot m d / cloud dot m d / clock dot m dClaude Code / CLAUDE.md
Andre KarpathyAndrej Karpathy
memory dot m b / memory dot m pmemory.md
UI UX Pro Max still / UI UX UX Pro MaxUI UX Pro Max skill
20 first dot dev21st.dev
TL draw / tldraw / TLD drawtldraw
Claude MEM / Claude MIM / cloud mem / Claude memoryClaude-Mem (as-heard skill name)
caveman skillthe token-compression skill (as-heard name)
context rotthe Context Rot research (as-heard citation)
dangerously skip permissions--dangerously-skip-permissions
Opus 4.5 / Gemini 3.1 Pro / Gemini 3 proas-heard model versions at recording (~April 2026)
13000 forked / 1 52000 started / 65000 stars / 33.5 / 32.8 / 14.1 kas-heard repo statistics — treat as approximate
skills dot s hskills.sh
sketch 2 app / sketch to mapsketch-to-app (the build)
e to e / e 2 eend-to-end (testing)
MacBook m 1 ProMacBook Pro (M1 Pro)
KVS Dilip / Delip / the lipDileep (KVSS Dileep)
hot in Bangalore(color: he's teaching from Bangalore)

True on recording day — verify before relying