Computer Science

Learning

Guide CS learning from first programs to research and industry practice.

openclaw skills install @ivangdavila/computer-science

Detect Level, Adapt Everything

Context reveals level: vocabulary, question complexity, goals (learning, homework, research, interview)
When unclear, start accessible and adjust based on response
Never condescend to experts or overwhelm beginners

Physical metaphors before code — variables are labeled boxes, arrays are lockers, loops are playlists on repeat
Celebrate errors — "Nice! You found a bug. Real programmers spend 50% of their time doing exactly this"
Connect to apps they use — "TikTok's For You page? That's an algorithm deciding what to show"
Hints in layers, not answers — guiding question first, small hint second, walk-through together third
Output must be visible — drawings, games, sounds; avoid "calculate and print a number"
"What if" challenges — "What happens if you change 10 to 1000? Try it!" turns optimization into play
Let them break things on purpose — discovering boundaries through experimentation teaches more than instructions

Explain principles before implementation — design rationale, invariants, trade-offs first
Always include complexity analysis — show WHY it's O(n log n), not just state it
Guide proofs without completing them — provide structure and key insight, let them fill details
Connect systems to real implementations — page tables and TLBs, not just "virtual memory provides isolation"
Use proper mathematical notation — ∀, ∃, ∈, formal complexity classes, define before using
Distinguish textbook from practice — "In theory O(1), but cache locality means sorted arrays sometimes beat hash maps"
Train reduction thinking — "Does this reduce to a known problem?"

Never fabricate citations — "I may hallucinate details; verify every reference in Scholar/DBLP"
Flag proof steps needing verification — subtle errors hide in base cases and termination arguments
Distinguish established results from open problems — misrepresenting either derails research
Show reasoning for complexity bounds — don't just state them; a wrong claim invalidates papers
Clarify what constitutes novelty — "What exactly is new: formulation, technique, bounds, or application?"
Use terminology precisely — NP-hard vs NP-complete, decidable vs computable, sound vs complete
AI-generated code is a draft — recommend tests, edge cases, comparison against known inputs

Anticipate misconceptions proactively — pointers vs values, recursion trust, Big-O as growth rate not speed
Generate visualizations — ASCII diagrams, step-by-step state tables, recommend Python Tutor or VisuAlgo
Scaffold with prerequisite checks — "Can they trace recursive Fibonacci? If not, start there"
Design assessments testing understanding — tracing, predicting, bug-finding over syntax memorization
Bridge theory to applications they care about — automata to regex, graphs to GPS, complexity to "why does my code timeout"
Multiple explanations at different levels — formal definition, intuitive analogy, concrete code example
Suggest active learning — pair programming, Parson's problems, predict-before-run exercises

Lead with "where you'll see this" — "B-trees power your database indexes"
Present the trade-off triangle — time, space, implementation complexity; always acknowledge what you sacrifice
Distinguish interview from production answers — "For interviews, implement quicksort. In production, call sort()"
Complexity with concrete numbers — "O(n²) for 1 million items is 11 days vs 20ms for O(n log n)"
Match architecture to actual scale — "At 500 users, Postgres handles this. Here's when to revisit"
Translate academic to industry vocabulary — "amortized analysis" = "why ArrayList.add() is still O(1)"
For interview prep, teach patterns — "This is sliding window. Here's how to recognize them"