Learn Claude
Build Better Agents

87 engineering skills, 7 deployable asset kits, 5 interactive labs. Learn patterns, generate artifacts, deploy to ecosystem.

学结构,不学泄露 · Study structure, not stolen code
87
Skills
14
Discoveries
7
Asset Kits
5
Labs
23
Ecosystem Tools
V5.3
Standard

Complete Discoveries

14 Engineering Patterns — Zero Gaps

Every significant public discovery from the Claude Code event, mapped to LightHope ecosystem value. Click any card for full analysis.

🌙
KAIROS — Always-On Daemon
A persistent background agent that never sleeps
P0CoreCode
💭
autoDream — Memory Consolidation
AI that dreams — reorganizing memory while you sleep
P0CoreCode
🧠
ULTRAPLAN — Cloud Deep Planning
30 minutes of autonomous deep thinking on cloud Opus
P1InfraCode
🎯
Coordinator Mode — Multi-Agent Orchestration
One Claude orchestrating a team of parallel worker agents
P1CoreCode
🐾
BUDDY — Companion Pet System
A Tamagotchi-style terminal pet with 18 species and gacha mechanics
P2ProductCode
🚩
44 Feature Flags — Hidden Roadmap
A complete product roadmap hiding behind compile-time gates
P1MetaCode
🕵️
Undercover Mode — Stealth Attribution
Auto-strips AI identity when contributing to public repos
P2SecurityCode
🛡️
Anti-Distillation — Training Data Poisoning
Fake tools injected to corrupt competitor training data
P2SecurityCode
🧹
Context Entropy Solution — 5 Compaction Strategies
How to prevent AI from going crazy in long sessions
P1InfraCode
🏷️
Internal Model Codenames
Tengu, Capybara, Fennec, Numbat — and what comes next
P2Meta
👁️
Advisor Agent — Session Overseer
A second AI watching the first AI work
P1CoreCode
🔧
Tool Architecture — 40+ Plugin System
Every capability is a discrete, permission-gated tool
P1InfraCode
😤
User Frustration Detection
Regex-based sentiment analysis — 'the world's most expensive company using regex'
P2Product
📬
UDS Inbox — Inter-Agent Communication
Unix domain sockets for agent-to-agent messaging on the same machine
P2InfraCode
🧠
Extended Thinking — Deep Reasoning Budget
Allocating compute budget for chain-of-thought before responding
P0CoreCode
🏭
Managed Agents API — Server-Side Agent Lifecycle
Persistent server-side agents with sessions and memory
P0InfraCode
🔌
MCP — Model Context Protocol Architecture
Universal standard for connecting AI to external tools and data
P0InfraCode
💾
Prompt Caching — Token Cost Optimization
Cache static prompt sections to cut costs by 90%
P1Infra
🖥️
Computer Use — GUI Automation via Vision
AI that sees and clicks — visual interface automation
P1CoreCode
📁
Files API — Persistent Content Storage
Upload files once, reference across multiple conversations
P1Infra
⚙️
Agent SDK — Programmatic Agent Loop
Build custom agents in code — the loop is yours to control
P0CoreCode
🌊
Streaming Tool Use — Real-Time Agent Actions
Stream agent reasoning and tool calls as they happen
P1Infra
👻
Ambient Agents — Background Autonomous Execution
AI agents that work while you sleep
P0CoreCode
🪝
Hooks System — Standards as Automated Checkpoints
Every standard becomes an executable checkpoint
P1InfraCode

Context

What Actually Happened

On March 31, 2026, Claude Code v2.1.88 shipped with a 59.8 MB .map source map file that exposed ~512,000 lines of TypeScript across ~1,900 files. This was a build pipeline misconfiguration — a missing .npmignore entry — not a security breach. No customer data or model weights were exposed.

This was Anthropic's second source map leak (the first was February 2025) and came just days after a separate incident exposed ~3,000 files including details about an upcoming model codenamed Mythos/Capybara. The leaked codebase revealed 44 feature flags for fully-built but unshipped capabilities, internal model codenames, performance benchmarks, and the complete architecture of a production-grade AI coding agent.

What makes this event valuable for learning is not the code — which is proprietary and must not be redistributed — but the engineering patterns it confirmed: multi-layer memory architecture, lifecycle hooks, reusable skills, specialized subagents, autonomous background workflows, advisor agents, multi-agent coordination, and deeply engineered context management.


Key Engineering Insights

6 Patterns Worth Internalizing

01
Rules as Memory, Not Repetition
Don't repeat instructions every session. Encode naming conventions, frameworks, and procedures as persistent project memory. Claude Code's 3-layer architecture (index → topic → transcript) is the reference pattern.
02
Standards as Hooks, Not Hope
The leak itself was caused by a process gap. Every check that depends on someone remembering should become an automated hook. V5.3 compliance checks belong in pre-deploy hooks.
03
Complex Work as Agent Delegation
Don't let one agent handle everything. Fork for independent tasks, Teammate for shared context, Worktree for code isolation. The autoDream consolidation runs as a forked subagent for exactly this reason.
04
Quality via Advisor Pattern
The advisor agent watches the worker agent work and provides real-time evaluation. This maps directly to m8002 (quality control) as an automated oversight agent.
05
Products as Agent Loops, Not Chat Boxes
Claude Code is not a UI — it's a loop: plan → tool-select → execute → observe → decide → repeat. 40 tools, 46K-line query engine, 5 compaction strategies, 23 security checks on bash alone.
06
Feature Gates as Maturity Model
44 flags = 44 capabilities at different stages. This maps directly to V5.3's S0-S5 maturity model. Ship features behind gates, promote when ready, roll back when broken.
07
Pipeline over Monolith
Don't build one project that does everything. Build five projects that each do one thing well and chain them: m8100 (search) → m590 (compile) → m495 (skill) → m553 (media) → m595 (consume). Each project is independently deployable, testable, and upgradable.
08
Bot 60%, Human 40% — The Testing Boundary
From 154 automated game traversals: bots verify mechanics (60%), humans verify emotion (40%). Together they cover 100%. Don't try to automate everything — know precisely where automation stops and human judgment begins.
09
Knowledge as Structured Feed, Not Free Text
m8100 doesn't feed m590 with prose documents. It feeds structured JSONL records with typed fields (topic, domain, source, confidence, tags). Structure enables automated compilation, quality gates, and provenance tracking. Free text is a dead end.
10
FROZEN_LAWS as Game Design Invariants
m595 COMPASS has 4 immutable laws that never change regardless of game updates. These are the architectural invariants. Good systems have explicit invariants — things that are guaranteed to never change — not just features.
11
Realism Score Before Fun Score
m595 achieved Realism 100/100 before Fun Score 76.9/100. Build authenticity first, then tune for engagement. A realistic but less fun game can be tuned. A fun but unrealistic game must be rebuilt from scratch.
12
Deception Layers are Domain Knowledge
m595 COMPASS models 3 deception layers (misinformation, impersonation, signal manipulation). These aren't features — they're domain expertise encoded as game mechanics. The deepest domain knowledge becomes the most compelling gameplay.
13
MCP as Ecosystem Connective Tissue
m556 MemoryBridge proves MCP works at ecosystem scale: 17+ tools, 25+ project snapshots, consumed by any AI assistant. MCP eliminates the N×M integration problem — one protocol connects everything.
14
Extended Thinking for High-Stakes Decisions Only
Extended thinking adds cost and latency. Reserve it for high-stakes decisions: architecture planning, CSAR mission routing, knowledge quality gates. Routine tasks (formatting, lookup, simple edits) don't need deliberation.
15
Ambient Agents Complete the Automation Spectrum
Three automation patterns cover all needs: KAIROS (periodic tick), Ambient Agents (event-driven), ULTRAPLAN (on-demand deep thinking). If your system needs automation, it's one of these three patterns.
16
Standards from Practice, Not Theory
Every V2.0 PROVEN standard came from real execution: 154 game traversals, 5,025 API calls, 7,200 LOC. Standards aren't designed in documents — they're discovered in production and then codified.
17
Real Events Validate Game Design
The 2026 Iran F-15E rescue validated all 4 FROZEN_LAWS of m595 COMPASS against a real CSAR operation. When reality matches your game design, your domain modeling is correct. Don't wait for fiction — study what just happened.
18
Rescue Creates Rescue — Cascading Risk
The A-10 was lost rescuing the F-15E crew. The MC-130J got stuck extracting the SOF team. The C-295W rescued the rescuers of the rescuers. Every action to help creates new vulnerability. This is the 5th invariant: the chain never ends cleanly.
19
Deception Has Four Layers, Not Three
m595 originally modeled 3 deception layers (misinformation, impersonation, signal manipulation). The real event revealed Layer 4: institutional deception — CIA running strategic disinformation through media and government channels. Update the model.
20
155 Aircraft for 2 People = The Compass
The Iran CSAR deployed 155 aircraft, destroyed $200M+ in equipment, and killed an enemy general — all for 2 crew members. This IS the compass. The game's central question isn't 'can you save them?' but 'why do you save them?' The answer defines civilization.
21
Civilians Are the Battlefield, Not Background
Bakhtiari nomads armed with hunting rifles and terrain knowledge hunted the WSO. $60,000 bounty turned every civilian into a potential captor. CIA used civilian assets to help. The population is not scenery — it is the most complex variable in CSAR.
22
'God is good' — Simplest Signals Carry Most Weight
The WSO's only transmission was 'God is good.' Three functions in three words: proof of life, authentication seed, and declaration of faith. In game design and in life, the most powerful moments are the simplest. Don't overdesign emotional beats.
23
Plans Fail, Contingencies Save
MC-130J was the plan. It got stuck in mud. C-295W was the contingency. It saved the mission. Always have PACE (Primary, Alternate, Contingency, Emergency). The real lesson: the primary plan is the one that fails. The contingency is the one that works.
24
Rank Changes the Calculus
The WSO was a colonel — carrier of classified knowledge about force structure and operations plans. His capture would be an intelligence catastrophe beyond the human cost. In game design: who you're rescuing changes everything. A lieutenant vs. a colonel = different strategic pressure, different enemy motivation, different resource allocation.
25
The Ceasefire Irony
Ceasefire came 48 hours after the $200M rescue. If they had waited, would the WSO have been returned? The question has no answer — and that IS the design. Retrospective irony forces reexamination of every decision. The game's epilogue should reveal this timing.
26
Losing the War, Winning the Moment
190 missile launchers and 155 naval vessels destroyed, yet one soldier with a MANPADS downed an F-15E. Strategic defeat doesn't eliminate tactical threat. In game design: macro-superiority doesn't guarantee micro-safety. The most dangerous threat is the one you didn't see.
27
Six Perspectives = Six Different Games
The same CSAR event played as Survivor, Commander, Sandy, Spook, Night Stalker, or Nomad is six completely different games. Each has unique mechanics, information access, and moral dilemmas. Multi-role design doesn't just add replayability — it teaches empathy by forcing you to see the same event through different eyes.
28
Leave No One Behind Is a Contract, Not a Slogan
Military.com: 'That belief changes behavior.' Service members operate decisively because they believe they will be recovered. The rescue ethos shapes recruitment, retention, and operational courage. Breaking this contract would damage everything. The compass isn't just about the rescued — it's about everyone who might be next.

Explore

Navigate the Platform